From: NitzanMordhai Date: Tue, 27 Jun 2023 06:31:22 +0000 (+0000) Subject: ceph-dencoder: Add missing common types to ceph-dencoder for accurate encode-decode... X-Git-Tag: v19.3.0~379^2~1 X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=1d7cabf3db8b8d1863aab9c403e2935ed01a5e5d;p=ceph.git ceph-dencoder: Add missing common types to ceph-dencoder for accurate encode-decode comparison 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 --- diff --git a/src/auth/Auth.h b/src/auth/Auth.h index 5521c8d3fcf0..83e23b34dbe3 100644 --- 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& 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& 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& 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& 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& 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 ce666e8bdc8c..5d68d3470bc0 100644 --- 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& 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 a29ac1abd811..3ce655a12562 100644 --- 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& ls); void clear() { *this = CryptoKey(); diff --git a/src/auth/cephx/CephxKeyServer.cc b/src/auth/cephx/CephxKeyServer.cc index 236ac451add9..a5ad1f2b7973 100644 --- a/src/auth/cephx/CephxKeyServer.cc +++ b/src/auth/cephx/CephxKeyServer.cc @@ -257,6 +257,16 @@ std::map 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& 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 64915c8ce4aa..d147dd441ad2 100644 --- 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 secrets; - KeyRing *extra_secrets; + KeyRing *extra_secrets = nullptr; /* for each service type */ - version_t rotating_ver; + version_t rotating_ver{0}; std::map 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& 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& 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& 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 aabfaaad10c9..260cb13ff5ab 100644 --- 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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 bb61ef341ac1..3cdfd9663e8d 100644 --- 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& 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& 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& 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& 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& 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& 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 2413fd7043da..b270c9d6e790 100644 --- 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& 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& 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 09e7f9f1f69d..037e60fffd9d 100644 --- 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& 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& 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 e850c635c0b8..d466122a9527 100644 --- 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& 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& 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& 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 1c69c1f08718..2ae601e4aafa 100644 --- 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& 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& 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& 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 5a65892598b6..4d3b2f5d3091 100644 --- 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& 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& 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& 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& 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 33b8cce51e5e..29aa2bae8fe9 100644 --- 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& 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 8209659bda90..0b0b30b6f01c 100644 --- 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& 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& 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& 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& 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& 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& 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 cc46df405052..3c3e828edf0a 100644 --- 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& 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& 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& 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 f40058954dce..f0f0cc024751 100644 --- 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& 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& 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 d33886881be5..ea8d6c93d2c8 100644 --- 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 62cd1172982a..2eff788ce52c 100644 --- 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& 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& 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& 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& 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 b82f6aa8a5dd..735ef7c89857 100644 --- 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 62cc16e33d52..dafa866e1f35 100644 --- 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& 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& 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 08e8d9e46623..f7a899fd9356 100644 --- 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& 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 5357b34eacb7..a9d6fb9c8b10 100644 --- a/src/common/entity_name.cc +++ b/src/common/entity_name.cc @@ -29,21 +29,30 @@ const std::array 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& 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 c88ebcbbabde..53f8cd4d5d09 100644 --- 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& 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 049ef8e3fcf6..54d97d9d4a2f 100644 --- 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& ls); version_t version = 1; diff --git a/src/include/frag.h b/src/include/frag.h index ec18bddfbb1e..5ea2429aee8d 100644 --- 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& 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& 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 c1932bfcc30e..606b9c6503d4 100644 --- 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& 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 4564af86e577..2e5fb471c139 100644 --- 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& 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& 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 bdd09a53df10..a50a506eb0bc 100644 --- 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& 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& 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& 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& 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 diff --git a/src/mds/mdstypes.cc b/src/mds/mdstypes.cc index 044c33459606..21e17ca0e5bc 100644 --- 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& 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 be33fad49491..028c4200c149 100644 --- 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 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& 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 c62e183a7563..a51d73489186 100644 --- 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 &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& ls) { + ls.push_back(new Release); + ls.push_back(new Release); + ls.back()->item.dname_len = 4; + ls.back()->dname = "test"; + } }; mutable std::vector releases; /* XXX HACK! */ diff --git a/src/messages/MMDSCacheRejoin.h b/src/messages/MMDSCacheRejoin.h index a9211d53538a..9237c79b6e77 100644 --- 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& 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& 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& 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 bd3c221a847e..e81282dc1a06 100644 --- 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& 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 904b6fbd3d98..80a8ea06a805 100644 --- 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& 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 4c96e8903260..cdedf223b055 100644 --- 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& ls); }; std::vector 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 3180e3476be2..e853321645ba 100644 --- 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)