ceph-dencoder: Add missing common types to ceph-dencoder for accurate encode-decode...

Currently, ceph-dencoder lacks certain common types, preventing us from accurately checking the ceph corpus for encode-decode mismatches.
This pull request aims to address this issue by adding the missing types to ceph-dencoder.

To successfully incorporate these types into ceph-dencoder, we need to introduce the necessary dump and generate_test_instances functions that was missing in some types.
These functions are essential for proper encode and decode of the added types.

This PR will enhance the functionality of ceph-dencoder by including the missing types, enabling a comprehensive analysis of encode-decode consistency.
With the addition of these types, we can ensure the robustness and correctness of the ceph corpus.

This update will significantly contribute to improving the overall reliability and accuracy of ceph-dencoder.
It allows for a more comprehensive assessment of the encode-decode behavior,
leading to enhanced data integrity and stability within the ceph ecosystem.

Fixes: https://tracker.ceph.com/issues/61788
Signed-off-by: Nitzan Mordechai <nmordech@redhat.com>

diff --git a/src/auth/Auth.h b/src/auth/Auth.h
index 5521c8d3fcf0e719796846876205fcb73e6c9468..83e23b34dbe3a0241aabda17cee706657ab711aa 100644 (file)
--- a/src/auth/Auth.h
+++ b/src/auth/Auth.h
@@ -16,6 +16,7 @@
 #define CEPH_AUTHTYPES_H
 
 #include "Crypto.h"
+#include "common/ceph_json.h"
 #include "common/entity_name.h"
 
 // The _MAX values are a bit wonky here because we are overloading the first
@@ -59,6 +60,14 @@ struct EntityAuth {
       decode(pending_key, bl);
     }
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("key", key);
+    encode_json("caps", caps, f);
+    f->dump_object("pending_key", pending_key);
+  }
+  static void generate_test_instances(std::list<EntityAuth*>& ls) {
+    ls.push_back(new EntityAuth);
+  }
 };
 WRITE_CLASS_ENCODER(EntityAuth)
 
@@ -95,6 +104,19 @@ struct AuthCapsInfo {
     allow_all = (bool)a;
     decode(caps, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_bool("allow_all", allow_all);
+    encode_json("caps", caps, f);
+    f->dump_unsigned("caps_len", caps.length());
+  }
+  static void generate_test_instances(std::list<AuthCapsInfo*>& ls) {
+    ls.push_back(new AuthCapsInfo);
+    ls.push_back(new AuthCapsInfo);
+    ls.back()->allow_all = true;
+    ls.push_back(new AuthCapsInfo);
+    ls.back()->caps.append("foo");
+    ls.back()->caps.append("bar");
+  }
 };
 WRITE_CLASS_ENCODER(AuthCapsInfo)
 
@@ -147,6 +169,25 @@ struct AuthTicket {
     decode(caps, bl);
     decode(flags, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("name", name);
+    f->dump_unsigned("global_id", global_id);
+    f->dump_stream("created") << created;
+    f->dump_stream("renew_after") << renew_after;
+    f->dump_stream("expires") << expires;
+    f->dump_object("caps", caps);
+    f->dump_unsigned("flags", flags);
+  }
+  static void generate_test_instances(std::list<AuthTicket*>& ls) {
+    ls.push_back(new AuthTicket);
+    ls.push_back(new AuthTicket);
+    ls.back()->name.set_id("client.123");
+    ls.back()->global_id = 123;
+    ls.back()->init_timestamps(utime_t(123, 456), 7);
+    ls.back()->caps.caps.append("foo");
+    ls.back()->caps.caps.append("bar");
+    ls.back()->flags = 0x12345678;
+  }
 };
 WRITE_CLASS_ENCODER(AuthTicket)
 
@@ -231,6 +272,16 @@ struct ExpiringCryptoKey {
     decode(key, bl);
     decode(expiration, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("key", key);
+    f->dump_stream("expiration") << expiration;
+  }
+  static void generate_test_instances(std::list<ExpiringCryptoKey*>& ls) {
+    ls.push_back(new ExpiringCryptoKey);
+    ls.push_back(new ExpiringCryptoKey);
+    ls.back()->key.set_secret(
+      CEPH_CRYPTO_AES, bufferptr("1234567890123456", 16), utime_t(123, 456));
+  }
 };
 WRITE_CLASS_ENCODER(ExpiringCryptoKey)
 
@@ -295,6 +346,15 @@ struct RotatingSecrets {
   }
 
   void dump();
+  void dump(ceph::Formatter *f) const {
+    encode_json("secrets", secrets, f);
+  }
+  static void generate_test_instances(std::list<RotatingSecrets*>& ls) {
+    ls.push_back(new RotatingSecrets);
+    ls.push_back(new RotatingSecrets);
+    auto eck = new ExpiringCryptoKey;
+    ls.back()->add(*eck);
+  }
 };
 WRITE_CLASS_ENCODER(RotatingSecrets)
 

diff --git a/src/auth/Crypto.cc b/src/auth/Crypto.cc
index ce666e8bdc8c3c8f266f133927136c2ede325d9b..5d68d3470bc04cf32f5902a7db3b0a3232f23045 100644 (file)
--- a/src/auth/Crypto.cc
+++ b/src/auth/Crypto.cc
@@ -511,6 +511,23 @@ void CryptoKey::decode(bufferlist::const_iterator& bl)
     throw ceph::buffer::malformed_input("malformed secret");
 }
 
+void CryptoKey::dump(Formatter *f) const
+{
+  f->dump_int("type", type);
+  f->dump_stream("created") << created;
+  f->dump_int("secret.length", secret.length());
+}
+
+void CryptoKey::generate_test_instances(std::list<CryptoKey*>& ls)
+{
+  ls.push_back(new CryptoKey);
+  ls.push_back(new CryptoKey);
+  ls.back()->type = CEPH_CRYPTO_AES;
+  ls.back()->set_secret(
+    CEPH_CRYPTO_AES, bufferptr("1234567890123456", 16), utime_t(123, 456));
+  ls.back()->created = utime_t(123, 456);
+}
+
 int CryptoKey::set_secret(int type, const bufferptr& s, utime_t c)
 {
   int r = _set_secret(type, s);

diff --git a/src/auth/Crypto.h b/src/auth/Crypto.h
index a29ac1abd8116fd2dcb940acba39f4c64036c97d..3ce655a12562c903ef60069e966dcf729857aa80 100644 (file)
--- a/src/auth/Crypto.h
+++ b/src/auth/Crypto.h
@@ -111,6 +111,8 @@ public:
 
   void encode(ceph::buffer::list& bl) const;
   void decode(ceph::buffer::list::const_iterator& bl);
+  void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<CryptoKey*>& ls);
 
   void clear() {
     *this = CryptoKey();

diff --git a/src/auth/cephx/CephxKeyServer.cc b/src/auth/cephx/CephxKeyServer.cc
index 236ac451add9ab72ea769c3d22da3f914c5b9245..a5ad1f2b7973c9a1657557886e444be5b94b7663 100644 (file)
--- a/src/auth/cephx/CephxKeyServer.cc
+++ b/src/auth/cephx/CephxKeyServer.cc
@@ -257,6 +257,16 @@ std::map<EntityName,CryptoKey> KeyServer::get_used_pending_keys()
   return ret;
 }
 
+void KeyServer::dump(Formatter *f) const
+{
+  f->dump_object("data", data);
+}
+
+void KeyServer::generate_test_instances(std::list<KeyServer*>& ls)
+{
+  ls.push_back(new KeyServer(nullptr, nullptr));
+}
+
 bool KeyServer::generate_secret(CryptoKey& secret)
 {
   bufferptr bp;

diff --git a/src/auth/cephx/CephxKeyServer.h b/src/auth/cephx/CephxKeyServer.h
index 64915c8ce4aaca2724b7dad027276db0c85cf651..d147dd441ad2447d403d54fcc202188bdaeed89d 100644 (file)
--- a/src/auth/cephx/CephxKeyServer.h
+++ b/src/auth/cephx/CephxKeyServer.h
@@ -21,15 +21,16 @@
 #include "include/common_fwd.h"
 
 struct KeyServerData {
-  version_t version;
+  version_t version{0};
 
   /* for each entity */
   std::map<EntityName, EntityAuth> secrets;
-  KeyRing *extra_secrets;
+  KeyRing *extra_secrets = nullptr;
 
   /* for each service type */
-  version_t rotating_ver;
+  version_t rotating_ver{0};
   std::map<uint32_t, RotatingSecrets> rotating_secrets;
+  KeyServerData() {}
 
   explicit KeyServerData(KeyRing *extra)
     : version(0),
@@ -70,7 +71,17 @@ struct KeyServerData {
     decode(rotating_ver, iter);
     decode(rotating_secrets, iter);
   }
-
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("version", version);
+    f->dump_unsigned("rotating_version", rotating_ver);
+    encode_json("secrets", secrets, f);
+    encode_json("rotating_secrets", rotating_secrets, f);
+  }
+  static void generate_test_instances(std::list<KeyServerData*>& ls) {
+    ls.push_back(new KeyServerData);
+    ls.push_back(new KeyServerData);
+    ls.back()->version = 1;
+  }
   bool contains(const EntityName& name) const {
     return (secrets.find(name) != secrets.end());
   }
@@ -159,8 +170,21 @@ struct KeyServerData {
        decode(auth, bl);
       }
     }
+    void dump(ceph::Formatter *f) const {
+      f->dump_unsigned("op", op);
+      f->dump_object("name", name);
+      f->dump_object("auth", auth);
+    }
+    static void generate_test_instances(std::list<Incremental*>& ls) {
+      ls.push_back(new Incremental);
+      ls.back()->op = AUTH_INC_DEL;
+      ls.push_back(new Incremental);
+      ls.back()->op = AUTH_INC_ADD;
+      ls.push_back(new Incremental);
+      ls.back()->op = AUTH_INC_SET_ROTATING;
+    }
   };
-
+  
   void apply_incremental(Incremental& inc) {
     switch (inc.op) {
     case AUTH_INC_ADD:
@@ -188,8 +212,6 @@ WRITE_CLASS_ENCODER(KeyServerData)
 WRITE_CLASS_ENCODER(KeyServerData::Incremental)
 
 
-
-
 class KeyServer : public KeyStore {
   CephContext *cct;
   KeyServerData data;
@@ -205,7 +227,9 @@ class KeyServer : public KeyStore {
   bool _get_service_caps(const EntityName& name, uint32_t service_id,
        AuthCapsInfo& caps) const;
 public:
+  KeyServer() : lock{ceph::make_mutex("KeyServer::lock")} {}
   KeyServer(CephContext *cct_, KeyRing *extra_secrets);
+  KeyServer& operator=(const KeyServer&) = delete;
   bool generate_secret(CryptoKey& secret);
 
   bool get_secret(const EntityName& name, CryptoKey& secret) const override;
@@ -248,6 +272,8 @@ public:
     using ceph::decode;
     decode(data, bl);
   }
+  void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<KeyServer*>& ls);
   bool contains(const EntityName& name) const;
   int encode_secrets(ceph::Formatter *f, std::stringstream *ds) const;
   void encode_formatted(std::string label, ceph::Formatter *f, ceph::buffer::list &bl);

diff --git a/src/auth/cephx/CephxProtocol.h b/src/auth/cephx/CephxProtocol.h
index aabfaaad10c93428258332ecaf0f7e05298acbb8..260cb13ff5abdc28e6b4da4fb0ff0f271a6e64dc 100644 (file)
--- a/src/auth/cephx/CephxProtocol.h
+++ b/src/auth/cephx/CephxProtocol.h
@@ -55,6 +55,13 @@ struct CephXServerChallenge {
     decode(struct_v, bl);
     decode(server_challenge, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("server_challenge", server_challenge);
+  }
+  static void generate_test_instances(std::list<CephXServerChallenge*>& ls) {
+    ls.push_back(new CephXServerChallenge);
+    ls.back()->server_challenge = 1;
+  }
 };
 WRITE_CLASS_ENCODER(CephXServerChallenge)
 
@@ -72,6 +79,13 @@ struct CephXRequestHeader {
     using ceph::decode;
     decode(request_type, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("request_type", request_type);
+  }
+  static void generate_test_instances(std::list<CephXRequestHeader*>& ls) {
+    ls.push_back(new CephXRequestHeader);
+    ls.back()->request_type = 1;
+  }
 };
 WRITE_CLASS_ENCODER(CephXRequestHeader)
 
@@ -89,6 +103,15 @@ struct CephXResponseHeader {
     decode(request_type, bl);
     decode(status, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("request_type", request_type);
+    f->dump_int("status", status);
+  }
+  static void generate_test_instances(std::list<CephXResponseHeader*>& ls) {
+    ls.push_back(new CephXResponseHeader);
+    ls.back()->request_type = 1;
+    ls.back()->status = 0;
+  }
 };
 WRITE_CLASS_ENCODER(CephXResponseHeader)
 
@@ -113,6 +136,17 @@ struct CephXTicketBlob {
      decode(secret_id, bl);
      decode(blob, bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("secret_id", secret_id);
+    f->dump_unsigned("blob_len", blob.length());
+  }
+
+  static void generate_test_instances(std::list<CephXTicketBlob*>& ls) {
+    ls.push_back(new CephXTicketBlob);
+    ls.back()->secret_id = 123;
+    ls.back()->blob.append(std::string_view("this is a blob"));
+  }
 };
 WRITE_CLASS_ENCODER(CephXTicketBlob)
 
@@ -152,6 +186,25 @@ struct CephXAuthenticate {
     //   old_ticket both on reconnects and renewals
     old_ticket_may_be_omitted = struct_v < 3;
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("client_challenge", client_challenge);
+    f->dump_unsigned("key", key);
+    f->open_object_section("old_ticket");
+    old_ticket.dump(f);
+    f->close_section();
+    f->dump_unsigned("other_keys", other_keys);
+  }
+  static void generate_test_instances(std::list<CephXAuthenticate*>& ls) {
+    ls.push_back(new CephXAuthenticate);
+    ls.back()->client_challenge = 0;
+    ls.back()->key = 0;
+    ls.push_back(new CephXAuthenticate);
+    ls.back()->client_challenge = 1;
+    ls.back()->key = 2;
+    ls.back()->old_ticket.secret_id = 3;
+    ls.back()->old_ticket.blob.append(std::string_view("this is a blob"));
+    ls.back()->other_keys = 4;
+  }
 };
 WRITE_CLASS_ENCODER(CephXAuthenticate)
 
@@ -168,6 +221,15 @@ struct CephXChallengeBlob {
     decode(server_challenge, bl);
     decode(client_challenge, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("server_challenge", server_challenge);
+    f->dump_unsigned("client_challenge", client_challenge);
+  }
+  static void generate_test_instances(std::list<CephXChallengeBlob*>& ls) {
+    ls.push_back(new CephXChallengeBlob);
+    ls.back()->server_challenge = 123;
+    ls.back()->client_challenge = 456;
+  }
 };
 WRITE_CLASS_ENCODER(CephXChallengeBlob)
 
@@ -218,6 +280,15 @@ struct CephXServiceTicketRequest {
     decode(struct_v, bl);
     decode(keys, bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("keys", keys);
+  }
+
+  static void generate_test_instances(std::list<CephXServiceTicketRequest*>& ls) {
+    ls.push_back(new CephXServiceTicketRequest);
+    ls.back()->keys = 123;
+  }
 };
 WRITE_CLASS_ENCODER(CephXServiceTicketRequest)
 
@@ -251,6 +322,17 @@ struct CephXAuthorizeReply {
       decode(connection_secret, bl);
     }
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("nonce_plus_one", nonce_plus_one);
+    f->dump_string("connection_secret", connection_secret);
+  }
+  static void generate_test_instances(std::list<CephXAuthorizeReply*>& ls) {
+    ls.push_back(new CephXAuthorizeReply);
+    ls.back()->nonce_plus_one = 0;
+    ls.push_back(new CephXAuthorizeReply);
+    ls.back()->nonce_plus_one = 123;
+    ls.back()->connection_secret = "secret";
+  }
 };
 WRITE_CLASS_ENCODER(CephXAuthorizeReply)
 
@@ -353,6 +435,17 @@ struct CephXServiceTicket {
     decode(session_key, bl);
     decode(validity, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    session_key.dump(f);
+    validity.dump(f);
+  }
+  static void generate_test_instances(std::list<CephXServiceTicket*>& ls) {
+    ls.push_back(new CephXServiceTicket);
+    ls.push_back(new CephXServiceTicket);
+    ls.back()->session_key.set_secret(
+      CEPH_CRYPTO_AES, bufferptr("1234567890123456", 16), utime_t(123, 456));
+    ls.back()->validity = utime_t(123, 456);
+  }
 };
 WRITE_CLASS_ENCODER(CephXServiceTicket)
 
@@ -375,6 +468,18 @@ struct CephXServiceTicketInfo {
     decode(ticket, bl);
     decode(session_key, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    ticket.dump(f);
+    session_key.dump(f);
+  }
+  static void generate_test_instances(std::list<CephXServiceTicketInfo*>& ls) {
+    ls.push_back(new CephXServiceTicketInfo);
+    ls.push_back(new CephXServiceTicketInfo);
+    ls.back()->ticket.global_id = 1234;
+    ls.back()->ticket.init_timestamps(utime_t(123, 456), utime_t(123, 456));
+    ls.back()->session_key.set_secret(
+      CEPH_CRYPTO_AES, bufferptr("1234567890123456", 16), utime_t(123, 456));
+  }
 };
 WRITE_CLASS_ENCODER(CephXServiceTicketInfo)
 
@@ -392,6 +497,13 @@ struct CephXAuthorizeChallenge : public AuthAuthorizerChallenge {
     decode(struct_v, bl);
     decode(server_challenge, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("server_challenge", server_challenge);
+  }
+  static void generate_test_instances(std::list<CephXAuthorizeChallenge*>& ls) {
+    ls.push_back(new CephXAuthorizeChallenge);
+    ls.back()->server_challenge = 1234;
+  }
 };
 WRITE_CLASS_ENCODER(CephXAuthorizeChallenge)
 
@@ -417,6 +529,18 @@ struct CephXAuthorize {
       decode(server_challenge_plus_one, bl);
     }
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("nonce", nonce);
+    f->dump_unsigned("have_challenge", have_challenge);
+    f->dump_unsigned("server_challenge_plus_one", server_challenge_plus_one);
+  }
+  static void generate_test_instances(std::list<CephXAuthorize*>& ls) {
+    ls.push_back(new CephXAuthorize);
+    ls.push_back(new CephXAuthorize);
+    ls.back()->nonce = 1234;
+    ls.back()->have_challenge = true;
+    ls.back()->server_challenge_plus_one = 1234;
+  }
 };
 WRITE_CLASS_ENCODER(CephXAuthorize)
 

diff --git a/src/cls/2pc_queue/cls_2pc_queue_ops.h b/src/cls/2pc_queue/cls_2pc_queue_ops.h
index bb61ef341ac1e8523569beb3a815b46a12a4c999..3cdfd9663e8df4959bbf99981b24617faf007b87 100644 (file)
--- a/src/cls/2pc_queue/cls_2pc_queue_ops.h
+++ b/src/cls/2pc_queue/cls_2pc_queue_ops.h
@@ -3,12 +3,13 @@
 
 #pragma once
 
+#include "common/ceph_json.h"
 #include "include/types.h"
 #include "cls_2pc_queue_types.h"
 
 struct cls_2pc_queue_reserve_op {
   uint64_t size;
-  uint32_t entries;
+  uint32_t entries{0};
 
   void encode(ceph::buffer::list& bl) const {
     ENCODE_START(1, 1, bl);
@@ -23,6 +24,19 @@ struct cls_2pc_queue_reserve_op {
     decode(entries, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("size", size);
+    f->dump_unsigned("entries", entries);
+  }
+
+  static void generate_test_instances(std::list<cls_2pc_queue_reserve_op*>& ls) {
+    ls.push_back(new cls_2pc_queue_reserve_op);
+    ls.back()->size = 0;
+    ls.push_back(new cls_2pc_queue_reserve_op);
+    ls.back()->size = 123;
+    ls.back()->entries = 456;
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_queue_reserve_op)
 
@@ -40,6 +54,15 @@ struct cls_2pc_queue_reserve_ret {
     decode(id, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("id", id);
+  }
+
+  static void generate_test_instances(std::list<cls_2pc_queue_reserve_ret*>& ls) {
+    ls.push_back(new cls_2pc_queue_reserve_ret);
+    ls.back()->id = 123;
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_queue_reserve_ret)
 
@@ -61,6 +84,19 @@ struct cls_2pc_queue_commit_op {
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("id", id);
+    encode_json("bl_data_vec", bl_data_vec, f);
+  }
+
+  static void generate_test_instances(std::list<cls_2pc_queue_commit_op*>& ls) {
+    ls.push_back(new cls_2pc_queue_commit_op);
+    ls.back()->id = 123;
+    ls.back()->bl_data_vec.push_back(ceph::buffer::list());
+    ls.back()->bl_data_vec.back().append("foo");
+    ls.back()->bl_data_vec.push_back(ceph::buffer::list());
+    ls.back()->bl_data_vec.back().append("bar");
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_queue_commit_op)
 
@@ -78,6 +114,13 @@ struct cls_2pc_queue_abort_op {
     decode(id, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("id", id);
+  }
+  static void generate_test_instances(std::list<cls_2pc_queue_abort_op*>& ls) {
+    ls.push_back(new cls_2pc_queue_abort_op);
+    ls.back()->id = 1;
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_queue_abort_op)
 
@@ -96,6 +139,14 @@ struct cls_2pc_queue_expire_op {
     decode(stale_time, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_stream("stale_time") << stale_time;
+  }
+  static void generate_test_instances(std::list<cls_2pc_queue_expire_op*>& ls) {
+    ls.push_back(new cls_2pc_queue_expire_op);
+    ls.push_back(new cls_2pc_queue_expire_op);
+    ls.back()->stale_time = ceph::coarse_real_time::min();
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_queue_expire_op)
 
@@ -113,6 +164,23 @@ struct cls_2pc_queue_reservations_ret {
     decode(reservations, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->open_array_section("reservations");
+    for (const auto& i : reservations) {
+      f->open_object_section("reservation");
+      f->dump_unsigned("id", i.first);
+      i.second.dump(f);
+      f->close_section();
+    }
+    f->close_section();
+  }
+
+  static void generate_test_instances(std::list<cls_2pc_queue_reservations_ret*>& ls) {
+    ls.push_back(new cls_2pc_queue_reservations_ret);
+    ls.push_back(new cls_2pc_queue_reservations_ret);
+    ls.back()->reservations[1] = cls_2pc_reservation();
+    ls.back()->reservations[2] = cls_2pc_reservation();
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_queue_reservations_ret)
 

diff --git a/src/cls/2pc_queue/cls_2pc_queue_types.h b/src/cls/2pc_queue/cls_2pc_queue_types.h
index 2413fd7043da0cb10d990fb4c1754663821ec134..b270c9d6e790b45abb71f5f99e6fa04df2440f51 100644 (file)
--- a/src/cls/2pc_queue/cls_2pc_queue_types.h
+++ b/src/cls/2pc_queue/cls_2pc_queue_types.h
@@ -34,6 +34,19 @@ struct cls_2pc_reservation
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("size", size);
+    f->dump_stream("timestamp") << timestamp;
+  }
+
+  static void generate_test_instances(std::list<cls_2pc_reservation*>& ls) {
+    ls.push_back(new cls_2pc_reservation);
+    ls.back()->size = 0;
+    ls.push_back(new cls_2pc_reservation);
+    ls.back()->size = 123;
+    ls.back()->timestamp = ceph::coarse_real_clock::zero();
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_reservation)
 
@@ -68,5 +81,28 @@ struct cls_2pc_urgent_data
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("reserved_size", reserved_size);
+    f->dump_unsigned("last_id", last_id);
+    f->open_array_section("reservations");
+    for (const auto& [id, res] : reservations) {
+      f->open_object_section("reservation");
+      f->dump_unsigned("id", id);
+      res.dump(f);
+      f->close_section();
+    }
+    f->close_section();
+    f->dump_bool("has_xattrs", has_xattrs);
+  }
+
+  static void generate_test_instances(std::list<cls_2pc_urgent_data*>& ls) {
+    ls.push_back(new cls_2pc_urgent_data);
+    ls.push_back(new cls_2pc_urgent_data);
+    ls.back()->reserved_size = 123;
+    ls.back()->last_id = 456;
+    ls.back()->reservations.emplace(789, cls_2pc_reservation(1, ceph::coarse_real_clock::zero(), 2));
+    ls.back()->has_xattrs = true;
+  }
 };
 WRITE_CLASS_ENCODER(cls_2pc_urgent_data)

diff --git a/src/cls/cas/cls_cas_internal.h b/src/cls/cas/cls_cas_internal.h
index 09e7f9f1f69d345dc89d8cdb0b652574364676b9..037e60fffd9da0929d551b3ccdf6606d7262254a 100644 (file)
--- a/src/cls/cas/cls_cas_internal.h
+++ b/src/cls/cas/cls_cas_internal.h
@@ -145,6 +145,12 @@ struct chunk_refs_by_object_t : public chunk_refs_t::refs_t {
     }
     f->close_section();
   }
+  static void generate_test_instances(std::list<chunk_refs_by_object_t*>& ls) {
+    ls.push_back(new chunk_refs_by_object_t());
+    ls.push_back(new chunk_refs_by_object_t());
+    ls.back()->by_object.insert(hobject_t(sobject_t("foo", CEPH_NOSNAP)));
+    ls.back()->by_object.insert(hobject_t(sobject_t("bar", CEPH_NOSNAP)));
+  }
 };
 WRITE_CLASS_ENCODER(chunk_refs_by_object_t)
 
@@ -386,6 +392,11 @@ struct chunk_refs_count_t : public chunk_refs_t::refs_t {
     f->dump_string("type", "count");
     f->dump_unsigned("count", total);
   }
+  static void generate_test_instances(std::list<chunk_refs_count_t*>& o) {
+    o.push_back(new chunk_refs_count_t);
+    o.push_back(new chunk_refs_count_t);
+    o.back()->total = 123;
+  }
 };
 WRITE_CLASS_ENCODER(chunk_refs_count_t)
 

diff --git a/src/cls/fifo/cls_fifo_ops.h b/src/cls/fifo/cls_fifo_ops.h
index e850c635c0b82e02c9a53044610911d46d5dc0a4..d466122a9527fb596043723270a5d211b4c4ed4d 100644 (file)
--- a/src/cls/fifo/cls_fifo_ops.h
+++ b/src/cls/fifo/cls_fifo_ops.h
@@ -67,6 +67,31 @@ struct create_meta
     decode(exclusive, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("id", id);
+    f->dump_object("version", version.value_or(objv()));
+    f->dump_string("pool_name", pool.name);
+    f->dump_string("pool_ns", pool.ns);
+    f->dump_string("oid_prefix", oid_prefix.value_or(""));
+    f->dump_unsigned("max_part_size", max_part_size);
+    f->dump_unsigned("max_entry_size", max_entry_size);
+    f->dump_bool("exclusive", exclusive);
+  }
+  static void generate_test_instances(std::list<create_meta*>& o) {
+    o.push_back(new create_meta);
+    o.push_back(new create_meta);
+    o.back()->id = "id";
+    objv v1;
+    v1.instance = "inst1";
+    v1.ver = 1;
+    o.back()->version = v1;
+    o.back()->pool.name = "pool";
+    o.back()->pool.ns = "ns";
+    o.back()->oid_prefix = "prefix";
+    o.back()->max_part_size = 1024;
+    o.back()->max_entry_size = 1024;
+    o.back()->exclusive = true;
+  }
 };
 WRITE_CLASS_ENCODER(create_meta)
 
@@ -84,6 +109,17 @@ struct get_meta
     decode(version, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("version", version.value_or(objv()));
+  }
+  static void generate_test_instances(std::list<get_meta*>& o) {
+    o.push_back(new get_meta);
+    o.push_back(new get_meta);
+    objv v1;
+    v1.instance = "inst1";
+    v1.ver = 1;
+    o.back()->version = v1;
+  }
 };
 WRITE_CLASS_ENCODER(get_meta)
 
@@ -108,6 +144,18 @@ struct get_meta_reply
     decode(part_entry_overhead, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("info", info);
+    f->dump_unsigned("part_header_size", part_header_size);
+    f->dump_unsigned("part_entry_overhead", part_entry_overhead);
+  }
+  static void generate_test_instances(std::list<get_meta_reply*>& o) {
+    o.push_back(new get_meta_reply);
+    o.push_back(new get_meta_reply);
+    o.back()->info = fifo::info();
+    o.back()->part_header_size = 1024;
+    o.back()->part_entry_overhead = 1024;
+  }
 };
 WRITE_CLASS_ENCODER(get_meta_reply)
 

diff --git a/src/cls/fifo/cls_fifo_types.h b/src/cls/fifo/cls_fifo_types.h
index 1c69c1f08718a9725fad3f09b190153b8424f0d9..2ae601e4aafafadd2a2978af3e30689dc5da7b55 100644 (file)
--- a/src/cls/fifo/cls_fifo_types.h
+++ b/src/cls/fifo/cls_fifo_types.h
@@ -54,7 +54,16 @@ struct objv {
     decode(ver, bl);
     DECODE_FINISH(bl);
   }
-  void dump(ceph::Formatter* f) const;
+  void dump(ceph::Formatter* f) const {
+    f->dump_string("instance", instance);
+    f->dump_unsigned("ver", ver);
+  }
+  static void generate_test_instances(std::list<objv*>& o) {
+    o.push_back(new objv);
+    o.push_back(new objv);
+    o.back()->instance = "instance";
+    o.back()->ver = 1;
+  }
   void decode_json(JSONObj* obj);
 
   bool operator ==(const objv& rhs) const {
@@ -103,7 +112,18 @@ struct data_params {
     decode(full_size_threshold, bl);
     DECODE_FINISH(bl);
   }
-  void dump(ceph::Formatter* f) const;
+  void dump(ceph::Formatter* f) const {
+    f->dump_unsigned("max_part_size", max_part_size);
+    f->dump_unsigned("max_entry_size", max_entry_size);
+    f->dump_unsigned("full_size_threshold", full_size_threshold);
+  }
+  static void generate_test_instances(std::list<data_params*>& o) {
+    o.push_back(new data_params);
+    o.push_back(new data_params);
+    o.back()->max_part_size = 1;
+    o.back()->max_entry_size = 2;
+    o.back()->full_size_threshold = 3;
+  }
   void decode_json(JSONObj* obj);
 
   auto operator <=>(const data_params&) const = default;
@@ -161,7 +181,10 @@ struct journal_entry {
     decode(part_tag, bl);
     DECODE_FINISH(bl);
   }
-  void dump(ceph::Formatter* f) const;
+  void dump(ceph::Formatter* f) const {
+    f->dump_int("op", (int)op);
+    f->dump_int("part_num", part_num);
+  }
 
   auto operator <=>(const journal_entry&) const = default;
 };
@@ -397,7 +420,38 @@ struct info {
     decode_journal(bl);
     DECODE_FINISH(bl);
   }
-  void dump(ceph::Formatter* f) const;
+  void dump(ceph::Formatter* f) const {
+    f->dump_string("id", id);
+    f->dump_object("version", version);
+    f->dump_string("oid_prefix", oid_prefix);
+    f->dump_object("params", params);
+    f->dump_int("tail_part_num", tail_part_num);
+    f->dump_int("head_part_num", head_part_num);
+    f->dump_int("min_push_part_num", min_push_part_num);
+    f->dump_int("max_push_part_num", max_push_part_num);
+    f->open_array_section("journal");
+    for (const auto& entry : journal) {
+      f->open_object_section("entry");
+      f->dump_object("entry", entry);
+      f->close_section();
+    }
+    f->close_section();
+  }
+  static void generate_test_instances(std::list<info*>& o) {
+    o.push_back(new info);
+    o.push_back(new info);
+    o.back()->id = "myid";
+    o.back()->version = objv();
+    o.back()->oid_prefix = "myprefix";
+    o.back()->params = data_params();
+    o.back()->tail_part_num = 123;
+    o.back()->head_part_num = 456;
+    o.back()->min_push_part_num = 789;
+    o.back()->max_push_part_num = 101112;
+    o.back()->journal.insert(journal_entry(journal_entry::Op::create, 1));
+    o.back()->journal.insert(journal_entry(journal_entry::Op::create, 2));
+    o.back()->journal.insert(journal_entry(journal_entry::Op::create, 3));
+  }
   void decode_json(JSONObj* obj);
 
   std::string part_oid(std::int64_t part_num) const {

diff --git a/src/cls/log/cls_log_ops.h b/src/cls/log/cls_log_ops.h
index 5a65892598b6e21a4b9f69f45bbdbafece94d7e2..4d3b2f5d30914c58d882166590ca7eab9bb7e079 100644 (file)
--- a/src/cls/log/cls_log_ops.h
+++ b/src/cls/log/cls_log_ops.h
@@ -4,6 +4,7 @@
 #ifndef CEPH_CLS_LOG_OPS_H
 #define CEPH_CLS_LOG_OPS_H
 
+#include "common/ceph_json.h"
 #include "cls_log_types.h"
 
 struct cls_log_add_op {
@@ -73,6 +74,21 @@ struct cls_log_list_op {
     decode(max_entries, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter* f) const {
+    f->dump_stream("from_time") << from_time;
+    f->dump_string("marker", marker);
+    f->dump_stream("to_time") << to_time;
+    f->dump_int("max_entries", max_entries);
+  }
+  static void generate_test_instances(std::list<cls_log_list_op*>& ls) {
+    ls.push_back(new cls_log_list_op);
+    ls.push_back(new cls_log_list_op);
+    ls.back()->from_time = utime_t(1, 2);
+    ls.back()->marker = "marker";
+    ls.back()->to_time = utime_t(3, 4);
+    ls.back()->max_entries = 5;
+  }
 };
 WRITE_CLASS_ENCODER(cls_log_list_op)
 
@@ -98,6 +114,25 @@ struct cls_log_list_ret {
     decode(truncated, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter* f) const {
+    encode_json("entries", entries, f);
+    f->dump_string("marker", marker);
+    f->dump_bool("truncated", truncated);
+  }
+  static void generate_test_instances(std::list<cls_log_list_ret*>& ls) {
+    ls.push_back(new cls_log_list_ret);
+    ls.push_back(new cls_log_list_ret);
+    ls.back()->entries.push_back(cls_log_entry());
+    ls.back()->entries.push_back(cls_log_entry());
+    ls.back()->entries.back().section = "section";
+    ls.back()->entries.back().name = "name";
+    ls.back()->entries.back().timestamp = utime_t(1, 2);
+    ls.back()->entries.back().data.append("data");
+    ls.back()->entries.back().id = "id";
+    ls.back()->marker = "marker";
+    ls.back()->truncated = true;
+  }
 };
 WRITE_CLASS_ENCODER(cls_log_list_ret)
 
@@ -133,6 +168,20 @@ struct cls_log_trim_op {
     }
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter* f) const {
+    f->dump_stream("from_time") << from_time;
+    f->dump_stream("to_time") << to_time;
+    f->dump_string("from_marker", from_marker);
+    f->dump_string("to_marker", to_marker);
+  }
+  static void generate_test_instances(std::list<cls_log_trim_op*>& ls) {
+    ls.push_back(new cls_log_trim_op);
+    ls.push_back(new cls_log_trim_op);
+    ls.back()->from_time = utime_t(1, 2);
+    ls.back()->to_time = utime_t(3, 4);
+    ls.back()->from_marker = "from_marker";
+    ls.back()->to_marker = "to_marker";
+  }
 };
 WRITE_CLASS_ENCODER(cls_log_trim_op)
 
@@ -150,6 +199,13 @@ struct cls_log_info_op {
     // currently empty request
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter* f) const {
+  }
+
+  static void generate_test_instances(std::list<cls_log_info_op*>& ls) {
+    ls.push_back(new cls_log_info_op);
+  }
 };
 WRITE_CLASS_ENCODER(cls_log_info_op)
 

diff --git a/src/cls/log/cls_log_types.h b/src/cls/log/cls_log_types.h
index 33b8cce51e5e8c792f4c9253bc2349fb5ec2f59b..29aa2bae8fe972e9660049de2fe4f4e4e1340b5c 100644 (file)
--- a/src/cls/log/cls_log_types.h
+++ b/src/cls/log/cls_log_types.h
@@ -92,6 +92,16 @@ struct cls_log_header {
     decode(max_time, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter* f) const {
+    f->dump_string("max_marker", max_marker);
+    f->dump_stream("max_time") << max_time;
+  }
+  static void generate_test_instances(std::list<cls_log_header*>& o) {
+    o.push_back(new cls_log_header);
+    o.push_back(new cls_log_header);
+    o.back()->max_marker = "test_marker";
+    o.back()->max_time = utime_t();
+  }
 };
 inline bool operator ==(const cls_log_header& lhs, const cls_log_header& rhs) {
   return (lhs.max_marker == rhs.max_marker &&

diff --git a/src/cls/queue/cls_queue_ops.h b/src/cls/queue/cls_queue_ops.h
index 8209659bda907b7492f6a6366e4762698fa0eec1..0b0b30b6f01cdfc26231f4b670107ab72a7b52c9 100644 (file)
--- a/src/cls/queue/cls_queue_ops.h
+++ b/src/cls/queue/cls_queue_ops.h
@@ -4,6 +4,7 @@
 #ifndef CEPH_CLS_QUEUE_OPS_H
 #define CEPH_CLS_QUEUE_OPS_H
 
+#include "common/ceph_json.h"
 #include "cls/queue/cls_queue_types.h"
 
 struct cls_queue_init_op {
@@ -29,6 +30,19 @@ struct cls_queue_init_op {
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("queue_size", queue_size);
+    f->dump_unsigned("max_urgent_data_size", max_urgent_data_size);
+    f->dump_unsigned("urgent_data_len", bl_urgent_data.length());
+  }
+
+  static void generate_test_instances(std::list<cls_queue_init_op*>& o) {
+    o.push_back(new cls_queue_init_op);
+    o.push_back(new cls_queue_init_op);
+    o.back()->queue_size = 1024;
+    o.back()->max_urgent_data_size = 1024;
+    o.back()->bl_urgent_data.append(std::string_view("data"));
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_init_op)
 
@@ -47,12 +61,23 @@ struct cls_queue_enqueue_op {
     DECODE_START(1, bl);
     decode(bl_data_vec, bl);
     DECODE_FINISH(bl);
-  } 
+  }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("data_vec_len", bl_data_vec.size());
+  }
+
+  static void generate_test_instances(std::list<cls_queue_enqueue_op*>& o) {
+    o.push_back(new cls_queue_enqueue_op);
+    o.push_back(new cls_queue_enqueue_op);
+    o.back()->bl_data_vec.push_back(ceph::buffer::list());
+    o.back()->bl_data_vec.back().append(std::string_view("data"));
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_enqueue_op)
 
 struct cls_queue_list_op {
-  uint64_t max;
+  uint64_t max{0};
   std::string start_marker;
 
   cls_queue_list_op() {}
@@ -70,6 +95,18 @@ struct cls_queue_list_op {
     decode(start_marker, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("max", max);
+    f->dump_string("start_marker", start_marker);
+  }
+
+  static void generate_test_instances(std::list<cls_queue_list_op*>& o) {
+    o.push_back(new cls_queue_list_op);
+    o.push_back(new cls_queue_list_op);
+    o.back()->max = 123;
+    o.back()->start_marker = "foo";
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_list_op)
 
@@ -95,6 +132,22 @@ struct cls_queue_list_ret {
     decode(entries, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_bool("is_truncated", is_truncated);
+    f->dump_string("next_marker", next_marker);
+    encode_json("entries", entries, f);
+  }
+
+  static void generate_test_instances(std::list<cls_queue_list_ret*>& o) {
+    o.push_back(new cls_queue_list_ret);
+    o.back()->is_truncated = true;
+    o.back()->next_marker = "foo";
+    o.back()->entries.push_back(cls_queue_entry());
+    o.back()->entries.push_back(cls_queue_entry());
+    o.back()->entries.back().marker = "id";
+    o.back()->entries.back().data.append(std::string_view("data"));
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_list_ret)
 
@@ -114,6 +167,15 @@ struct cls_queue_remove_op {
     decode(end_marker, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("end_marker", end_marker);
+  }
+  static void generate_test_instances(std::list<cls_queue_remove_op*>& o) {
+    o.push_back(new cls_queue_remove_op);
+    o.push_back(new cls_queue_remove_op);
+    o.back()->end_marker = "foo";
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_remove_op)
 
@@ -133,6 +195,14 @@ struct cls_queue_get_capacity_ret {
     decode(queue_capacity, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("queue_capacity", queue_capacity);
+  }
+  static void generate_test_instances(std::list<cls_queue_get_capacity_ret*>& o) {
+    o.push_back(new cls_queue_get_capacity_ret);
+    o.back()->queue_capacity = 123;
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_get_capacity_ret)
 

diff --git a/src/cls/queue/cls_queue_types.h b/src/cls/queue/cls_queue_types.h
index cc46df405052061a7dff7041d38bdfeb778465cb..3c3e828edf0ac63fa6c59a7bf7b0b1b6c562e123 100644 (file)
--- a/src/cls/queue/cls_queue_types.h
+++ b/src/cls/queue/cls_queue_types.h
@@ -34,6 +34,17 @@ struct cls_queue_entry
     decode(marker, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("marker", marker);
+    f->dump_unsigned("data_len", data.length());
+  }
+  static void generate_test_instances(std::list<cls_queue_entry*>& o) {
+    o.push_back(new cls_queue_entry);
+    o.push_back(new cls_queue_entry);
+    o.back()->data.append(std::string_view("data"));
+    o.back()->marker = "marker";
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_entry)
 
@@ -80,7 +91,16 @@ struct cls_queue_marker
     }
     return 0;
   }
-
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("offset", offset);
+    f->dump_unsigned("gen", gen);
+  }
+  static void generate_test_instances(std::list<cls_queue_marker*>& o) {
+    o.push_back(new cls_queue_marker);
+    o.push_back(new cls_queue_marker);
+    o.back()->offset = 1024;
+    o.back()->gen = 0;
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_marker)
 
@@ -114,6 +134,27 @@ struct cls_queue_head
     decode(bl_urgent_data, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("max_head_size", max_head_size);
+    f->dump_unsigned("queue_size", queue_size);
+    f->dump_unsigned("max_urgent_data_size", max_urgent_data_size);
+    f->dump_unsigned("front_offset", front.offset);
+    f->dump_unsigned("front_gen", front.gen);
+    f->dump_unsigned("tail_offset", tail.offset);
+    f->dump_unsigned("tail_gen", tail.gen);
+  }
+  static void generate_test_instances(std::list<cls_queue_head*>& o) {
+    o.push_back(new cls_queue_head);
+    o.push_back(new cls_queue_head);
+    o.back()->max_head_size = 1024;
+    o.back()->front.offset = 1024;
+    o.back()->front.gen = 0;
+    o.back()->tail.offset = 1024;
+    o.back()->tail.gen = 0;
+    o.back()->queue_size = 1024;
+    o.back()->max_urgent_data_size = 0;
+  }
 };
 WRITE_CLASS_ENCODER(cls_queue_head)
 

diff --git a/src/cls/timeindex/cls_timeindex_ops.h b/src/cls/timeindex/cls_timeindex_ops.h
index f40058954dcef4c28f2985e5a4d695aff06deea2..f0f0cc0247514c423f2ed0293f4912d069c676aa 100644 (file)
--- a/src/cls/timeindex/cls_timeindex_ops.h
+++ b/src/cls/timeindex/cls_timeindex_ops.h
@@ -4,6 +4,7 @@
 #ifndef CEPH_CLS_TIMEINDEX_OPS_H
 #define CEPH_CLS_TIMEINDEX_OPS_H
 
+#include "common/ceph_json.h"
 #include "cls_timeindex_types.h"
 
 struct cls_timeindex_add_op {
@@ -51,6 +52,26 @@ struct cls_timeindex_list_op {
     decode(max_entries, bl);
     DECODE_FINISH(bl);
   }
+
+   void dump(ceph::Formatter *f) const {
+    f->open_object_section("from_time");
+    from_time.dump(f);
+    f->close_section();
+    f->dump_string("marker", marker);
+    f->open_object_section("to_time");
+    to_time.dump(f);
+    f->close_section();
+    f->dump_int("max_entries", max_entries);
+  }
+
+  static void generate_test_instances(std::list<cls_timeindex_list_op*>& o) {
+    o.push_back(new cls_timeindex_list_op);
+    o.push_back(new cls_timeindex_list_op);
+    o.back()->from_time = utime_t(1, 2);
+    o.back()->marker = "marker";
+    o.back()->to_time = utime_t(3, 4);
+    o.back()->max_entries = 5;
+  }
 };
 WRITE_CLASS_ENCODER(cls_timeindex_list_op)
 
@@ -76,6 +97,23 @@ struct cls_timeindex_list_ret {
     decode(truncated, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    encode_json("entries", entries, f);
+    f->dump_string("marker", marker);
+    f->dump_bool("truncated", truncated);
+  }
+
+  static void generate_test_instances(std::list<cls_timeindex_list_ret*>& o) {
+    o.push_back(new cls_timeindex_list_ret);
+    o.push_back(new cls_timeindex_list_ret);
+    o.back()->entries.push_back(cls_timeindex_entry());
+    o.back()->entries.back().key_ts = utime_t(1, 2);
+    o.back()->entries.back().key_ext = "key_ext";
+    o.back()->entries.back().value.append("value");
+    o.back()->marker = "marker";
+    o.back()->truncated = true;
+  }
 };
 WRITE_CLASS_ENCODER(cls_timeindex_list_ret)
 

diff --git a/src/cls/timeindex/cls_timeindex_types.h b/src/cls/timeindex/cls_timeindex_types.h
index d33886881be523e28c5c631e8e751369b1d76bc4..ea8d6c93d2c88a10e5b23341a4d2228b04a82272 100644 (file)
--- a/src/cls/timeindex/cls_timeindex_types.h
+++ b/src/cls/timeindex/cls_timeindex_types.h
@@ -4,9 +4,9 @@
 #ifndef CEPH_CLS_TIMEINDEX_TYPES_H
 #define CEPH_CLS_TIMEINDEX_TYPES_H
 
+#include "common/Formatter.h"
 #include "include/encoding.h"
 #include "include/types.h"
-
 #include "include/utime.h"
 
 class JSONObj;

diff --git a/src/cls/version/cls_version_ops.h b/src/cls/version/cls_version_ops.h
index 62cd1172982a6f8e69dda092e59cd653a84a7a77..2eff788ce52ceaa2c57d1b3f8b95b01e8218cce0 100644 (file)
--- a/src/cls/version/cls_version_ops.h
+++ b/src/cls/version/cls_version_ops.h
@@ -5,6 +5,7 @@
 #define CEPH_CLS_VERSION_OPS_H
 
 #include "cls_version_types.h"
+#include "common/ceph_json.h"
 
 struct cls_version_set_op {
   obj_version objv;
@@ -22,6 +23,17 @@ struct cls_version_set_op {
     decode(objv, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("objv", objv);
+  }
+
+  static void generate_test_instances(std::list<cls_version_set_op*>& o) {
+    o.push_back(new cls_version_set_op);
+    o.push_back(new cls_version_set_op);
+    o.back()->objv.ver = 123;
+    o.back()->objv.tag = "foo";
+  }
 };
 WRITE_CLASS_ENCODER(cls_version_set_op)
 
@@ -44,6 +56,22 @@ struct cls_version_inc_op {
     decode(conds, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("objv", objv);
+    encode_json("conds", conds, f);
+  }
+
+  static void generate_test_instances(std::list<cls_version_inc_op*>& o) {
+    o.push_back(new cls_version_inc_op);
+    o.push_back(new cls_version_inc_op);
+    o.back()->objv.ver = 123;
+    o.back()->objv.tag = "foo";
+    o.back()->conds.push_back(obj_version_cond());
+    o.back()->conds.back().ver.ver = 123;
+    o.back()->conds.back().ver.tag = "foo";
+    o.back()->conds.back().cond = VER_COND_GE;
+  }
 };
 WRITE_CLASS_ENCODER(cls_version_inc_op)
 
@@ -66,6 +94,22 @@ struct cls_version_check_op {
     decode(conds, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("objv", objv);
+    encode_json("conds", conds, f);
+  }
+
+  static void generate_test_instances(std::list<cls_version_check_op*>& o) {
+    o.push_back(new cls_version_check_op);
+    o.push_back(new cls_version_check_op);
+    o.back()->objv.ver = 123;
+    o.back()->objv.tag = "foo";
+    o.back()->conds.push_back(obj_version_cond());
+    o.back()->conds.back().ver.ver = 123;
+    o.back()->conds.back().ver.tag = "foo";
+    o.back()->conds.back().cond = VER_COND_GE;
+  }
 };
 WRITE_CLASS_ENCODER(cls_version_check_op)
 
@@ -85,6 +129,17 @@ struct cls_version_read_ret {
     decode(objv, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("objv", objv);
+  }
+
+  static void generate_test_instances(std::list<cls_version_read_ret*>& o) {
+    o.push_back(new cls_version_read_ret);
+    o.push_back(new cls_version_read_ret);
+    o.back()->objv.ver = 123;
+    o.back()->objv.tag = "foo";
+  }
 };
 WRITE_CLASS_ENCODER(cls_version_read_ret)
 

diff --git a/src/cls/version/cls_version_types.cc b/src/cls/version/cls_version_types.cc
index b82f6aa8a5dd9871dd679ffa4e4330ebe84ec8ca..735ef7c89857bf87311c69ce1c24cbd28ad7a74d 100644 (file)
--- a/src/cls/version/cls_version_types.cc
+++ b/src/cls/version/cls_version_types.cc
@@ -6,12 +6,6 @@
 #include "common/ceph_json.h"
 
 
-void obj_version::dump(ceph::Formatter *f) const
-{
-  f->dump_int("ver", ver);
-  f->dump_string("tag", tag);
-}
-
 void obj_version::decode_json(JSONObj *obj)
 {
   JSONDecoder::decode_json("ver", ver, obj);

diff --git a/src/cls/version/cls_version_types.h b/src/cls/version/cls_version_types.h
index 62cc16e33d520b486f3c4748ac9fb6da09d35d68..dafa866e1f35832fe85f9a3e8941cdf0a07aeb9d 100644 (file)
--- a/src/cls/version/cls_version_types.h
+++ b/src/cls/version/cls_version_types.h
@@ -53,7 +53,11 @@ struct obj_version {
             tag.compare(v.tag) == 0);
   }
 
-  void dump(ceph::Formatter *f) const;
+  void dump(ceph::Formatter *f) const {
+    f->dump_int("ver", ver);
+    f->dump_string("tag", tag);
+  }
+
   void decode_json(JSONObj *obj);
   static void generate_test_instances(std::list<obj_version*>& o);
 };
@@ -91,6 +95,18 @@ struct obj_version_cond {
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("ver", ver);
+    f->dump_unsigned("cond", cond);
+  }
+
+  static void generate_test_instances(std::list<obj_version_cond*>& o) {
+    o.push_back(new obj_version_cond);
+    o.push_back(new obj_version_cond);
+    o.back()->ver.ver = 1;
+    o.back()->ver.tag = "foo";
+    o.back()->cond = VER_COND_EQ;
+  }
 };
 WRITE_CLASS_ENCODER(obj_version_cond)
 

diff --git a/src/common/ceph_json.h b/src/common/ceph_json.h
index 08e8d9e46623302cdda1d9f30d486a487aaa7bac..f7a899fd935680b1ee1d01587de3cf0484b9aaaa 100644 (file)
--- a/src/common/ceph_json.h
+++ b/src/common/ceph_json.h
@@ -836,6 +836,61 @@ public:
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    switch (type) {
+      case FMT_VALUE:
+        if (value.quoted) {
+          f->dump_string("value", value.str);
+        } else {
+          f->dump_format_unquoted("value", "%s", value.str.c_str());
+        }
+        break;
+      case FMT_ARRAY:
+        f->open_array_section("array");
+        for (auto& i : arr) {
+          i.dump(f);
+        }
+        f->close_section();
+        break;
+      case FMT_OBJ:
+        f->open_object_section("object");
+        for (auto& i : obj) {
+          f->dump_object(i.first.c_str(), i.second);
+        }
+        f->close_section();
+        break;
+      default:
+        break;
+    }
+  }
+  static void generate_test_instances(std::list<JSONFormattable*>& o) {
+    o.push_back(new JSONFormattable);
+    o.push_back(new JSONFormattable);
+    o.back()->set_type(FMT_VALUE);
+    o.back()->value.str = "foo";
+    o.back()->value.quoted = true;
+    o.push_back(new JSONFormattable);
+    o.back()->set_type(FMT_VALUE);
+    o.back()->value.str = "foo";
+    o.back()->value.quoted = false;
+    o.push_back(new JSONFormattable);
+    o.back()->set_type(FMT_ARRAY);
+    o.back()->arr.push_back(JSONFormattable());
+    o.back()->arr.back().set_type(FMT_VALUE);
+    o.back()->arr.back().value.str = "foo";
+    o.back()->arr.back().value.quoted = true;
+    o.back()->arr.push_back(JSONFormattable());
+    o.back()->arr.back().set_type(FMT_VALUE);
+    o.back()->arr.back().value.str = "bar";
+    o.back()->arr.back().value.quoted = true;
+    o.push_back(new JSONFormattable);
+    o.back()->set_type(FMT_OBJ);
+    o.back()->obj["foo"] = JSONFormattable();
+    o.back()->obj["foo"].set_type(FMT_VALUE);
+    o.back()->obj["foo"].value.str = "bar";
+    o.back()->obj["foo"].value.quoted = true;
+  }
+
   const std::string& val() const {
     return value.str;
   }

diff --git a/src/common/entity_name.cc b/src/common/entity_name.cc
index 5357b34eacb7f3f5f190c7183130c56568f1a54e..a9d6fb9c8b104b1ac7628a77d642e6f7f61792f6 100644 (file)
--- a/src/common/entity_name.cc
+++ b/src/common/entity_name.cc
@@ -29,21 +29,30 @@ const std::array<EntityName::str_to_entity_type_t, 6> EntityName::STR_TO_ENTITY_
   { CEPH_ENTITY_TYPE_CLIENT, "client" },
 }};
 
-const std::string& EntityName::
-to_str() const
-{
+void EntityName::dump(ceph::Formatter *f) const {
+  f->dump_int("type", type);
+  f->dump_string("id", id);
+}
+
+void EntityName::generate_test_instances(std::list<EntityName*>& ls) {
+  ls.push_back(new EntityName);
+  ls.push_back(new EntityName);
+  ls.back()->set_type(CEPH_ENTITY_TYPE_OSD);
+  ls.back()->set_id("0");
+  ls.push_back(new EntityName);
+  ls.back()->set_type(CEPH_ENTITY_TYPE_MDS);
+  ls.back()->set_id("a");
+}
+
+const std::string& EntityName::to_str() const {
   return type_id;
 }
 
-const char* EntityName::
-to_cstr() const
-{
+const char* EntityName::to_cstr() const {
   return type_id.c_str();
 }
 
-bool EntityName::
-from_str(std::string_view s)
-{
+bool EntityName::from_str(std::string_view s) {
   size_t pos = s.find('.');
 
   if (pos == string::npos)
@@ -56,9 +65,7 @@ from_str(std::string_view s)
   return true;
 }
 
-void EntityName::
-set(uint32_t type_, std::string_view id_)
-{
+void EntityName::set(uint32_t type_, std::string_view id_) {
   type = type_;
   id = id_;
 
@@ -71,9 +78,7 @@ set(uint32_t type_, std::string_view id_)
   }
 }
 
-int EntityName::
-set(std::string_view type_, std::string_view id_)
-{
+int EntityName::set(std::string_view type_, std::string_view id_) {
   uint32_t t = str_to_ceph_entity_type(type_);
   if (t == CEPH_ENTITY_TYPE_ANY)
     return -EINVAL;
@@ -81,9 +86,7 @@ set(std::string_view type_, std::string_view id_)
   return 0;
 }
 
-void EntityName::
-set_type(uint32_t type_)
-{
+void EntityName::set_type(uint32_t type_) {
   set(type_, id);
 }
 
@@ -93,9 +96,7 @@ set_type(std::string_view type_)
   return set(type_, id);
 }
 
-void EntityName::
-set_id(std::string_view id_)
-{
+void EntityName::set_id(std::string_view id_) {
   set(type, id_);
 }
 
@@ -106,33 +107,23 @@ void EntityName::set_name(entity_name_t n)
   set(n.type(), s);
 }
 
-const char* EntityName::
-get_type_str() const
-{
+const char* EntityName::get_type_str() const {
   return ceph_entity_type_name(type);
 }
 
-std::string_view EntityName::
-get_type_name() const
-{
+std::string_view EntityName::get_type_name() const {
   return ceph_entity_type_name(type);
 }
 
-const std::string &EntityName::
-get_id() const
-{
+const std::string &EntityName::get_id() const {
   return id;
 }
 
-bool EntityName::
-has_default_id() const
-{
+bool EntityName::has_default_id() const {
   return (id == "admin");
 }
 
-std::string EntityName::
-get_valid_types_as_str()
-{
+std::string EntityName::get_valid_types_as_str() {
   std::ostringstream out;
   size_t i;
   for (i = 0; i < STR_TO_ENTITY_TYPE.size(); ++i) {

diff --git a/src/common/entity_name.h b/src/common/entity_name.h
index c88ebcbbabde05ad83520a047627caf4d7decc9f..53f8cd4d5d09cf2666b04bdc0331cb5d5e9d8d4e 100644 (file)
--- a/src/common/entity_name.h
+++ b/src/common/entity_name.h
@@ -41,7 +41,8 @@ struct EntityName
     decode(id_, bl);
     set(type_, id_);
   }
-
+  void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<EntityName*>& ls);
   const std::string& to_str() const;
   const char *to_cstr() const;
   bool from_str(std::string_view s);

diff --git a/src/include/cephfs/types.h b/src/include/cephfs/types.h
index 049ef8e3fcf675c2948ee0e98a01d51f9b41196c..54d97d9d4a2fcca4e999e3b41e2fe6b95267b2fa 100644 (file)
--- a/src/include/cephfs/types.h
+++ b/src/include/cephfs/types.h
@@ -349,6 +349,8 @@ public:
   }
   void encode(ceph::buffer::list &bl) const;
   void decode(ceph::buffer::list::const_iterator& bl);
+  void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<inline_data_t*>& ls);
 
   version_t version = 1;
 

diff --git a/src/include/frag.h b/src/include/frag.h
index ec18bddfbb1e761d3faa655161a4601b8fd11273..5ea2429aee8d506270375840d98e3787a3b68720 100644 (file)
--- a/src/include/frag.h
+++ b/src/include/frag.h
@@ -159,6 +159,15 @@ public:
     ceph::decode_raw(v, p);
     _enc = v;
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("value", value());
+    f->dump_unsigned("bits", bits());
+  }
+  static void generate_test_instances(std::list<frag_t*>& ls) {
+    ls.push_back(new frag_t);
+    ls.push_back(new frag_t(10, 2));
+    ls.push_back(new frag_t(11, 3));
+  }
   bool operator<(const frag_t& b) const
   {
     if (value() != b.value())
@@ -525,6 +534,11 @@ public:
     }
     f->close_section(); // splits
   }
+
+  static void generate_test_instances(std::list<fragtree_t*>& ls) {
+    ls.push_back(new fragtree_t);
+    ls.push_back(new fragtree_t);
+  }
 };
 WRITE_CLASS_ENCODER(fragtree_t)
 

diff --git a/src/include/fs_types.h b/src/include/fs_types.h
index c1932bfcc30e8af440482a41dda19fe3699e649f..606b9c6503d4f536a17eb010aa33b497c72c1fc9 100644 (file)
--- a/src/include/fs_types.h
+++ b/src/include/fs_types.h
@@ -75,6 +75,13 @@ struct inodeno_t {
     using ceph::decode;
     decode(val, p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("val", val);
+  }
+  static void generate_test_instances(std::list<inodeno_t*>& ls) {
+    ls.push_back(new inodeno_t(1));
+    ls.push_back(new inodeno_t(123456789));
+  }
 } __attribute__ ((__may_alias__));
 WRITE_CLASS_ENCODER(inodeno_t)
 

diff --git a/src/include/object.h b/src/include/object.h
index 4564af86e5770e543f3c24554f3fa039a95f8dd8..2e5fb471c139e1a52e3281f7728336173bb8364d 100644 (file)
--- a/src/include/object.h
+++ b/src/include/object.h
@@ -25,6 +25,7 @@
 
 #include "include/rados.h"
 #include "include/unordered_map.h"
+#include "common/Formatter.h"
 
 #include "hash.h"
 #include "encoding.h"
@@ -58,6 +59,15 @@ struct object_t {
     using ceph::decode;
     decode(name, bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("name", name);
+  }
+
+  static void generate_test_instances(std::list<object_t*>& o) {
+    o.push_back(new object_t);
+    o.push_back(new object_t("myobject"));
+  }
 };
 WRITE_CLASS_ENCODER(object_t)
 
@@ -170,6 +180,14 @@ struct sobject_t {
     decode(oid, bl);
     decode(snap, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_stream("oid") << oid;
+    f->dump_stream("snap") << snap;
+  }
+  static void generate_test_instances(std::list<sobject_t*>& o) {
+    o.push_back(new sobject_t);
+    o.push_back(new sobject_t(object_t("myobject"), 123));
+  }
 };
 WRITE_CLASS_ENCODER(sobject_t)
 

diff --git a/src/include/types.h b/src/include/types.h
index bdd09a53df10f7c2022addb7231fbc0b82a86ccc..a50a506eb0bc265cd1da5d832334876ec461ee3d 100644 (file)
--- a/src/include/types.h
+++ b/src/include/types.h
@@ -371,6 +371,14 @@ struct client_t {
     using ceph::decode;
     decode(v, bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_int("id", v);
+  }
+  static void generate_test_instances(std::list<client_t*>& ls) {
+    ls.push_back(new client_t);
+    ls.push_back(new client_t(1));
+    ls.push_back(new client_t(123));
+  }
 };
 WRITE_CLASS_ENCODER(client_t)
 
@@ -517,7 +525,13 @@ struct shard_id_t {
     using ceph::decode;
     decode(id, bl);
   }
-
+  void dump(ceph::Formatter *f) const {
+    f->dump_int("id", id);
+  }
+  static void generate_test_instances(std::list<shard_id_t*>& ls) {
+    ls.push_back(new shard_id_t(1));
+    ls.push_back(new shard_id_t(2));
+  }
   bool operator==(const shard_id_t&) const = default;
   auto operator<=>(const shard_id_t&) const = default;
 };
@@ -561,6 +575,13 @@ struct errorcode32_t {
     decode(code, bl);
     code = ceph_to_hostos_errno(code);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_int("code", code);
+  }
+  static void generate_test_instances(std::list<errorcode32_t*>& ls) {
+    ls.push_back(new errorcode32_t(1));
+    ls.push_back(new errorcode32_t(2));
+  }
 };
 WRITE_CLASS_ENCODER(errorcode32_t)
 
@@ -602,6 +623,16 @@ struct sha_digest_t {
     decode(tmparr, bl);
     memcpy(v, tmparr.data(), SIZE);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("sha1", to_str());
+  }
+  static void generate_test_instances(std::list<sha_digest_t*>& ls) {
+    ls.push_back(new sha_digest_t);
+    ls.push_back(new sha_digest_t);
+    ls.back()->v[0] = 1;
+    ls.push_back(new sha_digest_t);
+    ls.back()->v[0] = 2;
+  }
 };
 
 template<uint8_t S>

diff --git a/src/mds/mdstypes.cc b/src/mds/mdstypes.cc
index 044c33459606f3b0f4e1fd175925cb12ba01af38..21e17ca0e5bcd718d2f2871660aa1176dbc4d6ca 100644 (file)
--- a/src/mds/mdstypes.cc
+++ b/src/mds/mdstypes.cc
@@ -284,6 +284,21 @@ void inline_data_t::decode(bufferlist::const_iterator &p)
     free_data();
 }
 
+void inline_data_t::dump(Formatter *f) const
+{
+  f->dump_unsigned("version", version);
+  f->dump_unsigned("length", length());
+}
+
+void inline_data_t::generate_test_instances(std::list<inline_data_t*>& ls)
+{
+  ls.push_back(new inline_data_t);
+  ls.push_back(new inline_data_t);
+  bufferlist bl;
+  bl.append("inline data");
+  ls.back()->set_data(bl);
+}
+
 
 /*
  * fnode_t

diff --git a/src/messages/MClientReply.h b/src/messages/MClientReply.h
index be33fad494913d810cc0e0f1971e1f4fa0e64a45..028c4200c149dd1ce6c075d12d8e7bc16be40d6f 100644 (file)
--- a/src/messages/MClientReply.h
+++ b/src/messages/MClientReply.h
@@ -291,7 +291,7 @@ struct InodeStat {
 };
 
 struct openc_response_t {
-  _inodeno_t                   created_ino;
+  _inodeno_t                   created_ino{0};
   interval_set<inodeno_t>      delegated_inos;
 
 public:
@@ -309,6 +309,16 @@ public:
     decode(delegated_inos, p);
     DECODE_FINISH(p);
   }
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("created_ino", created_ino);
+    f->dump_stream("delegated_inos") << delegated_inos;
+  }
+  static void generate_test_instances(std::list<openc_response_t*>& ls) {
+    ls.push_back(new openc_response_t);
+    ls.push_back(new openc_response_t);
+    ls.back()->created_ino = 1;
+    ls.back()->delegated_inos.insert(1, 10);
+  }
 } __attribute__ ((__may_alias__));
 WRITE_CLASS_ENCODER(openc_response_t)
 

diff --git a/src/messages/MClientRequest.h b/src/messages/MClientRequest.h
index c62e183a756336bfdd82961fb0be04d30b978475..a51d734891868b8b7f72d5bece376ebf397513e0 100644 (file)
--- a/src/messages/MClientRequest.h
+++ b/src/messages/MClientRequest.h
@@ -60,6 +60,17 @@ struct SnapPayload {
     decode(metadata, iter);
     DECODE_FINISH(iter);
   }
+  void dump(ceph::Formatter *f) const {
+    for (const auto &i : metadata) {
+      f->dump_string(i.first.c_str(), i.second);
+    }
+  }
+  static void generate_test_instances(std::list<SnapPayload *> &o) {
+    o.push_back(new SnapPayload);
+    o.push_back(new SnapPayload);
+    o.back()->metadata["key1"] = "val1";
+    o.back()->metadata["key2"] = "val2";
+  }
 };
 
 WRITE_CLASS_ENCODER(SnapPayload)
@@ -95,6 +106,26 @@ public:
       decode(item, bl);
       ceph::decode_nohead(item.dname_len, dname, bl);
     }
+
+    void dump(ceph::Formatter *f) const {
+      f->dump_string("dname", dname);
+      f->dump_unsigned("ino", item.ino);
+      f->dump_unsigned("cap_id", item.cap_id);
+      f->dump_unsigned("caps", item.caps);
+      f->dump_unsigned("wanted", item.wanted);
+      f->dump_unsigned("seq", item.seq);
+      f->dump_unsigned("issue_seq", item.issue_seq);
+      f->dump_unsigned("mseq", item.mseq);
+      f->dump_unsigned("dname_seq", item.dname_seq);
+      f->dump_unsigned("dname_len", item.dname_len);
+    }
+
+    static void generate_test_instances(std::list<Release*>& ls) {
+      ls.push_back(new Release);
+      ls.push_back(new Release);
+      ls.back()->item.dname_len = 4;
+      ls.back()->dname = "test";
+    }
   };
   mutable std::vector<Release> releases; /* XXX HACK! */
 

diff --git a/src/messages/MMDSCacheRejoin.h b/src/messages/MMDSCacheRejoin.h
index a9211d53538ad8e07ef7e7146da7195fe52d4d19..9237c79b6e77f469e50a3134d575d48b65f2257d 100644 (file)
--- a/src/messages/MMDSCacheRejoin.h
+++ b/src/messages/MMDSCacheRejoin.h
@@ -63,6 +63,17 @@ public:
       decode(nestlock, bl);
       decode(dftlock, bl);
     }
+    void dump(ceph::Formatter *f) const {
+      f->dump_int("nonce", nonce);
+      f->dump_int("caps_wanted", caps_wanted);
+      f->dump_int("filelock", filelock);
+      f->dump_int("nestlock", nestlock);
+      f->dump_int("dftlock", dftlock);
+    }
+    static void generate_test_instances(std::list<inode_strong*>& ls) {
+      ls.push_back(new inode_strong);
+      ls.push_back(new inode_strong(1, 2, 3, 4, 5));
+    }
   };
   WRITE_CLASS_ENCODER(inode_strong)
 
@@ -81,6 +92,14 @@ public:
       decode(nonce, bl);
       decode(dir_rep, bl);
     }
+    static void generate_test_instances(std::list<dirfrag_strong*>& ls) {
+      ls.push_back(new dirfrag_strong);
+      ls.push_back(new dirfrag_strong(1, 2));
+    }
+    void dump(ceph::Formatter *f) const {
+      f->dump_unsigned("nonce", nonce);
+      f->dump_unsigned("dir_rep", dir_rep);
+    }
   };
   WRITE_CLASS_ENCODER(dirfrag_strong)
 
@@ -118,6 +137,19 @@ public:
       decode(lock, bl);
       decode(alternate_name, bl);
     }
+    static void generate_test_instances(std::list<dn_strong*>& ls) {
+      ls.push_back(new dn_strong);
+      ls.push_back(new dn_strong(1, "alternate_name", 2, 3, 4, 5, 6));
+    }
+    void dump(ceph::Formatter *f) const {
+      f->dump_unsigned("first", first);
+      f->dump_string("alternate_name", alternate_name);
+      f->dump_unsigned("ino", ino);
+      f->dump_unsigned("remote_ino", remote_ino);
+      f->dump_unsigned("remote_d_type", remote_d_type);
+      f->dump_unsigned("nonce", nonce);
+      f->dump_unsigned("lock", lock);
+    }
   };
   WRITE_CLASS_ENCODER(dn_strong)
 

diff --git a/src/messages/MMgrReport.h b/src/messages/MMgrReport.h
index bd3c221a847eac41e01304655c3711419ed23f8f..e81282dc1a069ef339dbb09eb05014a26ae4de2c 100644 (file)
--- a/src/messages/MMgrReport.h
+++ b/src/messages/MMgrReport.h
@@ -74,6 +74,27 @@ public:
     }
     DECODE_FINISH(p);
   }
+
+  void dump(ceph::Formatter *f) const
+  {
+    f->dump_string("path", path);
+    f->dump_string("description", description);
+    f->dump_string("nick", nick);
+    f->dump_int("type", type);
+    f->dump_int("priority", priority);
+    f->dump_int("unit", unit);
+  }
+  static void generate_test_instances(std::list<PerfCounterType*>& ls)
+  {
+    ls.push_back(new PerfCounterType);
+    ls.push_back(new PerfCounterType);
+    ls.back()->path = "mycounter";
+    ls.back()->description = "mycounter description";
+    ls.back()->nick = "mycounter nick";
+    ls.back()->type = PERFCOUNTER_COUNTER;
+    ls.back()->priority = PerfCountersBuilder::PRIO_CRITICAL;
+    ls.back()->unit = UNIT_BYTES;
+  }
 };
 WRITE_CLASS_ENCODER(PerfCounterType)
 

diff --git a/src/os/bluestore/bluestore_types.cc b/src/os/bluestore/bluestore_types.cc
index 904b6fbd3d9872660f47194b7fce1459b2d42309..80a8ea06a805d69ad237aa45bff1a623b3563918 100644 (file)
--- a/src/os/bluestore/bluestore_types.cc
+++ b/src/os/bluestore/bluestore_types.cc
@@ -1087,6 +1087,15 @@ void bluestore_onode_t::shard_info::dump(Formatter *f) const
   f->dump_unsigned("bytes", bytes);
 }
 
+void bluestore_onode_t::shard_info::generate_test_instances(
+  list<shard_info*>& o)
+{
+  o.push_back(new shard_info);
+  o.push_back(new shard_info);
+  o.back()->offset = 123;
+  o.back()->bytes = 456;
+}
+
 ostream& operator<<(ostream& out, const bluestore_onode_t::shard_info& si)
 {
   return out << std::hex << "0x" << si.offset << "(0x" << si.bytes << " bytes"

diff --git a/src/os/bluestore/bluestore_types.h b/src/os/bluestore/bluestore_types.h
index 4c96e8903260f005436029913cdd86228f928318..cdedf223b055ab6d97b8238a75af979904cac4fd 100644 (file)
--- a/src/os/bluestore/bluestore_types.h
+++ b/src/os/bluestore/bluestore_types.h
@@ -954,6 +954,7 @@ struct bluestore_onode_t {
       denc_varint(v.bytes, p);
     }
     void dump(ceph::Formatter *f) const;
+    static void generate_test_instances(std::list<shard_info*>& ls);
   };
   std::vector<shard_info> extent_map_shards; ///< extent std::map shards (if any)
 

diff --git a/src/tools/ceph-dencoder/common_types.h b/src/tools/ceph-dencoder/common_types.h
index 3180e3476be28a2c69a4c5aa638af55e0499860d..e853321645ba2d5ea74251aeb280864ca224a849 100644 (file)
--- a/src/tools/ceph-dencoder/common_types.h
+++ b/src/tools/ceph-dencoder/common_types.h
@@ -23,12 +23,29 @@ TYPE(filepath)
 
 #include "include/fs_types.h"
 TYPE_FEATUREFUL(file_layout_t)
+TYPE(inodeno_t)
 
 #include "include/util.h"
 TYPE(ceph_data_stats)
 
+#include "include/object.h"
+TYPE(object_t)
+TYPE(sobject_t)
+
+#include "include/frag.h"
+TYPE(fragtree_t)
+TYPE(frag_t)
+
+#include "include/types.h"
+TYPE(shard_id_t)
+TYPE(inline_data_t)
+TYPE(sha256_digest_t)
+TYPE(errorcode32_t)
+TYPE(client_t)
+
 #include "common/bit_vector.hpp"
 TYPE(BitVector<2>)
+TYPE(ceph::BitVector<2>)
 
 #include "common/bloom_filter.hpp"
 TYPE(bloom_filter)
@@ -37,6 +54,9 @@ TYPE(compressible_bloom_filter)
 #include "common/DecayCounter.h"
 TYPE(DecayCounter)
 
+#include "common/entity_name.h"
+TYPE(EntityName)
+
 #include "common/histogram.h"
 TYPE(pow2_hist_t)
 
@@ -71,11 +91,17 @@ TYPE(cls_cas_chunk_put_ref_op)
 
 #include "cls/cas/cls_cas_internal.h"
 TYPE(chunk_refs_t)
+TYPE(chunk_refs_count_t)
+TYPE(chunk_refs_by_object_t)
 
 #include "cls/lock/cls_lock_types.h"
 TYPE(rados::cls::lock::locker_id_t)
 TYPE_FEATUREFUL(rados::cls::lock::locker_info_t)
 TYPE_FEATUREFUL(rados::cls::lock::lock_info_t)
+using namespace rados::cls::lock;
+TYPE(locker_id_t)
+TYPE_FEATUREFUL(locker_info_t)
+TYPE_FEATUREFUL(lock_info_t)
 
 #include "cls/lock/cls_lock_ops.h"
 TYPE(cls_lock_lock_op)
@@ -98,6 +124,64 @@ TYPE(obj_refcount)
 #include "cls/timeindex/cls_timeindex_types.h"
 TYPE(cls_timeindex_entry)
 
+#include "cls/timeindex/cls_timeindex_ops.h"
+TYPE(cls_timeindex_list_op)
+TYPE(cls_timeindex_list_ret)
+
+#include "cls/queue/cls_queue_types.h"
+TYPE(cls_queue_entry)
+TYPE(cls_queue_marker)
+TYPE(cls_queue_head)
+
+#include "cls/queue/cls_queue_ops.h"
+TYPE(cls_queue_get_capacity_ret)
+TYPE(cls_queue_remove_op)
+TYPE(cls_queue_enqueue_op)
+TYPE(cls_queue_list_op)
+TYPE(cls_queue_list_ret)
+TYPE(cls_queue_init_op)
+
+#include "cls/2pc_queue/cls_2pc_queue_ops.h"
+TYPE(cls_2pc_queue_abort_op)
+TYPE(cls_2pc_queue_commit_op)
+TYPE(cls_2pc_queue_expire_op)
+TYPE_NONDETERMINISTIC(cls_2pc_queue_reservations_ret)
+TYPE(cls_2pc_queue_reserve_op)
+TYPE(cls_2pc_queue_reserve_ret)
+TYPE(cls_queue_init_op)
+
+#include "cls/2pc_queue/cls_2pc_queue_types.h"
+TYPE(cls_2pc_reservation)
+TYPE_NONDETERMINISTIC(cls_2pc_urgent_data)
+
+#include "cls/log/cls_log_types.h"
+TYPE(cls_log_header)
+
+#include "cls/log/cls_log_ops.h"
+TYPE(cls_log_info_op)
+TYPE(cls_log_list_op)
+TYPE(cls_log_list_ret)
+TYPE(cls_log_trim_op)
+
+#include "cls/version/cls_version_ops.h"
+TYPE(cls_version_check_op)
+TYPE(cls_version_read_ret)
+TYPE(cls_version_inc_op)
+TYPE(cls_version_set_op)
+
+
+#include "cls/fifo/cls_fifo_ops.h"
+using namespace rados::cls::fifo::op;
+TYPE(create_meta)
+TYPE(get_meta)
+TYPE(get_meta_reply)
+
+#include "cls/fifo/cls_fifo_types.h"
+using namespace rados::cls::fifo;
+TYPE(data_params)
+TYPE(objv)
+TYPE(info)
+
 #include "journal/Entry.h"
 TYPE(journal::Entry)
 
@@ -125,9 +209,12 @@ MESSAGE(MClientReconnect)
 
 #include "messages/MClientReply.h"
 MESSAGE(MClientReply)
+TYPE(openc_response_t)
 
 #include "messages/MClientRequest.h"
 MESSAGE(MClientRequest)
+TYPE(SnapPayload)
+TYPE(MClientRequest::Release)
 
 #include "messages/MClientRequestForward.h"
 MESSAGE(MClientRequestForward)
@@ -251,6 +338,9 @@ MESSAGE(MMDSBeacon)
 
 #include "messages/MMDSCacheRejoin.h"
 MESSAGE(MMDSCacheRejoin)
+TYPE(MMDSCacheRejoin::dirfrag_strong)
+TYPE(MMDSCacheRejoin::dn_strong)
+TYPE(MMDSCacheRejoin::inode_strong)
 
 #include "messages/MMDSFindIno.h"
 MESSAGE(MMDSFindIno)
@@ -265,10 +355,14 @@ MESSAGE(MMDSFragmentNotify)
 MESSAGE(MMDSLoadTargets)
 
 #include "messages/MMDSMap.h"
-MESSAGE(MMDSMap)
+MESSAGE(MMDSMap) 
+
+#include "messages/MMgrBeacon.h"
+MESSAGE(MMgrBeacon)
 
 #include "messages/MMgrReport.h"
 MESSAGE(MMgrReport)
+TYPE(PerfCounterType)
 
 #include "messages/MMDSResolve.h"
 MESSAGE(MMDSResolve)
@@ -321,6 +415,9 @@ MESSAGE(MMonGetVersionReply)
 #include "messages/MMonGlobalID.h"
 MESSAGE(MMonGlobalID)
 
+#include "messages/MMonHealth.h"
+MESSAGE(MMonHealth)
+
 #include "messages/MMonJoin.h"
 MESSAGE(MMonJoin)
 
@@ -452,3 +549,74 @@ MESSAGE(MWatchNotify)
 
 #include "messages/MMgrUpdate.h" 
 MESSAGE(MMgrUpdate)
+
+#include "messages/MOSDECSubOpRead.h"
+MESSAGE(MOSDECSubOpRead)
+
+#include "messages/MOSDECSubOpReadReply.h"
+MESSAGE(MOSDECSubOpReadReply)
+
+#include "messages/MOSDECSubOpWrite.h"
+MESSAGE(MOSDECSubOpWrite)
+
+#include "messages/MOSDECSubOpWriteReply.h"
+MESSAGE(MOSDECSubOpWriteReply)
+
+#include "messages/MOSDMarkMeDown.h"
+MESSAGE(MOSDMarkMeDown)
+
+#include "messages/MOSDPGCreated.h"
+MESSAGE(MOSDPGCreated)
+
+#include "messages/MOSDPGPush.h"
+MESSAGE(MOSDPGPush)
+
+#include "messages/MOSDPGPushReply.h"
+MESSAGE(MOSDPGPushReply)
+
+#include "messages/MOSDPGUpdateLogMissing.h"
+MESSAGE(MOSDPGUpdateLogMissing)
+
+#include "messages/MOSDPGUpdateLogMissingReply.h"
+MESSAGE(MOSDPGUpdateLogMissingReply)
+
+#include "messages/MOSDRepOp.h"
+MESSAGE(MOSDRepOp)
+
+#include "messages/MOSDRepOpReply.h"
+MESSAGE(MOSDRepOpReply)
+
+#include "messages/MRecoveryReserve.h"
+MESSAGE(MRecoveryReserve)
+
+
+#include "auth/cephx/CephxProtocol.h"
+TYPE(CephXAuthenticate)
+TYPE(CephXAuthorize)
+TYPE(CephXAuthorizeChallenge)
+TYPE(CephXAuthorizeReply)
+TYPE(CephXChallengeBlob)
+TYPE(CephXRequestHeader)
+TYPE(CephXResponseHeader)
+TYPE(CephXServerChallenge)
+TYPE(CephXServiceTicket)
+TYPE(CephXServiceTicketInfo)
+TYPE(CephXServiceTicketRequest)
+TYPE(CephXTicketBlob)
+
+#include "auth/cephx/CephxKeyServer.h"
+TYPE(KeyServerData)
+TYPE(KeyServerData::Incremental)
+
+#include "auth/Auth.h"
+TYPE(RotatingSecrets)
+TYPE(ExpiringCryptoKey)
+TYPE(AuthCapsInfo)
+TYPE(AuthTicket)
+TYPE(EntityAuth)
+
+#include "auth/Crypto.h"
+TYPE(CryptoKey)
+
+#include "common/ceph_json.h"
+TYPE(JSONFormattable)