diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/cls/rgw/cls_rgw_types.cc | |
parent | Initial commit. (diff) | |
download | ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.tar.xz ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.zip |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/cls/rgw/cls_rgw_types.cc')
-rw-r--r-- | src/cls/rgw/cls_rgw_types.cc | 784 |
1 files changed, 784 insertions, 0 deletions
diff --git a/src/cls/rgw/cls_rgw_types.cc b/src/cls/rgw/cls_rgw_types.cc new file mode 100644 index 000000000..4a982eccb --- /dev/null +++ b/src/cls/rgw/cls_rgw_types.cc @@ -0,0 +1,784 @@ +// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- +// vim: ts=8 sw=2 smarttab + +#include "cls/rgw/cls_rgw_types.h" +#include "common/ceph_json.h" +#include "include/utime.h" + +using std::list; +using std::string; + +using ceph::bufferlist; +using ceph::Formatter; + +void rgw_zone_set_entry::from_str(const string& s) +{ + auto pos = s.find(':'); + if (pos == string::npos) { + zone = s; + location_key.reset(); + } else { + zone = s.substr(0, pos); + location_key = s.substr(pos + 1); + } +} + +string rgw_zone_set_entry::to_str() const +{ + string s = zone; + if (location_key) { + s = s + ":" + *location_key; + } + return s; +} + +void rgw_zone_set_entry::encode(bufferlist &bl) const +{ + /* no ENCODE_START, ENCODE_END for backward compatibility */ + ceph::encode(to_str(), bl); +} + +void rgw_zone_set_entry::decode(bufferlist::const_iterator &bl) +{ + /* no DECODE_START, DECODE_END for backward compatibility */ + string s; + ceph::decode(s, bl); + from_str(s); +} + +void rgw_zone_set_entry::dump(Formatter *f) const +{ + encode_json("entry", to_str(), f); +} + +void rgw_zone_set_entry::decode_json(JSONObj *obj) { + string s; + JSONDecoder::decode_json("entry", s, obj); + from_str(s); +} + +void rgw_zone_set::insert(const string& zone, std::optional<string> location_key) +{ + entries.insert(rgw_zone_set_entry(zone, location_key)); +} + +bool rgw_zone_set::exists(const string& zone, std::optional<string> location_key) const +{ + return entries.find(rgw_zone_set_entry(zone, location_key)) != entries.end(); +} + +void encode_json(const char *name, const rgw_zone_set& zs, ceph::Formatter *f) +{ + encode_json(name, zs.entries, f); +} + +void decode_json_obj(rgw_zone_set& zs, JSONObj *obj) +{ + decode_json_obj(zs.entries, obj); +} + +void rgw_bucket_pending_info::generate_test_instances(list<rgw_bucket_pending_info*>& o) +{ + rgw_bucket_pending_info *i = new rgw_bucket_pending_info; + i->state = CLS_RGW_STATE_COMPLETE; + i->op = CLS_RGW_OP_DEL; + o.push_back(i); + o.push_back(new rgw_bucket_pending_info); +} + +void rgw_bucket_pending_info::dump(Formatter *f) const +{ + encode_json("state", (int)state, f); + utime_t ut(timestamp); + encode_json("timestamp", ut, f); + encode_json("op", (int)op, f); +} + +void rgw_bucket_pending_info::decode_json(JSONObj *obj) { + int val; + JSONDecoder::decode_json("state", val, obj); + state = (RGWPendingState)val; + utime_t ut(timestamp); + JSONDecoder::decode_json("timestamp", ut, obj); + JSONDecoder::decode_json("op", val, obj); + op = (uint8_t)val; +} + +void cls_rgw_obj_key::decode_json(JSONObj *obj) { + JSONDecoder::decode_json("name", name, obj); + JSONDecoder::decode_json("instance", instance, obj); +} + +void rgw_bucket_dir_entry_meta::generate_test_instances(list<rgw_bucket_dir_entry_meta*>& o) +{ + rgw_bucket_dir_entry_meta *m = new rgw_bucket_dir_entry_meta; + m->category = RGWObjCategory::Main; + m->size = 100; + m->etag = "etag"; + m->owner = "owner"; + m->owner_display_name = "display name"; + m->content_type = "content/type"; + o.push_back(m); + o.push_back(new rgw_bucket_dir_entry_meta); +} + +void rgw_bucket_dir_entry_meta::dump(Formatter *f) const +{ + encode_json("category", (int)category, f); + encode_json("size", size, f); + utime_t ut(mtime); + encode_json("mtime", ut, f); + encode_json("etag", etag, f); + encode_json("storage_class", storage_class, f); + encode_json("owner", owner, f); + encode_json("owner_display_name", owner_display_name, f); + encode_json("content_type", content_type, f); + encode_json("accounted_size", accounted_size, f); + encode_json("user_data", user_data, f); + encode_json("appendable", appendable, f); +} + +void rgw_bucket_dir_entry_meta::decode_json(JSONObj *obj) { + int val; + JSONDecoder::decode_json("category", val, obj); + category = static_cast<RGWObjCategory>(val); + JSONDecoder::decode_json("size", size, obj); + utime_t ut; + JSONDecoder::decode_json("mtime", ut, obj); + mtime = ut.to_real_time(); + JSONDecoder::decode_json("etag", etag, obj); + JSONDecoder::decode_json("storage_class", storage_class, obj); + JSONDecoder::decode_json("owner", owner, obj); + JSONDecoder::decode_json("owner_display_name", owner_display_name, obj); + JSONDecoder::decode_json("content_type", content_type, obj); + JSONDecoder::decode_json("accounted_size", accounted_size, obj); + JSONDecoder::decode_json("user_data", user_data, obj); + JSONDecoder::decode_json("appendable", appendable, obj); +} + +void rgw_bucket_dir_entry::generate_test_instances(list<rgw_bucket_dir_entry*>& o) +{ + list<rgw_bucket_dir_entry_meta *> l; + rgw_bucket_dir_entry_meta::generate_test_instances(l); + + for (auto iter = l.begin(); iter != l.end(); ++iter) { + rgw_bucket_dir_entry_meta *m = *iter; + rgw_bucket_dir_entry *e = new rgw_bucket_dir_entry; + e->key.name = "name"; + e->ver.pool = 1; + e->ver.epoch = 1234; + e->locator = "locator"; + e->exists = true; + e->meta = *m; + e->tag = "tag"; + + o.push_back(e); + + delete m; + } + o.push_back(new rgw_bucket_dir_entry); +} + +void rgw_bucket_entry_ver::dump(Formatter *f) const +{ + encode_json("pool", pool, f); + encode_json("epoch", epoch, f); +} + +void rgw_bucket_entry_ver::decode_json(JSONObj *obj) { + JSONDecoder::decode_json("pool", pool, obj); + JSONDecoder::decode_json("epoch", epoch, obj); +} + +void rgw_bucket_entry_ver::generate_test_instances(list<rgw_bucket_entry_ver*>& ls) +{ + ls.push_back(new rgw_bucket_entry_ver); + ls.push_back(new rgw_bucket_entry_ver); + ls.back()->pool = 123; + ls.back()->epoch = 12322; +} + + +void rgw_bucket_dir_entry::dump(Formatter *f) const +{ + encode_json("name", key.name, f); + encode_json("instance", key.instance , f); + encode_json("ver", ver , f); + encode_json("locator", locator , f); + encode_json("exists", exists , f); + encode_json("meta", meta , f); + encode_json("tag", tag , f); + encode_json("flags", (int)flags , f); + encode_json("pending_map", pending_map, f); + encode_json("versioned_epoch", versioned_epoch , f); +} + +void rgw_bucket_dir_entry::decode_json(JSONObj *obj) { + JSONDecoder::decode_json("name", key.name, obj); + JSONDecoder::decode_json("instance", key.instance , obj); + JSONDecoder::decode_json("ver", ver , obj); + JSONDecoder::decode_json("locator", locator , obj); + JSONDecoder::decode_json("exists", exists , obj); + JSONDecoder::decode_json("meta", meta , obj); + JSONDecoder::decode_json("tag", tag , obj); + int val; + JSONDecoder::decode_json("flags", val , obj); + flags = (uint16_t)val; + JSONDecoder::decode_json("pending_map", pending_map, obj); + JSONDecoder::decode_json("versioned_epoch", versioned_epoch, obj); +} + +static void dump_bi_entry(bufferlist bl, BIIndexType index_type, Formatter *formatter) +{ + auto iter = bl.cbegin(); + switch (index_type) { + case BIIndexType::Plain: + case BIIndexType::Instance: + { + rgw_bucket_dir_entry entry; + decode(entry, iter); + encode_json("entry", entry, formatter); + } + break; + case BIIndexType::OLH: + { + rgw_bucket_olh_entry entry; + decode(entry, iter); + encode_json("entry", entry, formatter); + } + break; + default: + break; + } +} + +void rgw_cls_bi_entry::decode_json(JSONObj *obj, cls_rgw_obj_key *effective_key) { + JSONDecoder::decode_json("idx", idx, obj); + string s; + JSONDecoder::decode_json("type", s, obj); + if (s == "plain") { + type = BIIndexType::Plain; + } else if (s == "instance") { + type = BIIndexType::Instance; + } else if (s == "olh") { + type = BIIndexType::OLH; + } else { + type = BIIndexType::Invalid; + } + using ceph::encode; + switch (type) { + case BIIndexType::Plain: + case BIIndexType::Instance: + { + rgw_bucket_dir_entry entry; + JSONDecoder::decode_json("entry", entry, obj); + encode(entry, data); + + if (effective_key) { + *effective_key = entry.key; + } + } + break; + case BIIndexType::OLH: + { + rgw_bucket_olh_entry entry; + JSONDecoder::decode_json("entry", entry, obj); + encode(entry, data); + + if (effective_key) { + *effective_key = entry.key; + } + } + break; + default: + break; + } +} + +void rgw_cls_bi_entry::dump(Formatter *f) const +{ + string type_str; + switch (type) { + case BIIndexType::Plain: + type_str = "plain"; + break; + case BIIndexType::Instance: + type_str = "instance"; + break; + case BIIndexType::OLH: + type_str = "olh"; + break; + default: + type_str = "invalid"; + } + encode_json("type", type_str, f); + encode_json("idx", idx, f); + dump_bi_entry(data, type, f); +} + +bool rgw_cls_bi_entry::get_info(cls_rgw_obj_key *key, + RGWObjCategory *category, + rgw_bucket_category_stats *accounted_stats) +{ + bool account = false; + auto iter = data.cbegin(); + using ceph::decode; + switch (type) { + case BIIndexType::Plain: + account = true; + // NO BREAK; falls through to case InstanceIdx: + case BIIndexType::Instance: + { + rgw_bucket_dir_entry entry; + decode(entry, iter); + account = (account && entry.exists); + *key = entry.key; + *category = entry.meta.category; + accounted_stats->num_entries++; + accounted_stats->total_size += entry.meta.accounted_size; + accounted_stats->total_size_rounded += cls_rgw_get_rounded_size(entry.meta.accounted_size); + accounted_stats->actual_size += entry.meta.size; + } + break; + case BIIndexType::OLH: + { + rgw_bucket_olh_entry entry; + decode(entry, iter); + *key = entry.key; + } + break; + default: + break; + } + + return account; +} + +void rgw_bucket_olh_entry::dump(Formatter *f) const +{ + encode_json("key", key, f); + encode_json("delete_marker", delete_marker, f); + encode_json("epoch", epoch, f); + encode_json("pending_log", pending_log, f); + encode_json("tag", tag, f); + encode_json("exists", exists, f); + encode_json("pending_removal", pending_removal, f); +} + +void rgw_bucket_olh_entry::decode_json(JSONObj *obj) +{ + JSONDecoder::decode_json("key", key, obj); + JSONDecoder::decode_json("delete_marker", delete_marker, obj); + JSONDecoder::decode_json("epoch", epoch, obj); + JSONDecoder::decode_json("pending_log", pending_log, obj); + JSONDecoder::decode_json("tag", tag, obj); + JSONDecoder::decode_json("exists", exists, obj); + JSONDecoder::decode_json("pending_removal", pending_removal, obj); +} + +void rgw_bucket_olh_log_entry::generate_test_instances(list<rgw_bucket_olh_log_entry*>& o) +{ + rgw_bucket_olh_log_entry *entry = new rgw_bucket_olh_log_entry; + entry->epoch = 1234; + entry->op = CLS_RGW_OLH_OP_LINK_OLH; + entry->op_tag = "op_tag"; + entry->key.name = "key.name"; + entry->key.instance = "key.instance"; + entry->delete_marker = true; + o.push_back(entry); + o.push_back(new rgw_bucket_olh_log_entry); +} + +void rgw_bucket_olh_log_entry::dump(Formatter *f) const +{ + encode_json("epoch", epoch, f); + const char *op_str; + switch (op) { + case CLS_RGW_OLH_OP_LINK_OLH: + op_str = "link_olh"; + break; + case CLS_RGW_OLH_OP_UNLINK_OLH: + op_str = "unlink_olh"; + break; + case CLS_RGW_OLH_OP_REMOVE_INSTANCE: + op_str = "remove_instance"; + break; + default: + op_str = "unknown"; + } + encode_json("op", op_str, f); + encode_json("op_tag", op_tag, f); + encode_json("key", key, f); + encode_json("delete_marker", delete_marker, f); +} + +void rgw_bucket_olh_log_entry::decode_json(JSONObj *obj) +{ + JSONDecoder::decode_json("epoch", epoch, obj); + string op_str; + JSONDecoder::decode_json("op", op_str, obj); + if (op_str == "link_olh") { + op = CLS_RGW_OLH_OP_LINK_OLH; + } else if (op_str == "unlink_olh") { + op = CLS_RGW_OLH_OP_UNLINK_OLH; + } else if (op_str == "remove_instance") { + op = CLS_RGW_OLH_OP_REMOVE_INSTANCE; + } else { + op = CLS_RGW_OLH_OP_UNKNOWN; + } + JSONDecoder::decode_json("op_tag", op_tag, obj); + JSONDecoder::decode_json("key", key, obj); + JSONDecoder::decode_json("delete_marker", delete_marker, obj); +} +void rgw_bi_log_entry::decode_json(JSONObj *obj) +{ + JSONDecoder::decode_json("op_id", id, obj); + JSONDecoder::decode_json("op_tag", tag, obj); + string op_str; + JSONDecoder::decode_json("op", op_str, obj); + if (op_str == "write") { + op = CLS_RGW_OP_ADD; + } else if (op_str == "del") { + op = CLS_RGW_OP_DEL; + } else if (op_str == "cancel") { + op = CLS_RGW_OP_CANCEL; + } else if (op_str == "unknown") { + op = CLS_RGW_OP_UNKNOWN; + } else if (op_str == "link_olh") { + op = CLS_RGW_OP_LINK_OLH; + } else if (op_str == "link_olh_del") { + op = CLS_RGW_OP_LINK_OLH_DM; + } else if (op_str == "unlink_instance") { + op = CLS_RGW_OP_UNLINK_INSTANCE; + } else if (op_str == "syncstop") { + op = CLS_RGW_OP_SYNCSTOP; + } else if (op_str == "resync") { + op = CLS_RGW_OP_RESYNC; + } else { + op = CLS_RGW_OP_UNKNOWN; + } + JSONDecoder::decode_json("object", object, obj); + JSONDecoder::decode_json("instance", instance, obj); + string state_str; + JSONDecoder::decode_json("state", state_str, obj); + if (state_str == "pending") { + state = CLS_RGW_STATE_PENDING_MODIFY; + } else if (state_str == "complete") { + state = CLS_RGW_STATE_COMPLETE; + } else { + state = CLS_RGW_STATE_UNKNOWN; + } + JSONDecoder::decode_json("index_ver", index_ver, obj); + utime_t ut; + JSONDecoder::decode_json("timestamp", ut, obj); + timestamp = ut.to_real_time(); + uint32_t f; + JSONDecoder::decode_json("bilog_flags", f, obj); + JSONDecoder::decode_json("ver", ver, obj); + bilog_flags = (uint16_t)f; + JSONDecoder::decode_json("owner", owner, obj); + JSONDecoder::decode_json("owner_display_name", owner_display_name, obj); + JSONDecoder::decode_json("zones_trace", zones_trace, obj); +} + +void rgw_bi_log_entry::dump(Formatter *f) const +{ + f->dump_string("op_id", id); + f->dump_string("op_tag", tag); + switch (op) { + case CLS_RGW_OP_ADD: + f->dump_string("op", "write"); + break; + case CLS_RGW_OP_DEL: + f->dump_string("op", "del"); + break; + case CLS_RGW_OP_CANCEL: + f->dump_string("op", "cancel"); + break; + case CLS_RGW_OP_UNKNOWN: + f->dump_string("op", "unknown"); + break; + case CLS_RGW_OP_LINK_OLH: + f->dump_string("op", "link_olh"); + break; + case CLS_RGW_OP_LINK_OLH_DM: + f->dump_string("op", "link_olh_del"); + break; + case CLS_RGW_OP_UNLINK_INSTANCE: + f->dump_string("op", "unlink_instance"); + break; + case CLS_RGW_OP_SYNCSTOP: + f->dump_string("op", "syncstop"); + break; + case CLS_RGW_OP_RESYNC: + f->dump_string("op", "resync"); + break; + default: + f->dump_string("op", "invalid"); + break; + } + + f->dump_string("object", object); + f->dump_string("instance", instance); + + switch (state) { + case CLS_RGW_STATE_PENDING_MODIFY: + f->dump_string("state", "pending"); + break; + case CLS_RGW_STATE_COMPLETE: + f->dump_string("state", "complete"); + break; + default: + f->dump_string("state", "invalid"); + break; + } + + f->dump_int("index_ver", index_ver); + utime_t ut(timestamp); + ut.gmtime_nsec(f->dump_stream("timestamp")); + f->open_object_section("ver"); + ver.dump(f); + f->close_section(); + f->dump_int("bilog_flags", bilog_flags); + f->dump_bool("versioned", (bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0); + f->dump_string("owner", owner); + f->dump_string("owner_display_name", owner_display_name); + encode_json("zones_trace", zones_trace, f); +} + +void rgw_bi_log_entry::generate_test_instances(list<rgw_bi_log_entry*>& ls) +{ + ls.push_back(new rgw_bi_log_entry); + ls.push_back(new rgw_bi_log_entry); + ls.back()->id = "midf"; + ls.back()->object = "obj"; + ls.back()->timestamp = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)}); + ls.back()->index_ver = 4323; + ls.back()->tag = "tagasdfds"; + ls.back()->op = CLS_RGW_OP_DEL; + ls.back()->state = CLS_RGW_STATE_PENDING_MODIFY; +} + +void rgw_bucket_category_stats::generate_test_instances(list<rgw_bucket_category_stats*>& o) +{ + rgw_bucket_category_stats *s = new rgw_bucket_category_stats; + s->total_size = 1024; + s->total_size_rounded = 4096; + s->num_entries = 2; + s->actual_size = 1024; + o.push_back(s); + o.push_back(new rgw_bucket_category_stats); +} + +void rgw_bucket_category_stats::dump(Formatter *f) const +{ + f->dump_unsigned("total_size", total_size); + f->dump_unsigned("total_size_rounded", total_size_rounded); + f->dump_unsigned("num_entries", num_entries); + f->dump_unsigned("actual_size", actual_size); +} + +void rgw_bucket_dir_header::generate_test_instances(list<rgw_bucket_dir_header*>& o) +{ + list<rgw_bucket_category_stats *> l; + rgw_bucket_category_stats::generate_test_instances(l); + + uint8_t i = 0; + for (auto iter = l.begin(); iter != l.end(); ++iter, ++i) { + RGWObjCategory c = static_cast<RGWObjCategory>(i); + rgw_bucket_dir_header *h = new rgw_bucket_dir_header; + rgw_bucket_category_stats *s = *iter; + h->stats[c] = *s; + + o.push_back(h); + + delete s; + } + + o.push_back(new rgw_bucket_dir_header); +} + +void rgw_bucket_dir_header::dump(Formatter *f) const +{ + f->dump_int("ver", ver); + f->dump_int("master_ver", master_ver); + f->open_array_section("stats"); + for (auto iter = stats.begin(); iter != stats.end(); ++iter) { + f->dump_int("category", int(iter->first)); + f->open_object_section("category_stats"); + iter->second.dump(f); + f->close_section(); + } + f->close_section(); + ::encode_json("new_instance", new_instance, f); +} + +void rgw_bucket_dir::generate_test_instances(list<rgw_bucket_dir*>& o) +{ + list<rgw_bucket_dir_header *> l; + rgw_bucket_dir_header::generate_test_instances(l); + + uint8_t i = 0; + for (auto iter = l.begin(); iter != l.end(); ++iter, ++i) { + rgw_bucket_dir *d = new rgw_bucket_dir; + rgw_bucket_dir_header *h = *iter; + d->header = *h; + + list<rgw_bucket_dir_entry *> el; + for (auto eiter = el.begin(); eiter != el.end(); ++eiter) { + rgw_bucket_dir_entry *e = *eiter; + d->m[e->key.name] = *e; + + delete e; + } + + o.push_back(d); + + delete h; + } + + o.push_back(new rgw_bucket_dir); +} + +void rgw_bucket_dir::dump(Formatter *f) const +{ + f->open_object_section("header"); + header.dump(f); + f->close_section(); + auto iter = m.cbegin(); + f->open_array_section("map"); + for (; iter != m.cend(); ++iter) { + f->dump_string("key", iter->first); + f->open_object_section("dir_entry"); + iter->second.dump(f); + f->close_section(); + } + f->close_section(); +} + +void rgw_usage_log_entry::dump(Formatter *f) const +{ + f->dump_string("owner", owner.to_str()); + f->dump_string("payer", payer.to_str()); + f->dump_string("bucket", bucket); + f->dump_unsigned("epoch", epoch); + + f->open_object_section("total_usage"); + f->dump_unsigned("bytes_sent", total_usage.bytes_sent); + f->dump_unsigned("bytes_received", total_usage.bytes_received); + f->dump_unsigned("ops", total_usage.ops); + f->dump_unsigned("successful_ops", total_usage.successful_ops); + f->close_section(); + + f->open_array_section("categories"); + if (usage_map.size() > 0) { + for (auto it = usage_map.begin(); it != usage_map.end(); it++) { + const rgw_usage_data& total_usage = it->second; + f->open_object_section("entry"); + f->dump_string("category", it->first.c_str()); + f->dump_unsigned("bytes_sent", total_usage.bytes_sent); + f->dump_unsigned("bytes_received", total_usage.bytes_received); + f->dump_unsigned("ops", total_usage.ops); + f->dump_unsigned("successful_ops", total_usage.successful_ops); + f->close_section(); + } + } + f->close_section(); +} + +void rgw_usage_log_entry::generate_test_instances(list<rgw_usage_log_entry *> &o) +{ + rgw_usage_log_entry *entry = new rgw_usage_log_entry; + rgw_usage_data usage_data{1024, 2048}; + entry->owner = rgw_user("owner"); + entry->payer = rgw_user("payer"); + entry->bucket = "bucket"; + entry->epoch = 1234; + entry->total_usage.bytes_sent = usage_data.bytes_sent; + entry->total_usage.bytes_received = usage_data.bytes_received; + entry->total_usage.ops = usage_data.ops; + entry->total_usage.successful_ops = usage_data.successful_ops; + entry->usage_map["get_obj"] = usage_data; + o.push_back(entry); + o.push_back(new rgw_usage_log_entry); +} + +void cls_rgw_reshard_entry::generate_key(const string& tenant, const string& bucket_name, string *key) +{ + *key = tenant + ":" + bucket_name; +} + +void cls_rgw_reshard_entry::get_key(string *key) const +{ + generate_key(tenant, bucket_name, key); +} + +void cls_rgw_reshard_entry::dump(Formatter *f) const +{ + utime_t ut(time); + encode_json("time",ut, f); + encode_json("tenant", tenant, f); + encode_json("bucket_name", bucket_name, f); + encode_json("bucket_id", bucket_id, f); + encode_json("new_instance_id", new_instance_id, f); + encode_json("old_num_shards", old_num_shards, f); + encode_json("tentative_new_num_shards", new_num_shards, f); +} + +void cls_rgw_reshard_entry::generate_test_instances(list<cls_rgw_reshard_entry*>& ls) +{ + ls.push_back(new cls_rgw_reshard_entry); + ls.push_back(new cls_rgw_reshard_entry); + ls.back()->time = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)}); + ls.back()->tenant = "tenant"; + ls.back()->bucket_name = "bucket1"""; + ls.back()->bucket_id = "bucket_id"; + ls.back()->new_instance_id = "new_instance_id"; + ls.back()->old_num_shards = 8; + ls.back()->new_num_shards = 64; +} + +void cls_rgw_bucket_instance_entry::dump(Formatter *f) const +{ + encode_json("reshard_status", to_string(reshard_status), f); + encode_json("new_bucket_instance_id", new_bucket_instance_id, f); + encode_json("num_shards", num_shards, f); + +} + +void cls_rgw_bucket_instance_entry::generate_test_instances( + list<cls_rgw_bucket_instance_entry*>& ls) +{ + ls.push_back(new cls_rgw_bucket_instance_entry); + ls.push_back(new cls_rgw_bucket_instance_entry); + ls.back()->reshard_status = RESHARD_STATUS::IN_PROGRESS; + ls.back()->new_bucket_instance_id = "new_instance_id"; +} + +void cls_rgw_lc_obj_head::dump(Formatter *f) const +{ + encode_json("start_date", start_date, f); + encode_json("marker", marker, f); +} + +void cls_rgw_lc_obj_head::generate_test_instances(list<cls_rgw_lc_obj_head*>& ls) +{ +} + +std::ostream& operator<<(std::ostream& out, cls_rgw_reshard_status status) { + switch (status) { + case cls_rgw_reshard_status::NOT_RESHARDING: + out << "NOT_RESHARDING"; + break; + case cls_rgw_reshard_status::IN_PROGRESS: + out << "IN_PROGRESS"; + break; + case cls_rgw_reshard_status::DONE: + out << "DONE"; + break; + default: + out << "UNKNOWN_STATUS"; + } + + return out; +} |