// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
-// vim: ts=8 sw=2 smarttab
+// vim: ts=8 sw=2 smarttab ft=cpp
#include "rgw_common.h"
#include "rgw_rados.h"
+#include "rgw_zone.h"
#include "rgw_log.h"
#include "rgw_acl.h"
#include "rgw_acl_s3.h"
#include "rgw_keystone.h"
#include "rgw_basic_types.h"
#include "rgw_op.h"
+#include "rgw_data_sync.h"
#include "rgw_sync.h"
#include "rgw_orphan.h"
+#include "rgw_bucket_sync.h"
+#include "rgw_tools.h"
#include "common/ceph_json.h"
#include "common/Formatter.h"
pool = rgw_pool(s);
}
+void encode_json(const char *name, const rgw_placement_rule& r, Formatter *f)
+{
+ encode_json(name, r.to_str(), f);
+}
+
+void decode_json_obj(rgw_placement_rule& v, JSONObj *obj)
+{
+ string s;
+ decode_json_obj(s, obj);
+ v.from_str(s);
+}
+
void RGWOLHInfo::dump(Formatter *f) const
{
encode_json("target", target, f);
encode_json("placement_rule", placement_rule, f);
}
+void rgw_obj_select::dump(Formatter *f) const
+{
+ f->dump_string("placement_rule", placement_rule.to_str());
+ f->dump_object("obj", obj);
+ f->dump_object("raw_obj", raw_obj);
+ f->dump_bool("is_raw", is_raw);
+}
+
+void RGWObjManifest::obj_iterator::dump(Formatter *f) const
+{
+ f->dump_unsigned("part_ofs", part_ofs);
+ f->dump_unsigned("stripe_ofs", stripe_ofs);
+ f->dump_unsigned("ofs", ofs);
+ f->dump_unsigned("stripe_size", stripe_size);
+ f->dump_int("cur_part_id", cur_part_id);
+ f->dump_int("cur_stripe", cur_stripe);
+ f->dump_string("cur_override_prefix", cur_override_prefix);
+ f->dump_object("location", location);
+}
+
void RGWObjManifest::dump(Formatter *f) const
{
map<uint64_t, RGWObjManifestPart>::const_iterator iter = objs.begin();
::encode_json("rules", rules, f);
::encode_json("tail_instance", tail_instance, f);
::encode_json("tail_placement", tail_placement, f);
+
+ f->dump_object("begin_iter", begin_iter);
+ f->dump_object("end_iter", end_iter);
}
void rgw_log_entry::dump(Formatter *f) const
f->dump_string("user_agent", user_agent);
f->dump_string("referrer", referrer);
f->dump_string("bucket_id", bucket_id);
+ f->dump_string("trans_id", trans_id);
}
void ACLPermission::dump(Formatter *f) const
{ RGW_PERM_READ, "read" },
{ RGW_PERM_WRITE, "write" },
{ RGW_PERM_READ_ACP, "read-acp" },
- { RGW_PERM_WRITE_ACP, "read-acp" },
+ { RGW_PERM_WRITE_ACP, "write-acp" },
{ 0, NULL }
};
-static void mask_to_str(rgw_flags_desc *mask_list, uint32_t mask, char *buf, int len)
+template <class T>
+static void mask_to_str(T *mask_list, uint32_t mask, char *buf, int len)
{
const char *sep = "";
int pos = 0;
while (mask) {
uint32_t orig_mask = mask;
for (int i = 0; mask_list[i].mask; i++) {
- struct rgw_flags_desc *desc = &mask_list[i];
+ T *desc = &mask_list[i];
if ((mask & desc->mask) == desc->mask) {
pos += snprintf(buf + pos, len - pos, "%s%s", sep, desc->str);
if (pos == len)
{ 0, NULL }
};
-static void op_type_to_str(uint32_t mask, char *buf, int len)
+extern void op_type_to_str(uint32_t mask, char *buf, int len)
{
return mask_to_str(op_type_flags, mask, buf, len);
}
encode_json("suspended", (int)suspended, f);
encode_json("max_buckets", (int)max_buckets, f);
- encode_json("auid", auid, f);
-
encode_json_map("subusers", NULL, "subuser", NULL, user_info_dump_subuser,(void *)this, subusers, f);
encode_json_map("keys", NULL, "key", NULL, user_info_dump_key,(void *)this, access_keys, f);
encode_json_map("swift_keys", NULL, "key", NULL, user_info_dump_swift_key,(void *)this, swift_keys, f);
if (system) { /* no need to show it for every user */
encode_json("system", (bool)system, f);
}
- encode_json("default_placement", default_placement, f);
+ if (admin) {
+ encode_json("admin", (bool)admin, f);
+ }
+ encode_json("default_placement", default_placement.name, f);
+ encode_json("default_storage_class", default_placement.storage_class, f);
encode_json("placement_tags", placement_tags, f);
encode_json("bucket_quota", bucket_quota, f);
encode_json("user_quota", user_quota, f);
encode_json("temp_url_keys", temp_url_keys, f);
string user_source_type;
- switch ((RGWUserSourceType)type) {
+ switch ((RGWIdentityType)type) {
case TYPE_RGW:
user_source_type = "rgw";
break;
break;
}
encode_json("type", user_source_type, f);
+ encode_json("mfa_ids", mfa_ids, f);
}
JSONDecoder::decode_json("suspended", susp, obj);
suspended = (__u8)susp;
JSONDecoder::decode_json("max_buckets", max_buckets, obj);
- JSONDecoder::decode_json("auid", auid, obj);
JSONDecoder::decode_json("keys", access_keys, decode_access_keys, obj);
JSONDecoder::decode_json("swift_keys", swift_keys, decode_swift_keys, obj);
bool sys = false;
JSONDecoder::decode_json("system", sys, obj);
system = (__u8)sys;
- JSONDecoder::decode_json("default_placement", default_placement, obj);
+ bool ad = false;
+ JSONDecoder::decode_json("admin", ad, obj);
+ admin = (__u8)ad;
+ JSONDecoder::decode_json("default_placement", default_placement.name, obj);
+ JSONDecoder::decode_json("default_storage_class", default_placement.storage_class, obj);
JSONDecoder::decode_json("placement_tags", placement_tags, obj);
JSONDecoder::decode_json("bucket_quota", bucket_quota, obj);
JSONDecoder::decode_json("user_quota", user_quota, obj);
} else if (user_source_type == "none") {
type = TYPE_NONE;
}
+ JSONDecoder::decode_json("mfa_ids", mfa_ids, obj);
}
void RGWQuotaInfo::dump(Formatter *f) const
encode_json("mdsearch_config", mdsearch_config, f);
encode_json("reshard_status", (int)reshard_status, f);
encode_json("new_bucket_instance_id", new_bucket_instance_id, f);
+ if (!empty_sync_policy()) {
+ encode_json("sync_policy", *sync_policy, f);
+ }
}
void RGWBucketInfo::decode_json(JSONObj *obj) {
if (zonegroup.empty()) {
JSONDecoder::decode_json("region", zonegroup, obj);
}
- JSONDecoder::decode_json("placement_rule", placement_rule, obj);
+ string pr;
+ JSONDecoder::decode_json("placement_rule", pr, obj);
+ placement_rule.from_str(pr);
JSONDecoder::decode_json("has_instance_obj", has_instance_obj, obj);
JSONDecoder::decode_json("quota", quota, obj);
JSONDecoder::decode_json("num_shards", num_shards, obj);
int rs;
JSONDecoder::decode_json("reshard_status", rs, obj);
reshard_status = (cls_rgw_reshard_status)rs;
- JSONDecoder::decode_json("new_bucket_instance_id",new_bucket_instance_id, obj);
+
+ rgw_sync_policy_info sp;
+ JSONDecoder::decode_json("sync_policy", sp, obj);
+ if (!sp.empty()) {
+ set_sync_policy(std::move(sp));
+ }
+}
+
+void rgw_sync_directional_rule::dump(Formatter *f) const
+{
+ encode_json("source_zone", source_zone, f);
+ encode_json("dest_zone", dest_zone, f);
+}
+
+void rgw_sync_directional_rule::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("source_zone", source_zone, obj);
+ JSONDecoder::decode_json("dest_zone", dest_zone, obj);
+}
+
+void rgw_sync_symmetric_group::dump(Formatter *f) const
+{
+ encode_json("id", id, f);
+ encode_json("zones", zones, f);
+}
+
+void rgw_sync_symmetric_group::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("id", id, obj);
+ JSONDecoder::decode_json("zones", zones, obj);
+}
+
+void rgw_sync_bucket_entity::dump(Formatter *f) const
+{
+ encode_json("zone", zone, f);
+ encode_json("bucket", bucket_key(), f);
+}
+
+void rgw_sync_bucket_entity::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("zone", zone, obj);
+ string s;
+ if (JSONDecoder::decode_json("bucket", s, obj)) {
+ rgw_bucket b;
+ int ret = rgw_bucket_parse_bucket_key(nullptr, s, &b, nullptr);
+ if (ret >= 0) {
+ bucket = b;
+ } else {
+ bucket.reset();
+ }
+ }
+}
+
+void rgw_sync_pipe_filter_tag::dump(Formatter *f) const
+{
+ encode_json("key", key, f);
+ encode_json("value", value, f);
+}
+
+void rgw_sync_pipe_filter_tag::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("key", key, obj);
+ JSONDecoder::decode_json("value", value, obj);
+}
+
+void rgw_sync_pipe_filter::dump(Formatter *f) const
+{
+ encode_json("prefix", prefix, f);
+ encode_json("tags", tags, f);
+}
+
+void rgw_sync_pipe_filter::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("prefix", prefix, obj);
+ JSONDecoder::decode_json("tags", tags, obj);
+}
+
+void rgw_sync_pipe_acl_translation::dump(Formatter *f) const
+{
+ encode_json("owner", owner, f);
+}
+
+void rgw_sync_pipe_acl_translation::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("owner", owner, obj);
+}
+
+void rgw_sync_pipe_source_params::dump(Formatter *f) const
+{
+ encode_json("filter", filter, f);
+}
+
+void rgw_sync_pipe_source_params::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("filter", filter, obj);
+}
+
+void rgw_sync_pipe_dest_params::dump(Formatter *f) const
+{
+ encode_json("acl_translation", acl_translation, f);
+ encode_json("storage_class", storage_class, f);
+}
+
+void rgw_sync_pipe_dest_params::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("acl_translation", acl_translation, obj);
+ JSONDecoder::decode_json("storage_class", storage_class, obj);
+}
+
+void rgw_sync_pipe_params::dump(Formatter *f) const
+{
+ encode_json("source", source, f);
+ encode_json("dest", dest, f);
+ encode_json("priority", priority, f);
+ string s;
+ switch (mode) {
+ case MODE_SYSTEM:
+ s = "system";
+ break;
+ default:
+ s = "user";
+ }
+ encode_json("mode", s, f);
+ encode_json("user", user, f);
+}
+
+void rgw_sync_pipe_params::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("source", source, obj);
+ JSONDecoder::decode_json("dest", dest, obj);
+ JSONDecoder::decode_json("priority", priority, obj);
+ string s;
+ JSONDecoder::decode_json("mode", s, obj);
+ if (s == "system") {
+ mode = MODE_SYSTEM;
+ } else {
+ mode = MODE_USER;
+ }
+ JSONDecoder::decode_json("user", user, obj);
+}
+
+
+void rgw_sync_bucket_entities::dump(Formatter *f) const
+{
+ encode_json("bucket", rgw_sync_bucket_entities::bucket_key(bucket), f);
+ if (zones) {
+ encode_json("zones", zones, f);
+ } else if (all_zones) {
+ set<string> z = { "*" };
+ encode_json("zones", z, f);
+ }
+}
+
+void rgw_sync_bucket_entities::decode_json(JSONObj *obj)
+{
+ string s;
+ JSONDecoder::decode_json("bucket", s, obj);
+ if (s == "*") {
+ bucket.reset();
+ } else {
+ rgw_bucket b;
+ int ret = rgw_bucket_parse_bucket_key(nullptr, s, &b, nullptr);
+ if (ret < 0) {
+ bucket.reset();
+ } else {
+ if (b.tenant == "*") {
+ b.tenant.clear();
+ }
+ if (b.name == "*") {
+ b.name.clear();
+ }
+ if (b.bucket_id == "*") {
+ b.bucket_id.clear();
+ }
+ bucket = b;
+ }
+ }
+ JSONDecoder::decode_json("zones", zones, obj);
+ if (zones && zones->size() == 1) {
+ auto iter = zones->begin();
+ if (*iter == "*") {
+ zones.reset();
+ all_zones = true;
+ }
+ }
+}
+
+void rgw_sync_bucket_pipe::dump(Formatter *f) const
+{
+ encode_json("id", id, f);
+ encode_json("source", source, f);
+ encode_json("dest", dest, f);
+ encode_json("params", params, f);
+}
+
+void rgw_sync_bucket_pipe::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("id", id, obj);
+ JSONDecoder::decode_json("source", source, obj);
+ JSONDecoder::decode_json("dest", dest, obj);
+ JSONDecoder::decode_json("params", params, obj);
+}
+
+void rgw_sync_bucket_pipes::dump(Formatter *f) const
+{
+ encode_json("id", id, f);
+ encode_json("source", source, f);
+ encode_json("dest", dest, f);
+ encode_json("params", params, f);
+}
+
+void rgw_sync_bucket_pipes::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("id", id, obj);
+ JSONDecoder::decode_json("source", source, obj);
+ JSONDecoder::decode_json("dest", dest, obj);
+ JSONDecoder::decode_json("params", params, obj);
+}
+
+void rgw_sync_data_flow_group::dump(Formatter *f) const
+{
+ if (!symmetrical.empty()) {
+ encode_json("symmetrical", symmetrical, f);
+ }
+
+ if (!directional.empty()) {
+ encode_json("directional", directional, f);
+ }
+}
+
+void rgw_sync_data_flow_group::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("symmetrical", symmetrical, obj);
+ JSONDecoder::decode_json("directional", directional, obj);
+}
+
+void rgw_sync_policy_group::dump(Formatter *f) const
+{
+ encode_json("id", id, f);
+ encode_json("data_flow", data_flow, f);
+ encode_json("pipes", pipes, f);
+ string s;
+ switch (status) {
+ case rgw_sync_policy_group::Status::FORBIDDEN:
+ s = "forbidden";
+ break;
+ case rgw_sync_policy_group::Status::ALLOWED:
+ s = "allowed";
+ break;
+ case rgw_sync_policy_group::Status::ENABLED:
+ s = "enabled";
+ break;
+ default:
+ s = "unknown";
+ }
+ encode_json("status", s, f);
+}
+
+void rgw_sync_policy_group::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("id", id, obj);
+ JSONDecoder::decode_json("data_flow", data_flow, obj);
+ JSONDecoder::decode_json("pipes", pipes, obj);
+ string s;
+ JSONDecoder::decode_json("status", s, obj);
+ set_status(s);
+}
+
+void rgw_sync_policy_info::dump(Formatter *f) const
+{
+ Formatter::ArraySection section(*f, "groups");
+ for (auto& group : groups ) {
+ encode_json("group", group.second, f);
+ }
+}
+
+void rgw_sync_policy_info::decode_json(JSONObj *obj)
+{
+ vector<rgw_sync_policy_group> groups_vec;
+
+ JSONDecoder::decode_json("groups", groups_vec, obj);
+
+ for (auto& group : groups_vec) {
+ groups.emplace(std::make_pair(group.id, std::move(group)));
+ }
}
void rgw_obj_key::dump(Formatter *f) const
encode_json("ns", ns, f);
}
+void rgw_obj_key::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("name", name, obj);
+ JSONDecoder::decode_json("instance", instance, obj);
+ JSONDecoder::decode_json("ns", ns, obj);
+}
+
void RGWBucketEnt::dump(Formatter *f) const
{
encode_json("bucket", bucket, f);
utime_t ut(creation_time);
encode_json("mtime", ut, f); /* mtime / creation time discrepency needed for backward compatibility */
encode_json("count", count, f);
- encode_json("placement_rule", placement_rule, f);
+ encode_json("placement_rule", placement_rule.to_str(), f);
}
void RGWUploadPartInfo::dump(Formatter *f) const
encode_json("log_pool", log_pool, f);
encode_json("intent_log_pool", intent_log_pool, f);
encode_json("usage_log_pool", usage_log_pool, f);
+ encode_json("roles_pool", roles_pool, f);
encode_json("reshard_pool", reshard_pool, f);
encode_json("user_keys_pool", user_keys_pool, f);
encode_json("user_email_pool", user_email_pool, f);
encode_json("user_swift_pool", user_swift_pool, f);
encode_json("user_uid_pool", user_uid_pool, f);
+ encode_json("otp_pool", otp_pool, f);
encode_json_plain("system_key", system_key, f);
encode_json("placement_pools", placement_pools, f);
- encode_json("metadata_heap", metadata_heap, f);
encode_json("tier_config", tier_config, f);
encode_json("realm_id", realm_id, f);
}
+void RGWZoneStorageClass::dump(Formatter *f) const
+{
+ if (data_pool) {
+ encode_json("data_pool", data_pool.get(), f);
+ }
+ if (compression_type) {
+ encode_json("compression_type", compression_type.get(), f);
+ }
+}
+
+void RGWZoneStorageClass::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("data_pool", data_pool, obj);
+ JSONDecoder::decode_json("compression_type", compression_type, obj);
+}
+
+void RGWZoneStorageClasses::dump(Formatter *f) const
+{
+ for (auto& i : m) {
+ encode_json(i.first.c_str(), i.second, f);
+ }
+}
+
+void RGWZoneStorageClasses::decode_json(JSONObj *obj)
+{
+ JSONFormattable f;
+ decode_json_obj(f, obj);
+
+ for (auto& field : f.object()) {
+ JSONObj *field_obj = obj->find_obj(field.first);
+ assert(field_obj);
+
+ decode_json_obj(m[field.first], field_obj);
+ }
+ standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
+}
+
void RGWZonePlacementInfo::dump(Formatter *f) const
{
encode_json("index_pool", index_pool, f);
- encode_json("data_pool", data_pool, f);
+ encode_json("storage_classes", storage_classes, f);
encode_json("data_extra_pool", data_extra_pool, f);
encode_json("index_type", (uint32_t)index_type, f);
- encode_json("compression", compression_type, f);
+
+ /* no real need for backward compatibility of compression_type and data_pool in here,
+ * rather not clutter the output */
}
void RGWZonePlacementInfo::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("index_pool", index_pool, obj);
- JSONDecoder::decode_json("data_pool", data_pool, obj);
+ JSONDecoder::decode_json("storage_classes", storage_classes, obj);
JSONDecoder::decode_json("data_extra_pool", data_extra_pool, obj);
uint32_t it;
JSONDecoder::decode_json("index_type", it, obj);
index_type = (RGWBucketIndexType)it;
- JSONDecoder::decode_json("compression", compression_type, obj);
+
+ /* backward compatibility, these are now defined in storage_classes */
+ string standard_compression_type;
+ string *pcompression = nullptr;
+ if (JSONDecoder::decode_json("compression", standard_compression_type, obj)) {
+ pcompression = &standard_compression_type;
+ }
+ rgw_pool standard_data_pool;
+ rgw_pool *ppool = nullptr;
+ if (JSONDecoder::decode_json("data_pool", standard_data_pool, obj)) {
+ ppool = &standard_data_pool;
+ }
+ if (ppool || pcompression) {
+ storage_classes.set_storage_class(RGW_STORAGE_CLASS_STANDARD, ppool, pcompression);
+ }
}
void RGWZoneParams::decode_json(JSONObj *obj)
JSONDecoder::decode_json("lc_pool", lc_pool, obj);
JSONDecoder::decode_json("log_pool", log_pool, obj);
JSONDecoder::decode_json("intent_log_pool", intent_log_pool, obj);
+ JSONDecoder::decode_json("roles_pool", roles_pool, obj);
JSONDecoder::decode_json("reshard_pool", reshard_pool, obj);
JSONDecoder::decode_json("usage_log_pool", usage_log_pool, obj);
JSONDecoder::decode_json("user_keys_pool", user_keys_pool, obj);
JSONDecoder::decode_json("user_email_pool", user_email_pool, obj);
JSONDecoder::decode_json("user_swift_pool", user_swift_pool, obj);
JSONDecoder::decode_json("user_uid_pool", user_uid_pool, obj);
+ JSONDecoder::decode_json("otp_pool", otp_pool, obj);
JSONDecoder::decode_json("system_key", system_key, obj);
JSONDecoder::decode_json("placement_pools", placement_pools, obj);
- JSONDecoder::decode_json("metadata_heap", metadata_heap, obj);
JSONDecoder::decode_json("tier_config", tier_config, obj);
JSONDecoder::decode_json("realm_id", realm_id, obj);
encode_json("tier_type", tier_type, f);
encode_json("sync_from_all", sync_from_all, f);
encode_json("sync_from", sync_from, f);
+ encode_json("redirect_zone", redirect_zone, f);
}
void RGWZone::decode_json(JSONObj *obj)
JSONDecoder::decode_json("bucket_index_max_shards", bucket_index_max_shards, obj);
JSONDecoder::decode_json("read_only", read_only, obj);
JSONDecoder::decode_json("tier_type", tier_type, obj);
- JSONDecoder::decode_json("sync_from_all", sync_from_all, obj);
+ JSONDecoder::decode_json("sync_from_all", sync_from_all, true, obj);
JSONDecoder::decode_json("sync_from", sync_from, obj);
+ JSONDecoder::decode_json("redirect_zone", redirect_zone, obj);
}
void RGWZoneGroupPlacementTarget::dump(Formatter *f) const
{
encode_json("name", name, f);
encode_json("tags", tags, f);
+ encode_json("storage_classes", storage_classes, f);
}
void RGWZoneGroupPlacementTarget::decode_json(JSONObj *obj)
{
JSONDecoder::decode_json("name", name, obj);
JSONDecoder::decode_json("tags", tags, obj);
+ JSONDecoder::decode_json("storage_classes", storage_classes, obj);
+ if (storage_classes.empty()) {
+ storage_classes.insert(RGW_STORAGE_CLASS_STANDARD);
+ }
}
void RGWZoneGroup::dump(Formatter *f) const
encode_json_map("placement_targets", placement_targets, f); /* more friendly representation */
encode_json("default_placement", default_placement, f);
encode_json("realm_id", realm_id, f);
+ encode_json("sync_policy", sync_policy, f);
}
-static void decode_zones(map<string, RGWZone>& zones, JSONObj *o)
+static void decode_zones(map<rgw_zone_id, RGWZone>& zones, JSONObj *o)
{
RGWZone z;
z.decode_json(o);
JSONDecoder::decode_json("master_zone", master_zone, obj);
JSONDecoder::decode_json("zones", zones, decode_zones, obj);
JSONDecoder::decode_json("placement_targets", placement_targets, decode_placement_targets, obj);
- JSONDecoder::decode_json("default_placement", default_placement, obj);
+ JSONDecoder::decode_json("default_placement", default_placement.name, obj);
+ JSONDecoder::decode_json("default_storage_class", default_placement.storage_class, obj);
JSONDecoder::decode_json("realm_id", realm_id, obj);
+ JSONDecoder::decode_json("sync_policy", sync_policy, obj);
}
encode_json("message", message, f);
}
+void rgw_bucket_shard_full_sync_marker::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("position", position, obj);
+ JSONDecoder::decode_json("count", count, obj);
+}
+
+void rgw_bucket_shard_full_sync_marker::dump(Formatter *f) const
+{
+ encode_json("position", position, f);
+ encode_json("count", count, f);
+}
+
+void rgw_bucket_shard_inc_sync_marker::decode_json(JSONObj *obj)
+{
+ JSONDecoder::decode_json("position", position, obj);
+}
+
+void rgw_bucket_shard_inc_sync_marker::dump(Formatter *f) const
+{
+ encode_json("position", position, f);
+}
+
+void rgw_bucket_shard_sync_info::decode_json(JSONObj *obj)
+{
+ std::string s;
+ JSONDecoder::decode_json("status", s, obj);
+ if (s == "full-sync") {
+ state = StateFullSync;
+ } else if (s == "incremental-sync") {
+ state = StateIncrementalSync;
+ } else if (s == "stopped") {
+ state = StateStopped;
+ } else {
+ state = StateInit;
+ }
+ JSONDecoder::decode_json("full_marker", full_marker, obj);
+ JSONDecoder::decode_json("inc_marker", inc_marker, obj);
+}
+
+void rgw_bucket_shard_sync_info::dump(Formatter *f) const
+{
+ const char *s{nullptr};
+ switch ((SyncState)state) {
+ case StateInit:
+ s = "init";
+ break;
+ case StateFullSync:
+ s = "full-sync";
+ break;
+ case StateIncrementalSync:
+ s = "incremental-sync";
+ break;
+ case StateStopped:
+ s = "stopped";
+ break;
+ default:
+ s = "unknown";
+ break;
+ }
+ encode_json("status", s, f);
+ encode_json("full_marker", full_marker, f);
+ encode_json("inc_marker", inc_marker, f);
+}
+
/* This utility function shouldn't conflict with the overload of std::to_string
* provided by string_ref since Boost 1.54 as it's defined outside of the std
* namespace. I hope we'll remove it soon - just after merging the Matt's PR
f->open_object_section("token_request");
f->open_object_section("auth");
f->open_object_section("passwordCredentials");
- encode_json("username", to_string(conf.get_admin_user()), f);
- encode_json("password", to_string(conf.get_admin_password()), f);
+ encode_json("username", ::to_string(conf.get_admin_user()), f);
+ encode_json("password", ::to_string(conf.get_admin_password()), f);
f->close_section();
- encode_json("tenantName", to_string(conf.get_admin_tenant()), f);
+ encode_json("tenantName", ::to_string(conf.get_admin_tenant()), f);
f->close_section();
f->close_section();
}
f->open_object_section("password");
f->open_object_section("user");
f->open_object_section("domain");
- encode_json("name", to_string(conf.get_admin_domain()), f);
+ encode_json("name", ::to_string(conf.get_admin_domain()), f);
f->close_section();
- encode_json("name", to_string(conf.get_admin_user()), f);
- encode_json("password", to_string(conf.get_admin_password()), f);
+ encode_json("name", ::to_string(conf.get_admin_user()), f);
+ encode_json("password", ::to_string(conf.get_admin_password()), f);
f->close_section();
f->close_section();
f->close_section();
f->open_object_section("scope");
f->open_object_section("project");
if (! conf.get_admin_project().empty()) {
- encode_json("name", to_string(conf.get_admin_project()), f);
+ encode_json("name", ::to_string(conf.get_admin_project()), f);
} else {
- encode_json("name", to_string(conf.get_admin_tenant()), f);
+ encode_json("name", ::to_string(conf.get_admin_tenant()), f);
}
f->open_object_section("domain");
- encode_json("name", to_string(conf.get_admin_domain()), f);
+ encode_json("name", ::to_string(conf.get_admin_domain()), f);
f->close_section();
f->close_section();
f->close_section();
encode_json("stage", stage, f);
f->close_section();
}
+
+void RGWObjTags::dump(Formatter *f) const
+{
+ f->open_object_section("tagset");
+ for (auto& tag: tag_map){
+ f->dump_string(tag.first.c_str(), tag.second);
+ }
+ f->close_section();
+}
+
+void lc_op::dump(Formatter *f) const
+{
+ f->dump_bool("status", status);
+ f->dump_bool("dm_expiration", dm_expiration);
+
+ f->dump_int("expiration", expiration);
+ f->dump_int("noncur_expiration", noncur_expiration);
+ f->dump_int("mp_expiration", mp_expiration);
+ if (expiration_date) {
+ utime_t ut(*expiration_date);
+ f->dump_stream("expiration_date") << ut;
+ }
+ if (obj_tags) {
+ f->dump_object("obj_tags", *obj_tags);
+ }
+ f->open_object_section("transitions");
+ for(auto& [storage_class, transition] : transitions) {
+ f->dump_object(storage_class, transition);
+ }
+ f->close_section();
+
+ f->open_object_section("noncur_transitions");
+ for (auto& [storage_class, transition] : noncur_transitions) {
+ f->dump_object(storage_class, transition);
+ }
+ f->close_section();
+}
+
+void LCFilter::dump(Formatter *f) const
+{
+ f->dump_string("prefix", prefix);
+ f->dump_object("obj_tags", obj_tags);
+}
+
+void LCExpiration::dump(Formatter *f) const
+{
+ f->dump_string("days", days);
+ f->dump_string("date", date);
+}
+
+void LCRule::dump(Formatter *f) const
+{
+ f->dump_string("id", id);
+ f->dump_string("prefix", prefix);
+ f->dump_string("status", status);
+ f->dump_object("expiration", expiration);
+ f->dump_object("noncur_expiration", noncur_expiration);
+ f->dump_object("mp_expiration", mp_expiration);
+ f->dump_object("filter", filter);
+ f->open_object_section("transitions");
+ for (auto& [storage_class, transition] : transitions) {
+ f->dump_object(storage_class, transition);
+ }
+ f->close_section();
+
+ f->open_object_section("noncur_transitions");
+ for (auto& [storage_class, transition] : noncur_transitions) {
+ f->dump_object(storage_class, transition);
+ }
+ f->close_section();
+ f->dump_bool("dm_expiration", dm_expiration);
+}
+
+void RGWLifecycleConfiguration::dump(Formatter *f) const
+{
+ f->open_object_section("prefix_map");
+ for (auto& prefix : prefix_map) {
+ f->dump_object(prefix.first.c_str(), prefix.second);
+ }
+ f->close_section();
+
+ f->open_array_section("rule_map");
+ for (auto& rule : rule_map) {
+ f->open_object_section("entry");
+ f->dump_string("id", rule.first);
+ f->open_object_section("rule");
+ rule.second.dump(f);
+ f->close_section();
+ f->close_section();
+ }
+ f->close_section();
+}
+
+void compression_block::dump(Formatter *f) const
+{
+ f->dump_unsigned("old_ofs", old_ofs);
+ f->dump_unsigned("new_ofs", new_ofs);
+ f->dump_unsigned("len", len);
+}
+
+void RGWCompressionInfo::dump(Formatter *f) const
+{
+ f->dump_string("compression_type", compression_type);
+ f->dump_unsigned("orig_size", orig_size);
+ ::encode_json("blocks", blocks, f);
+}
+
+void objexp_hint_entry::dump(Formatter *f) const
+{
+ f->open_object_section("objexp_hint_entry");
+ encode_json("tenant", tenant, f);
+ encode_json("bucket_name", bucket_name, f);
+ encode_json("bucket_id", bucket_id, f);
+ encode_json("rgw_obj_key", obj_key, f);
+ utime_t ut(exp_time);
+ encode_json("exp_time", ut, f);
+ f->close_section();
+}
+
+void rgw_user::dump(Formatter *f) const
+{
+ ::encode_json("user", *this, f);
+}
projects / ceph.git / blobdiff