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

Currently, ceph-dencoder lacks certain rgw 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/cls/log/cls_log_ops.h b/src/cls/log/cls_log_ops.h
index 0cedc8802a5e43f1a0525895e6d3ba54f3ae0492..5a65892598b6e21a4b9f69f45bbdbafece94d7e2 100644 (file)
--- a/src/cls/log/cls_log_ops.h
+++ b/src/cls/log/cls_log_ops.h
@@ -27,6 +27,23 @@ struct cls_log_add_op {
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter* f) const {
+    encode_json("entries", entries, f);
+    encode_json("monotonic_inc", monotonic_inc, f);
+  }
+
+  static void generate_test_instances(std::list<cls_log_add_op *>& l) {
+    l.push_back(new cls_log_add_op);
+    l.push_back(new cls_log_add_op);
+    l.back()->entries.push_back(cls_log_entry());
+    l.back()->entries.push_back(cls_log_entry());
+    l.back()->entries.back().section = "section";
+    l.back()->entries.back().name = "name";
+    l.back()->entries.back().timestamp = utime_t(1, 2);
+    l.back()->entries.back().data.append("data");
+    l.back()->entries.back().id = "id";
+  }
 };
 WRITE_CLASS_ENCODER(cls_log_add_op)
 

diff --git a/src/cls/rgw/cls_rgw_ops.h b/src/cls/rgw/cls_rgw_ops.h
index 2891a3b61049ba06f5c9fd015de9f787a628670b..4d58909a76708d72bb3e9c980e4e8601767c9408 100644 (file)
--- a/src/cls/rgw/cls_rgw_ops.h
+++ b/src/cls/rgw/cls_rgw_ops.h
@@ -527,6 +527,17 @@ struct rgw_cls_obj_remove_op {
     decode(keep_attr_prefixes, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    encode_json("keep_attr_prefixes", keep_attr_prefixes, f);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_obj_remove_op*>& o) {
+    o.push_back(new rgw_cls_obj_remove_op);
+    o.back()->keep_attr_prefixes.push_back("keep_attr_prefixes1");
+    o.back()->keep_attr_prefixes.push_back("keep_attr_prefixes2");
+    o.back()->keep_attr_prefixes.push_back("keep_attr_prefixes3");
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_obj_remove_op)
 
@@ -544,6 +555,15 @@ struct rgw_cls_obj_store_pg_ver_op {
     decode(attr, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("attr", attr);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_obj_store_pg_ver_op*>& o) {
+    o.push_back(new rgw_cls_obj_store_pg_ver_op);
+    o.back()->attr = "attr";
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_obj_store_pg_ver_op)
 
@@ -566,6 +586,17 @@ struct rgw_cls_obj_check_attrs_prefix {
     decode(fail_if_exist, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("check_prefix", check_prefix);
+    f->dump_bool("fail_if_exist", fail_if_exist);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_obj_check_attrs_prefix*>& o) {
+    o.push_back(new rgw_cls_obj_check_attrs_prefix);
+    o.back()->check_prefix = "prefix";
+    o.back()->fail_if_exist = true;
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_obj_check_attrs_prefix)
 
@@ -619,6 +650,15 @@ struct rgw_cls_usage_log_add_op {
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_object("info", info);
+    f->dump_string("user", user.to_str());
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_usage_log_add_op*>& o) {
+    o.push_back(new rgw_cls_usage_log_add_op);
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_usage_log_add_op)
 
@@ -643,6 +683,19 @@ struct rgw_cls_bi_get_op {
     type = (BIIndexType)c;
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_stream("key") << key;
+    f->dump_int("type", (int)type);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_bi_get_op*>& o) {
+    o.push_back(new rgw_cls_bi_get_op);
+    o.push_back(new rgw_cls_bi_get_op);
+    o.back()->key.name = "key";
+    o.back()->key.instance = "instance";
+    o.back()->type = BIIndexType::Plain;
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_bi_get_op)
 
@@ -662,6 +715,15 @@ struct rgw_cls_bi_get_ret {
     decode(entry, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("entry", entry.idx);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_bi_get_ret*>& o) {
+    o.push_back(new rgw_cls_bi_get_ret);
+    o.back()->entry.idx = "entry";
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_bi_get_ret)
 
@@ -681,6 +743,16 @@ struct rgw_cls_bi_put_op {
     decode(entry, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("entry", entry.idx);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_bi_put_op*>& o) {
+    o.push_back(new rgw_cls_bi_put_op);
+    o.push_back(new rgw_cls_bi_put_op);
+    o.back()->entry.idx = "entry";
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_bi_put_op)
 
@@ -706,6 +778,20 @@ struct rgw_cls_bi_list_op {
     decode(marker, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("max", max);
+    f->dump_string("name_filter", name_filter);
+    f->dump_string("marker", marker);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_bi_list_op*>& o) {
+    o.push_back(new rgw_cls_bi_list_op);
+    o.push_back(new rgw_cls_bi_list_op);
+    o.back()->max = 100;
+    o.back()->name_filter = "name_filter";
+    o.back()->marker = "marker";
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_bi_list_op)
 
@@ -728,6 +814,20 @@ struct rgw_cls_bi_list_ret {
     decode(is_truncated, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_bool("is_truncated", is_truncated);
+    encode_json("entries", entries, f);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_bi_list_ret*>& o) {
+    o.push_back(new rgw_cls_bi_list_ret);
+    o.push_back(new rgw_cls_bi_list_ret);
+    o.back()->entries.push_back(rgw_cls_bi_entry());
+    o.back()->entries.push_back(rgw_cls_bi_entry());
+    o.back()->entries.back().idx = "entry";
+    o.back()->is_truncated = true;
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_bi_list_ret)
 
@@ -763,6 +863,25 @@ struct rgw_cls_usage_log_read_op {
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("start_epoch", start_epoch);
+    f->dump_unsigned("end_epoch", end_epoch);
+    f->dump_string("owner", owner);
+    f->dump_string("bucket", bucket);
+    f->dump_string("iter", iter);
+    f->dump_unsigned("max_entries", max_entries);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_usage_log_read_op*>& o) {
+    o.push_back(new rgw_cls_usage_log_read_op);
+    o.back()->start_epoch = 1;
+    o.back()->end_epoch = 2;
+    o.back()->owner = "owner";
+    o.back()->bucket = "bucket";
+    o.back()->iter = "iter";
+    o.back()->max_entries = 100;
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_usage_log_read_op)
 
@@ -786,6 +905,24 @@ struct rgw_cls_usage_log_read_ret {
     decode(next_iter, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_bool("truncated", truncated);
+    f->dump_string("next_iter", next_iter);
+    encode_json("usage", usage, f);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_usage_log_read_ret*>& o) {
+    o.push_back(new rgw_cls_usage_log_read_ret);
+    o.back()->next_iter = "123";
+    o.back()->truncated = true;
+    o.back()->usage.clear();
+    o.push_back(new rgw_cls_usage_log_read_ret);
+    o.back()->usage[rgw_user_bucket("user1", "bucket1")] = rgw_usage_log_entry();
+    o.back()->usage[rgw_user_bucket("user2", "bucket2")] = rgw_usage_log_entry();
+    o.back()->truncated = true;
+    o.back()->next_iter = "next_iter";
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_usage_log_read_ret)
 
@@ -814,6 +951,22 @@ struct rgw_cls_usage_log_trim_op {
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("start_epoch", start_epoch);
+    f->dump_unsigned("end_epoch", end_epoch);
+    f->dump_string("user", user);
+    f->dump_string("bucket", bucket);
+  }
+
+  static void generate_test_instances(std::list<rgw_cls_usage_log_trim_op*>& ls) {
+    rgw_cls_usage_log_trim_op *m = new rgw_cls_usage_log_trim_op;
+    m->start_epoch = 1;
+    m->end_epoch = 2;
+    m->user = "user";
+    m->bucket = "bucket";
+    ls.push_back(m);
+  }
 };
 WRITE_CLASS_ENCODER(rgw_cls_usage_log_trim_op)
 
@@ -1174,6 +1327,20 @@ struct cls_rgw_lc_set_entry_op {
     }
     DECODE_FINISH(bl);
   }
+
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("bucket", entry.bucket);
+    f->dump_int("start_time", entry.start_time);
+    f->dump_int("status", entry.status);
+  }
+
+  static void generate_test_instances(std::list<cls_rgw_lc_set_entry_op*>& ls) {
+    ls.push_back(new cls_rgw_lc_set_entry_op);
+    ls.push_back(new cls_rgw_lc_set_entry_op);
+    ls.back()->entry.bucket = "foo";
+    ls.back()->entry.start_time = 123;
+    ls.back()->entry.status = 456;
+  }
 };
 WRITE_CLASS_ENCODER(cls_rgw_lc_set_entry_op)
 

diff --git a/src/cls/rgw/cls_rgw_types.cc b/src/cls/rgw/cls_rgw_types.cc
index 14e0d988466af9455071bf4a9767357d5b57ef81..4310f4cd4a4b9cb7900768182dcb3178fb7de2d3 100644 (file)
--- a/src/cls/rgw/cls_rgw_types.cc
+++ b/src/cls/rgw/cls_rgw_types.cc
@@ -56,6 +56,20 @@ void rgw_zone_set_entry::decode_json(JSONObj *obj) {
   JSONDecoder::decode_json("entry", s, obj);
   from_str(s);
 }
+void rgw_zone_set::dump(Formatter *f) const
+{
+  encode_json("entries", entries, f);
+}
+
+void rgw_zone_set::generate_test_instances(list<rgw_zone_set*>& o)
+{
+  o.push_back(new rgw_zone_set);
+  o.push_back(new rgw_zone_set);
+  std::optional<string> loc_key = "loc_key";
+  o.back()->insert("zone1", loc_key);
+  o.back()->insert("zone2", loc_key);
+  o.back()->insert("zone3", loc_key);
+}
 
 void rgw_zone_set::insert(const string& zone, std::optional<string> location_key)
 {

diff --git a/src/cls/rgw/cls_rgw_types.h b/src/cls/rgw/cls_rgw_types.h
index f94bf114fa1e6a93989e749c80a598dd0209f9f6..5f94b9918fa46d5ae88834a81c4d1f67d1f54f07 100644 (file)
--- a/src/cls/rgw/cls_rgw_types.h
+++ b/src/cls/rgw/cls_rgw_types.h
@@ -72,7 +72,8 @@ struct rgw_zone_set {
     /* no DECODE_START, DECODE_END for backward compatibility */
     ceph::decode(entries, bl);
   }
-
+  void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<rgw_zone_set*>& o);
   void insert(const std::string& zone, std::optional<std::string> location_key);
   bool exists(const std::string& zone, std::optional<std::string> location_key) const;
 };

diff --git a/src/cls/rgw_gc/cls_rgw_gc_ops.h b/src/cls/rgw_gc/cls_rgw_gc_ops.h
index 22ddbad06d1dab9162990d999911d03066363b22..4c507c09e24da0f0beffd6efed7714bf1db6d8a7 100644 (file)
--- a/src/cls/rgw_gc/cls_rgw_gc_ops.h
+++ b/src/cls/rgw_gc/cls_rgw_gc_ops.h
@@ -25,6 +25,16 @@ struct cls_rgw_gc_queue_init_op {
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_unsigned("size", size);
+    f->dump_unsigned("num_deferred_entries", num_deferred_entries);
+  }
+
+  static void generate_test_instances(std::list<cls_rgw_gc_queue_init_op*>& o) {
+    o.push_back(new cls_rgw_gc_queue_init_op);
+    o.back()->size = 1024;
+    o.back()->num_deferred_entries = 512;
+  }
 };
 WRITE_CLASS_ENCODER(cls_rgw_gc_queue_init_op)
 

diff --git a/src/cls/rgw_gc/cls_rgw_gc_types.h b/src/cls/rgw_gc/cls_rgw_gc_types.h
index 885bf14b99387f0d21f3c8fa24e01db9d25af56c..d9a553fdcb4c2bed4813127c25bcad33f57eebd2 100644 (file)
--- a/src/cls/rgw_gc/cls_rgw_gc_types.h
+++ b/src/cls/rgw_gc/cls_rgw_gc_types.h
@@ -30,5 +30,22 @@ struct cls_rgw_gc_urgent_data
     decode(num_xattr_urgent_entries, bl);
     DECODE_FINISH(bl);
   }
+  void dump(ceph::Formatter *f) const {
+    f->open_object_section("urgent_data_map");
+    for (auto& i : urgent_data_map) {
+      f->dump_string(i.first.c_str(), i.first);
+    }
+    f->close_section();
+    f->dump_unsigned("num_urgent_data_entries", num_urgent_data_entries);
+    f->dump_unsigned("num_head_urgent_entries", num_head_urgent_entries);
+    f->dump_unsigned("num_xattr_urgent_entries", num_xattr_urgent_entries);
+  }
+  static void generate_test_instances(std::list<cls_rgw_gc_urgent_data*>& o) {
+    o.push_back(new cls_rgw_gc_urgent_data);
+    o.push_back(new cls_rgw_gc_urgent_data);
+    o.back()->num_urgent_data_entries = 1024;
+    o.back()->num_head_urgent_entries = 512;
+    o.back()->num_xattr_urgent_entries = 512;
+  }
 };
 WRITE_CLASS_ENCODER(cls_rgw_gc_urgent_data)

diff --git a/src/rgw/driver/rados/rgw_obj_manifest.cc b/src/rgw/driver/rados/rgw_obj_manifest.cc
index 92ade8120fdf8d54e2ce87a30751bcf4614f5c91..e7fc363907ffe76c2c11c08c5f4458c165384cbd 100644 (file)
--- a/src/rgw/driver/rados/rgw_obj_manifest.cc
+++ b/src/rgw/driver/rados/rgw_obj_manifest.cc
@@ -346,6 +346,18 @@ void RGWObjManifestRule::dump(Formatter *f) const
   encode_json("override_prefix", override_prefix, f);
 }
 
+void RGWObjManifestRule::generate_test_instances(std::list<RGWObjManifestRule*>& o)
+{
+  RGWObjManifestRule *r = new RGWObjManifestRule;
+  r->start_part_num = 0;
+  r->start_ofs = 0;
+  r->part_size = 512 * 1024;
+  r->stripe_max_size = 512 * 1024 * 1024;
+  r->override_prefix = "override_prefix";
+  o.push_back(r);
+  o.push_back(new RGWObjManifestRule);
+}
+
 void rgw_obj_select::dump(Formatter *f) const
 {
   f->dump_string("placement_rule", placement_rule.to_str());
@@ -361,6 +373,20 @@ void RGWObjTier::dump(Formatter *f) const
   encode_json("is_multipart_upload", is_multipart_upload, f);
 }
 
+void RGWObjTier::generate_test_instances(std::list<RGWObjTier*>& o)
+{
+  RGWObjTier *t = new RGWObjTier;
+  t->name = "name";
+  std::list<RGWZoneGroupPlacementTier *> tiers;
+  RGWZoneGroupPlacementTier::generate_test_instances(tiers);
+  for (auto iter = tiers.begin(); iter != tiers.end(); ++iter) {
+    t->tier_placement = *(*iter);
+  }
+  t->is_multipart_upload = true;
+  o.push_back(t);
+  o.push_back(new RGWObjTier);
+}
+
 // returns true on success, false on failure
 static bool rgw_get_obj_data_pool(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params,
                                   const rgw_placement_rule& head_placement_rule,

diff --git a/src/rgw/driver/rados/rgw_obj_manifest.h b/src/rgw/driver/rados/rgw_obj_manifest.h
index 6984184aa5ed2860308cd116623907d64c2476c0..b6b89653372d31551706d503e89cc803cb96e5d9 100644 (file)
--- a/src/rgw/driver/rados/rgw_obj_manifest.h
+++ b/src/rgw/driver/rados/rgw_obj_manifest.h
@@ -154,6 +154,7 @@ struct RGWObjManifestRule {
     DECODE_FINISH(bl);
   }
   void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<RGWObjManifestRule*>& o);
 };
 WRITE_CLASS_ENCODER(RGWObjManifestRule)
 
@@ -180,6 +181,7 @@ struct RGWObjTier {
       DECODE_FINISH(bl);
     }
     void dump(Formatter *f) const;
+    static void generate_test_instances(std::list<RGWObjTier*>& o);
 };
 WRITE_CLASS_ENCODER(RGWObjTier)
 

diff --git a/src/rgw/driver/rados/rgw_rados.cc b/src/rgw/driver/rados/rgw_rados.cc
index b714cbd566018cc80b54cdae1c766408647414bc..d7e3caec697c4d5d38d011545e9ac410ce60ced0 100644 (file)
--- a/src/rgw/driver/rados/rgw_rados.cc
+++ b/src/rgw/driver/rados/rgw_rados.cc
@@ -10081,3 +10081,9 @@ void RGWOLHPendingInfo::dump(Formatter *f) const
   encode_json("time", ut, f);
 }
 
+void RGWOLHPendingInfo::generate_test_instances(list<RGWOLHPendingInfo*>& o)
+{
+  auto it = new RGWOLHPendingInfo;
+  it->time = ceph::real_clock::zero();
+  o.push_back(it);
+}

diff --git a/src/rgw/driver/rados/rgw_rados.h b/src/rgw/driver/rados/rgw_rados.h
index 29e0e70cc490354efcc22f550754d8bc68e63f41..512d520cd26597a9ec2bcd49788da975e84b9762 100644 (file)
--- a/src/rgw/driver/rados/rgw_rados.h
+++ b/src/rgw/driver/rados/rgw_rados.h
@@ -131,6 +131,7 @@ struct RGWOLHPendingInfo {
   }
 
   void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<RGWOLHPendingInfo*>& o);
 };
 WRITE_CLASS_ENCODER(RGWOLHPendingInfo)
 

diff --git a/src/rgw/driver/rados/rgw_user.h b/src/rgw/driver/rados/rgw_user.h
index ea05de8063df7a73625862e35d3cad8fa58b23b4..aca905774a95130128b9f94f2d40d2408370c409 100644 (file)
--- a/src/rgw/driver/rados/rgw_user.h
+++ b/src/rgw/driver/rados/rgw_user.h
@@ -51,6 +51,14 @@ struct RGWUID
     decode(s, bl);
     user_id.from_str(s);
   }
+  void dump(Formatter *f) const {
+    f->dump_string("user_id", user_id.to_str());
+  }
+  static void generate_test_instances(std::list<RGWUID*>& o) {
+    o.push_back(new RGWUID);
+    o.push_back(new RGWUID);
+    o.back()->user_id.from_str("test:tester");
+  }
 };
 WRITE_CLASS_ENCODER(RGWUID)
 

diff --git a/src/rgw/driver/rados/rgw_zone.cc b/src/rgw/driver/rados/rgw_zone.cc
index 5ece0984dae10aa76288664b6332594c98000b05..8c237f6bedac1cb2b6e260b5c54cf7a344341076 100644 (file)
--- a/src/rgw/driver/rados/rgw_zone.cc
+++ b/src/rgw/driver/rados/rgw_zone.cc
@@ -1502,3 +1502,10 @@ void RGWNameToId::decode_json(JSONObj *obj) {
   JSONDecoder::decode_json("obj_id", obj_id, obj);
 }
 
+void RGWNameToId::generate_test_instances(list<RGWNameToId*>& o) {
+  RGWNameToId *n = new RGWNameToId;
+  n->obj_id = "id";
+  o.push_back(n);
+  o.push_back(new RGWNameToId);
+}
+

diff --git a/src/rgw/rgw_acl_types.h b/src/rgw/rgw_acl_types.h
index af256b1b5a678f389b61131fd4f56477545db131..c76d085e0b552e96979bd60291a3a29dad8ff963 100644 (file)
--- a/src/rgw/rgw_acl_types.h
+++ b/src/rgw/rgw_acl_types.h
@@ -127,7 +127,7 @@ public:
   bool is_valid_cap_type(const std::string& tp);
   void dump(Formatter *f) const;
   void dump(Formatter *f, const char *name) const;
-
+  static void generate_test_instances(std::list<RGWUserCaps*>& o);
   void decode_json(JSONObj *obj);
 };
 WRITE_CLASS_ENCODER(RGWUserCaps)

diff --git a/src/rgw/rgw_basic_types.h b/src/rgw/rgw_basic_types.h
index 25d70bdbf1b812d94091a5ac3d8cd751d15b81d3..cd30d2344bad699afc15737bb3aedd1cda52c22b 100644 (file)
--- a/src/rgw/rgw_basic_types.h
+++ b/src/rgw/rgw_basic_types.h
@@ -74,6 +74,15 @@ struct rgw_zone_id {
     ceph::decode(id, bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("id", id);
+  }
+
+  static void generate_test_instances(std::list<rgw_zone_id*>& o) {
+    o.push_back(new rgw_zone_id);
+    o.push_back(new rgw_zone_id("id"));
+  }
+
   void clear() {
     id.clear();
   }

diff --git a/src/rgw/rgw_common.cc b/src/rgw/rgw_common.cc
index 5868268c5e1b174a4e1b5a5349b581e0f7208ae1..4a11e11d2eb466a81f2aa1dfae14f176c475b0fd 100644 (file)
--- a/src/rgw/rgw_common.cc
+++ b/src/rgw/rgw_common.cc
@@ -2023,6 +2023,15 @@ void RGWUserCaps::dump(Formatter *f) const
   dump(f, "caps");
 }
 
+void RGWUserCaps::generate_test_instances(list<RGWUserCaps*>& o)
+{
+  o.push_back(new RGWUserCaps);
+  RGWUserCaps *caps = new RGWUserCaps;
+  caps->add_cap("read");
+  caps->add_cap("write");
+  o.push_back(caps);
+}
+
 void RGWUserCaps::dump(Formatter *f, const char *name) const
 {
   f->open_array_section(name);
@@ -2150,6 +2159,16 @@ void rgw_raw_obj::decode_from_rgw_obj(bufferlist::const_iterator& bl)
   pool = old_obj.get_explicit_data_pool();
 }
 
+void rgw_raw_obj::generate_test_instances(std::list<rgw_raw_obj*>& o)
+{
+  rgw_raw_obj *r = new rgw_raw_obj;
+  r->oid = "foo";
+  r->loc = "bar";
+  r->pool.name = "baz";
+  r->pool.ns = "ns";
+  o.push_back(r);
+}
+
 static struct rgw_name_to_flag op_type_mapping[] = { {"*",  RGW_OP_TYPE_ALL},
                   {"read",  RGW_OP_TYPE_READ},
                  {"write", RGW_OP_TYPE_WRITE},

diff --git a/src/rgw/rgw_common.h b/src/rgw/rgw_common.h
index 67333be998856faa76a1b7878ed3f7bea5f69ca1..f1e93796c93c5fe4ea5b8053281d208efaed3d22 100644 (file)
--- a/src/rgw/rgw_common.h
+++ b/src/rgw/rgw_common.h
@@ -1368,6 +1368,17 @@ struct multipart_upload_info
     decode(dest_placement, bl);
     DECODE_FINISH(bl);
   }
+
+  void dump(Formatter *f) const {
+    dest_placement.dump(f);
+  }
+
+  static void generate_test_instances(std::list<multipart_upload_info*>& o) {
+    o.push_back(new multipart_upload_info);
+    o.push_back(new multipart_upload_info);
+    o.back()->dest_placement.name = "dest_placement";
+    o.back()->dest_placement.storage_class = "dest_storage_class";
+  }
 };
 WRITE_CLASS_ENCODER(multipart_upload_info)
 

diff --git a/src/rgw/rgw_compression.cc b/src/rgw/rgw_compression.cc
index 8306e766a7618d459e16d165f633a99107d0e8a8..1c666e551c9b1d0aca2051ae6fcc7c9252a7ee8d 100644 (file)
--- a/src/rgw/rgw_compression.cc
+++ b/src/rgw/rgw_compression.cc
@@ -234,3 +234,14 @@ void RGWCompressionInfo::dump(Formatter *f) const
   ::encode_json("blocks", blocks, f);
 }
 
+void RGWCompressionInfo::generate_test_instances(list<RGWCompressionInfo*>& o)
+{
+  RGWCompressionInfo *i = new RGWCompressionInfo;
+  i->compression_type = "type";
+  i->orig_size = 1024;
+  i->blocks.push_back(compression_block());
+  i->blocks.back().old_ofs = 0;
+  i->blocks.back().new_ofs = 0;
+  i->blocks.back().len = 1024;
+  o.push_back(i);
+}

diff --git a/src/rgw/rgw_compression_types.h b/src/rgw/rgw_compression_types.h
index efc002efbece5c8956e84be5d85d24de89d93346..e6a79b2f0ed3295185e1b0e7a53134d545f12b87 100644 (file)
--- a/src/rgw/rgw_compression_types.h
+++ b/src/rgw/rgw_compression_types.h
@@ -71,6 +71,7 @@ struct RGWCompressionInfo {
      DECODE_FINISH(bl);
   } 
   void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<RGWCompressionInfo*>& o);
 };
 WRITE_CLASS_ENCODER(RGWCompressionInfo)
 

diff --git a/src/rgw/rgw_cors.cc b/src/rgw/rgw_cors.cc
index 83ba079b2509de8ec50377f98de6cdce0efdff15..e41abf8ccb44c34911dbe334c8a8c72085652c1b 100644 (file)
--- a/src/rgw/rgw_cors.cc
+++ b/src/rgw/rgw_cors.cc
@@ -23,6 +23,7 @@
 #include "include/types.h"
 #include "common/debug.h"
 #include "include/str_list.h"
+#include "common/ceph_json.h"
 #include "common/Formatter.h"
 
 #include "rgw_cors.h"
@@ -40,6 +41,17 @@ void RGWCORSRule::dump_origins() {
   }
 }
 
+void RGWCORSRule::dump(Formatter *f) const
+{
+  f->open_object_section("CORSRule");
+  f->dump_string("ID", id);
+  f->dump_unsigned("MaxAgeSeconds", max_age);
+  f->dump_unsigned("AllowedMethod", allowed_methods);
+  encode_json("AllowedOrigin", allowed_origins, f);
+  encode_json("AllowedHeader", allowed_hdrs, f);
+  encode_json("ExposeHeader", exposable_hdrs, f);
+}
+
 void RGWCORSRule::erase_origin_if_present(string& origin, bool *rule_empty) {
   set<string>::iterator it = allowed_origins.find(origin);
   if (!rule_empty)
@@ -53,6 +65,20 @@ void RGWCORSRule::erase_origin_if_present(string& origin, bool *rule_empty) {
   }
 }
 
+void RGWCORSRule::generate_test_instances(list<RGWCORSRule*>& o)
+{
+  o.push_back(new RGWCORSRule);
+  o.push_back(new RGWCORSRule);
+  o.back()->id = "test";
+  o.back()->max_age = 100;
+  o.back()->allowed_methods = RGW_CORS_GET | RGW_CORS_PUT;
+  o.back()->allowed_origins.insert("http://origin1");
+  o.back()->allowed_origins.insert("http://origin2");
+  o.back()->allowed_hdrs.insert("accept-encoding");
+  o.back()->allowed_hdrs.insert("accept-language");
+  o.back()->exposable_hdrs.push_back("x-rgw-something");
+}
+
 /*
  * make attrs look-like-this
  * does not convert underscores or dashes

diff --git a/src/rgw/rgw_cors.h b/src/rgw/rgw_cors.h
index c7a2ed5bd69c6d97ea3ce9efd910f817447f4554..d14c32c0cb42aeccd6b4997a31d4f1b9e8d3ecef 100644 (file)
--- a/src/rgw/rgw_cors.h
+++ b/src/rgw/rgw_cors.h
@@ -80,6 +80,7 @@ public:
     decode(exposable_hdrs, bl);
     DECODE_FINISH(bl);
   }
+  static void generate_test_instances(std::list<RGWCORSRule*>& o);
   bool has_wildcard_origin();
   bool is_origin_present(const char *o);
   void format_exp_headers(std::string& s);

diff --git a/src/rgw/rgw_obj_types.h b/src/rgw/rgw_obj_types.h
index 1347a8ad00d473c8bb5a1bcc5d2faaa2fafa6e24..70f9ddf5adf30c970ddb725f29918dea746e45db 100644 (file)
--- a/src/rgw/rgw_obj_types.h
+++ b/src/rgw/rgw_obj_types.h
@@ -475,6 +475,7 @@ struct rgw_raw_obj {
   }
 
   void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<rgw_raw_obj*>& o);
   void decode_json(JSONObj *obj);
 };
 WRITE_CLASS_ENCODER(rgw_raw_obj)

diff --git a/src/rgw/rgw_object_lock.cc b/src/rgw/rgw_object_lock.cc
index 1d44328fe696c812fb59bdbe0d3e84e1cf29a39b..fdd6608af1555ab4dea01e57593de4c9fb5c2e46 100644 (file)
--- a/src/rgw/rgw_object_lock.cc
+++ b/src/rgw/rgw_object_lock.cc
@@ -17,6 +17,15 @@ void DefaultRetention::decode_xml(XMLObj *obj) {
   }
 }
 
+void DefaultRetention::dump(Formatter *f) const {
+  f->dump_string("mode", mode);
+  if (days > 0) {
+    f->dump_int("days", days);
+  } else {
+    f->dump_int("years", years);
+  }
+}
+
 void DefaultRetention::dump_xml(Formatter *f) const {
   encode_xml("Mode", mode, f);
   if (days > 0) {
@@ -34,6 +43,17 @@ void ObjectLockRule::dump_xml(Formatter *f) const {
   encode_xml("DefaultRetention", defaultRetention, f);
 }
 
+void ObjectLockRule::dump(Formatter *f) const {
+  f->open_object_section("default_retention");
+  defaultRetention.dump(f);
+  f->close_section();
+}
+
+void ObjectLockRule::generate_test_instances(std::list<ObjectLockRule*>& o) {
+  ObjectLockRule *obj = new ObjectLockRule;
+  o.push_back(obj);
+}
+
 void RGWObjectLock::decode_xml(XMLObj *obj) {
   string enabled_str;
   RGWXMLDecoder::decode_xml("ObjectLockEnabled", enabled_str, obj, true);
@@ -54,6 +74,16 @@ void RGWObjectLock::dump_xml(Formatter *f) const {
   }
 }
 
+void RGWObjectLock::dump(Formatter *f) const {
+  f->dump_bool("enabled", enabled);
+  f->dump_bool("rule_exist", rule_exist);
+  if (rule_exist) {
+    f->open_object_section("rule");
+    rule.dump(f);
+    f->close_section();
+  }
+}
+
 ceph::real_time RGWObjectLock::get_lock_until_date(const ceph::real_time& mtime) const {
   if (!rule_exist) {
     return ceph::real_time();
@@ -64,6 +94,17 @@ ceph::real_time RGWObjectLock::get_lock_until_date(const ceph::real_time& mtime)
   return mtime + std::chrono::years(get_years());
 }
 
+void RGWObjectLock::generate_test_instances(list<RGWObjectLock*>& o) {
+  RGWObjectLock *obj = new RGWObjectLock;
+  obj->enabled = true;
+  obj->rule_exist = true;
+  o.push_back(obj);
+  obj = new RGWObjectLock;
+  obj->enabled = false;
+  obj->rule_exist = false;
+  o.push_back(obj);
+}
+
 void RGWObjectRetention::decode_xml(XMLObj *obj) {
   RGWXMLDecoder::decode_xml("Mode", mode, obj, true);
   if (mode.compare("GOVERNANCE") != 0 && mode.compare("COMPLIANCE") != 0) {

diff --git a/src/rgw/rgw_object_lock.h b/src/rgw/rgw_object_lock.h
index 27c73feaec92bc9ffa90e1611b16d439353af8c2..022aef8d45ab37853091cae3fcbe3d6959032d60 100644 (file)
--- a/src/rgw/rgw_object_lock.h
+++ b/src/rgw/rgw_object_lock.h
@@ -45,7 +45,7 @@ public:
     decode(years, bl);
     DECODE_FINISH(bl);
   }
-
+  void dump(Formatter *f) const;
   void decode_xml(XMLObj *obj);
   void dump_xml(Formatter *f) const;
 };
@@ -82,6 +82,8 @@ public:
 
   void decode_xml(XMLObj *obj);
   void dump_xml(Formatter *f) const;
+  void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<ObjectLockRule*>& o);
 };
 WRITE_CLASS_ENCODER(ObjectLockRule)
 
@@ -141,6 +143,8 @@ public:
   void decode_xml(XMLObj *obj);
   void dump_xml(Formatter *f) const;
   ceph::real_time get_lock_until_date(const ceph::real_time& mtime) const;
+  void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<RGWObjectLock*>& o);
 };
 WRITE_CLASS_ENCODER(RGWObjectLock)
 

diff --git a/src/rgw/rgw_placement_types.h b/src/rgw/rgw_placement_types.h
index bcf7a4af735b1a8432277d92ea134dc0909f90d1..10f1515330f1ac62060c5e0608b2e254b6c8230f 100644 (file)
--- a/src/rgw/rgw_placement_types.h
+++ b/src/rgw/rgw_placement_types.h
@@ -89,6 +89,16 @@ struct rgw_placement_rule {
     from_str(s);
   }
 
+  void dump(Formatter *f) const {
+    f->dump_string("name", name);
+    f->dump_string("storage_class", get_storage_class());
+  }
+
+  static void generate_test_instances(std::list<rgw_placement_rule*>& o) {
+    o.push_back(new rgw_placement_rule);
+    o.push_back(new rgw_placement_rule("name", "storage_class"));
+  }
+
   std::string to_str() const {
     if (standard_storage_class()) {
       return name;

diff --git a/src/rgw/rgw_pool_types.h b/src/rgw/rgw_pool_types.h
index b23e7d005dbe69634b87d6e67a259ff666baed75..d2b2a845e373fb8e3406306f7882998d75158755 100644 (file)
--- a/src/rgw/rgw_pool_types.h
+++ b/src/rgw/rgw_pool_types.h
@@ -90,6 +90,16 @@ struct rgw_pool {
     DECODE_FINISH(bl);
   }
 
+  void dump(ceph::Formatter *f) const {
+    f->dump_string("name", name);
+    f->dump_string("ns", ns);
+  }
+
+  static void generate_test_instances(std::list<rgw_pool*>& o) {
+    o.push_back(new rgw_pool);
+    o.push_back(new rgw_pool("pool", "ns"));
+  }
+
   rgw_pool& operator=(const rgw_pool&) = default;
 
   bool operator==(const rgw_pool& p) const {

diff --git a/src/rgw/rgw_quota.cc b/src/rgw/rgw_quota.cc
index 7591a279b87b319dd078529b36ebeaf5b051e2df..484b472a387e1300b64522b4bce3d69da6dc298c 100644 (file)
--- a/src/rgw/rgw_quota.cc
+++ b/src/rgw/rgw_quota.cc
@@ -1032,6 +1032,16 @@ void RGWQuotaInfo::dump(Formatter *f) const
   f->dump_int("max_objects", max_objects);
 }
 
+void RGWQuotaInfo::generate_test_instances(std::list<RGWQuotaInfo*>& o)
+{
+  o.push_back(new RGWQuotaInfo);
+  o.push_back(new RGWQuotaInfo);
+  o.back()->enabled = true;
+  o.back()->check_on_raw = true;
+  o.back()->max_size = 1024;
+  o.back()->max_objects = 1;
+}
+
 void RGWQuotaInfo::decode_json(JSONObj *obj)
 {
   if (false == JSONDecoder::decode_json("max_size", max_size, obj)) {

diff --git a/src/rgw/rgw_quota_types.h b/src/rgw/rgw_quota_types.h
index 8306968155533e611257bc82385a90c6e5e49653..f7d06657ed682ccd05e993c6944ca42ea817eb31 100644 (file)
--- a/src/rgw/rgw_quota_types.h
+++ b/src/rgw/rgw_quota_types.h
@@ -75,7 +75,7 @@ public:
   }
 
   void dump(Formatter *f) const;
-
+  static void generate_test_instances(std::list<RGWQuotaInfo*>& o);
   void decode_json(JSONObj *obj);
 
 };

diff --git a/src/rgw/rgw_sync_policy.cc b/src/rgw/rgw_sync_policy.cc
index cf28d5eecc48d9b4d30a1077d38d0889c491112a..0568262de6756587c6481d1e3d39f6d1f34d470c 100644 (file)
--- a/src/rgw/rgw_sync_policy.cc
+++ b/src/rgw/rgw_sync_policy.cc
@@ -774,6 +774,12 @@ void rgw_sync_policy_info::dump(Formatter *f) const
   }
 }
 
+void rgw_sync_policy_info::generate_test_instances(list<rgw_sync_policy_info*>& o)
+{
+  rgw_sync_policy_info *info = new rgw_sync_policy_info;
+  o.push_back(info);
+}
+
 void rgw_sync_policy_info::decode_json(JSONObj *obj)
 {
   vector<rgw_sync_policy_group> groups_vec;

diff --git a/src/rgw/rgw_sync_policy.h b/src/rgw/rgw_sync_policy.h
index 4758c426d4be5febe582e34c1c2d96a21e692735..98d0a4798a5d99146facc51babd3f243923fadbc 100644 (file)
--- a/src/rgw/rgw_sync_policy.h
+++ b/src/rgw/rgw_sync_policy.h
@@ -667,6 +667,7 @@ struct rgw_sync_policy_info {
   }
 
   void dump(ceph::Formatter *f) const;
+  static void generate_test_instances(std::list<rgw_sync_policy_info*>& o);
   void decode_json(JSONObj *obj);
 
   bool empty() const {

diff --git a/src/rgw/rgw_tag.cc b/src/rgw/rgw_tag.cc
index f7e52592f7711dc9dd05aaea042f87671000b6e2..b4f72185f60491e01f6504a8c088c0593062ab1b 100644 (file)
--- a/src/rgw/rgw_tag.cc
+++ b/src/rgw/rgw_tag.cc
@@ -65,3 +65,12 @@ void RGWObjTags::dump(Formatter *f) const
   f->close_section();
 }
 
+void RGWObjTags::generate_test_instances(std::list<RGWObjTags*>& o)
+{
+  RGWObjTags *r = new RGWObjTags;
+  r->add_tag("key1","val1");
+  r->add_tag("key2","val2");
+  o.push_back(r);
+  o.push_back(new RGWObjTags);
+}
+

diff --git a/src/rgw/rgw_tag.h b/src/rgw/rgw_tag.h
index 15bb25ee832cf83b01061c183705e76c3b0f94a4..a7f056d200ce740ecacba3ac06ed46a598e56790 100644 (file)
--- a/src/rgw/rgw_tag.h
+++ b/src/rgw/rgw_tag.h
@@ -36,6 +36,7 @@ protected:
   }
 
   void dump(Formatter *f) const;
+  static void generate_test_instances(std::list<RGWObjTags*>& o);
   void add_tag(const std::string& key, const std::string& val="");
   void emplace_tag(std::string&& key, std::string&& val);
   int check_and_add_tag(const std::string& key, const std::string& val="");

diff --git a/src/rgw/rgw_zone.cc b/src/rgw/rgw_zone.cc
index b743689edc0d08cfcb1a1f9139c06a2dbac7c1d4..784c9c53fdc60fb4408bd6bb2070125338381f21 100644 (file)
--- a/src/rgw/rgw_zone.cc
+++ b/src/rgw/rgw_zone.cc
@@ -770,6 +770,17 @@ void RGWZonePlacementInfo::dump(Formatter *f) const
    * rather not clutter the output */
 }
 
+void RGWZonePlacementInfo::generate_test_instances(list<RGWZonePlacementInfo*>& o)
+{
+  o.push_back(new RGWZonePlacementInfo);
+  o.push_back(new RGWZonePlacementInfo);
+  o.back()->index_pool = rgw_pool("rgw.buckets.index");
+  
+  o.back()->data_extra_pool = rgw_pool("rgw.buckets.non-ec");
+  o.back()->index_type = rgw::BucketIndexType::Normal;
+  o.back()->inline_data = false;
+}
+
 void RGWZonePlacementInfo::decode_json(JSONObj *obj)
 {
   JSONDecoder::decode_json("index_pool", index_pool, obj);
@@ -860,6 +871,11 @@ void RGWZoneStorageClasses::dump(Formatter *f) const
   }
 }
 
+void RGWZoneStorageClasses::generate_test_instances(list<RGWZoneStorageClasses*>& o)
+{
+  o.push_back(new RGWZoneStorageClasses);
+}
+
 void RGWZoneStorageClasses::decode_json(JSONObj *obj)
 {
   JSONFormattable f;
@@ -915,6 +931,14 @@ void RGWZoneStorageClass::dump(Formatter *f) const
   }
 }
 
+void RGWZoneStorageClass::generate_test_instances(list<RGWZoneStorageClass*>& o)
+{
+  o.push_back(new RGWZoneStorageClass);
+  o.push_back(new RGWZoneStorageClass);
+  o.back()->data_pool = rgw_pool("pool1");
+  o.back()->compression_type = "zlib";
+}
+
 void RGWZoneStorageClass::decode_json(JSONObj *obj)
 {
   JSONDecoder::decode_json("data_pool", data_pool, obj);

diff --git a/src/rgw/rgw_zone_types.h b/src/rgw/rgw_zone_types.h
index f2881dfef926d875ef11fe677c4bea892de40896..c8711a96d6d54b090017aa0e956ab49501ceab74 100644 (file)
--- a/src/rgw/rgw_zone_types.h
+++ b/src/rgw/rgw_zone_types.h
@@ -79,6 +79,7 @@ struct RGWNameToId {
 
   void dump(Formatter *f) const;
   void decode_json(JSONObj *obj);
+  static void generate_test_instances(std::list<RGWNameToId*>& o);
 };
 WRITE_CLASS_ENCODER(RGWNameToId)
 
@@ -122,6 +123,7 @@ struct RGWZoneStorageClass {
 
   void dump(Formatter *f) const;
   void decode_json(JSONObj *obj);
+  static void generate_test_instances(std::list<RGWZoneStorageClass*>& o);
 };
 WRITE_CLASS_ENCODER(RGWZoneStorageClass)
 
@@ -209,6 +211,7 @@ public:
 
   void dump(Formatter *f) const;
   void decode_json(JSONObj *obj);
+  static void generate_test_instances(std::list<RGWZoneStorageClasses*>& o);
 };
 WRITE_CLASS_ENCODER(RGWZoneStorageClasses)
 
@@ -305,6 +308,7 @@ struct RGWZonePlacementInfo {
 
   void dump(Formatter *f) const;
   void decode_json(JSONObj *obj);
+  static void generate_test_instances(std::list<RGWZonePlacementInfo*>& o);
 
 };
 WRITE_CLASS_ENCODER(RGWZonePlacementInfo)
@@ -574,6 +578,12 @@ struct RGWZoneGroupPlacementTier {
 
   void dump(Formatter *f) const;
   void decode_json(JSONObj *obj);
+  static void generate_test_instances(std::list<RGWZoneGroupPlacementTier*>& o) {
+    o.push_back(new RGWZoneGroupPlacementTier);
+    o.push_back(new RGWZoneGroupPlacementTier);
+    o.back()->tier_type = "cloud-s3";
+    o.back()->storage_class = "STANDARD";
+  }
 };
 WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTier)
 
@@ -621,5 +631,16 @@ struct RGWZoneGroupPlacementTarget {
   }
   void dump(Formatter *f) const;
   void decode_json(JSONObj *obj);
+  static void generate_test_instances(std::list<RGWZoneGroupPlacementTarget*>& o) {
+    o.push_back(new RGWZoneGroupPlacementTarget);
+    o.back()->storage_classes.insert("STANDARD");
+    o.push_back(new RGWZoneGroupPlacementTarget);
+    o.back()->name = "target";
+    o.back()->tags.insert("tag1");
+    o.back()->tags.insert("tag2");
+    o.back()->storage_classes.insert("STANDARD_IA");
+    o.back()->tier_targets["cloud-s3"].tier_type = "cloud-s3";
+    o.back()->tier_targets["cloud-s3"].storage_class = "STANDARD";
+  }
 };
 WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTarget)

diff --git a/src/tools/ceph-dencoder/rgw_types.h b/src/tools/ceph-dencoder/rgw_types.h
index 7a5f544eca2dfc9dcc56fc4cd913e1b0e7b3b860..45d6921c5be286bae3bedfd8e94c07604ee224ce 100644 (file)
--- a/src/tools/ceph-dencoder/rgw_types.h
+++ b/src/tools/ceph-dencoder/rgw_types.h
@@ -5,6 +5,7 @@ TYPE(RGWOLHInfo)
 TYPE(RGWObjManifestPart)
 TYPE(RGWObjManifest)
 TYPE(objexp_hint_entry)
+TYPE(RGWOLHPendingInfo)
 
 #include "rgw_zone.h"
 TYPE(RGWZoneParams)
@@ -13,6 +14,7 @@ TYPE(RGWZoneGroup)
 TYPE(RGWRealm)
 TYPE(RGWPeriod)
 TYPE(RGWPeriodLatestEpochInfo)
+TYPE(RGWNameToId)
 
 #include "rgw_acl.h"
 TYPE(ACLPermission)
@@ -33,6 +35,9 @@ TYPE(RGWLifecycleConfiguration)
 #include "cls/log/cls_log_types.h"
 TYPE(cls_log_entry)
 
+#include "cls/log/cls_log_ops.h"
+TYPE(cls_log_add_op)
+
 #include "cls/rgw/cls_rgw_types.h"
 TYPE(rgw_bucket_pending_info)
 TYPE(rgw_bucket_dir_entry_meta)
@@ -51,6 +56,7 @@ TYPE(rgw_usage_data)
 TYPE(rgw_usage_log_info)
 TYPE(rgw_user_bucket)
 TYPE(cls_rgw_lc_entry)
+TYPE(rgw_zone_set)
 
 #include "cls/rgw/cls_rgw_ops.h"
 TYPE(cls_rgw_lc_get_entry_ret)
@@ -86,6 +92,28 @@ TYPE(cls_rgw_reshard_remove_op)
 TYPE(cls_rgw_set_bucket_resharding_op)
 TYPE(cls_rgw_clear_bucket_resharding_op)
 TYPE(cls_rgw_lc_obj_head)
+TYPE(rgw_cls_bi_get_op)
+TYPE(rgw_cls_bi_get_ret)
+TYPE(rgw_cls_bi_list_op)
+TYPE(rgw_cls_bi_list_ret)
+TYPE(rgw_cls_bi_put_op)
+TYPE(rgw_cls_obj_check_attrs_prefix)
+TYPE(rgw_cls_obj_remove_op)
+TYPE(rgw_cls_obj_store_pg_ver_op)
+TYPE(rgw_cls_usage_log_add_op)
+TYPE(rgw_cls_usage_log_read_op)
+TYPE(rgw_cls_usage_log_read_ret)
+TYPE(rgw_cls_usage_log_trim_op)
+TYPE(cls_rgw_guard_bucket_resharding_op)
+TYPE(cls_rgw_lc_set_entry_op)
+
+#include "cls/rgw_gc/cls_rgw_gc_ops.h"
+TYPE(cls_rgw_gc_queue_init_op)
+#include "cls/rgw_gc/cls_rgw_gc_types.h"
+TYPE(cls_rgw_gc_urgent_data)
+
+
+
 
 #include "cls/rgw/cls_rgw_client.h"
 TYPE(rgw_bi_log_entry)
@@ -112,6 +140,14 @@ TYPE(cls::journal::ObjectPosition)
 TYPE(cls::journal::ObjectSetPosition)
 TYPE(cls::journal::Client)
 TYPE(cls::journal::Tag)
+using namespace cls::journal;
+TYPE(ObjectSetPosition)
+TYPE(ObjectPosition)
+TYPE(Tag)
+TYPE(Client)
+
+#include "cls/version/cls_version_types.h"
+TYPE(obj_version)
 
 #include "rgw_common.h"
 TYPE(RGWAccessKey)
@@ -121,6 +157,9 @@ TYPE(rgw_bucket)
 TYPE(RGWBucketInfo)
 TYPE(RGWBucketEnt)
 TYPE(rgw_obj)
+TYPE(RGWBucketEntryPoint)
+TYPE(multipart_upload_info)
+
 
 #include "rgw_log.h"
 TYPE(rgw_log_entry)
@@ -147,4 +186,54 @@ TYPE(rgw_data_sync_status)
 #include "rgw_bucket_encryption.h"
 TYPE(RGWBucketEncryptionConfig)
 
+#include "rgw_compression_types.h"
+TYPE(RGWCompressionInfo)
+
+#include "rgw_cors.h"
+TYPE(RGWCORSRule)
+
+#include "rgw_object_lock.h"
+TYPE(RGWObjectLock)
+TYPE(ObjectLockRule)
+
+
+#include "rgw_obj_types.h"
+TYPE(rgw_obj_index_key)
+TYPE(rgw_raw_obj)
+
+#include "rgw_obj_manifest.h"
+TYPE(RGWObjManifestRule)
+TYPE(RGWObjTier)
+
+#include "rgw_tag.h"
+TYPE(RGWObjTags)
+
+#include "rgw_placement_types.h"
+TYPE(rgw_placement_rule)
+
+#include "rgw_pool_types.h"
+TYPE(rgw_pool)
+
+#include "rgw_quota_types.h"
+TYPE(RGWQuotaInfo)
+
+
+#include "rgw_sync_policy.h"
+TYPE(rgw_sync_policy_info)
+
+#include "rgw_basic_types.h"
+TYPE(rgw_zone_id)
+TYPE(RGWZoneStorageClass)
+TYPE(RGWZoneStorageClasses)
+TYPE(RGWZonePlacementInfo)
+TYPE(RGWZoneGroupPlacementTarget)
+TYPE(RGWUserCaps)
+
+
+#include "rgw_user.h"
+TYPE(RGWUID)
+
+#include "rgw_user_types.h"
+TYPE(rgw_user)
+
 #endif