summaryrefslogtreecommitdiffstats
path: root/src/rgw/rgw_bucket_layout.cc
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-21 11:54:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-21 11:54:28 +0000
commite6918187568dbd01842d8d1d2c808ce16a894239 (patch)
tree64f88b554b444a49f656b6c656111a145cbbaa28 /src/rgw/rgw_bucket_layout.cc
parentInitial commit. (diff)
downloadceph-e6918187568dbd01842d8d1d2c808ce16a894239.tar.xz
ceph-e6918187568dbd01842d8d1d2c808ce16a894239.zip
Adding upstream version 18.2.2.upstream/18.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/rgw/rgw_bucket_layout.cc')
-rw-r--r--src/rgw/rgw_bucket_layout.cc380
1 files changed, 380 insertions, 0 deletions
diff --git a/src/rgw/rgw_bucket_layout.cc b/src/rgw/rgw_bucket_layout.cc
new file mode 100644
index 000000000..499e8f0cd
--- /dev/null
+++ b/src/rgw/rgw_bucket_layout.cc
@@ -0,0 +1,380 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab ft=cpp
+
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2020 Red Hat, Inc.
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation. See file COPYING.
+ *
+ */
+
+#include <boost/algorithm/string.hpp>
+#include "rgw_bucket_layout.h"
+
+namespace rgw {
+
+// BucketIndexType
+std::string_view to_string(const BucketIndexType& t)
+{
+ switch (t) {
+ case BucketIndexType::Normal: return "Normal";
+ case BucketIndexType::Indexless: return "Indexless";
+ default: return "Unknown";
+ }
+}
+bool parse(std::string_view str, BucketIndexType& t)
+{
+ if (boost::iequals(str, "Normal")) {
+ t = BucketIndexType::Normal;
+ return true;
+ }
+ if (boost::iequals(str, "Indexless")) {
+ t = BucketIndexType::Indexless;
+ return true;
+ }
+ return false;
+}
+void encode_json_impl(const char *name, const BucketIndexType& t, ceph::Formatter *f)
+{
+ encode_json(name, to_string(t), f);
+}
+void decode_json_obj(BucketIndexType& t, JSONObj *obj)
+{
+ std::string str;
+ decode_json_obj(str, obj);
+ parse(str, t);
+}
+
+// BucketHashType
+std::string_view to_string(const BucketHashType& t)
+{
+ switch (t) {
+ case BucketHashType::Mod: return "Mod";
+ default: return "Unknown";
+ }
+}
+bool parse(std::string_view str, BucketHashType& t)
+{
+ if (boost::iequals(str, "Mod")) {
+ t = BucketHashType::Mod;
+ return true;
+ }
+ return false;
+}
+void encode_json_impl(const char *name, const BucketHashType& t, ceph::Formatter *f)
+{
+ encode_json(name, to_string(t), f);
+}
+void decode_json_obj(BucketHashType& t, JSONObj *obj)
+{
+ std::string str;
+ decode_json_obj(str, obj);
+ parse(str, t);
+}
+
+// bucket_index_normal_layout
+void encode(const bucket_index_normal_layout& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(1, 1, bl);
+ encode(l.num_shards, bl);
+ encode(l.hash_type, bl);
+ ENCODE_FINISH(bl);
+}
+void decode(bucket_index_normal_layout& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(1, bl);
+ decode(l.num_shards, bl);
+ decode(l.hash_type, bl);
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const bucket_index_normal_layout& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("num_shards", l.num_shards, f);
+ encode_json("hash_type", l.hash_type, f);
+ f->close_section();
+}
+void decode_json_obj(bucket_index_normal_layout& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("num_shards", l.num_shards, obj);
+ JSONDecoder::decode_json("hash_type", l.hash_type, obj);
+}
+
+// bucket_index_layout
+void encode(const bucket_index_layout& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(1, 1, bl);
+ encode(l.type, bl);
+ switch (l.type) {
+ case BucketIndexType::Normal:
+ encode(l.normal, bl);
+ break;
+ case BucketIndexType::Indexless:
+ break;
+ }
+ ENCODE_FINISH(bl);
+}
+void decode(bucket_index_layout& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(1, bl);
+ decode(l.type, bl);
+ switch (l.type) {
+ case BucketIndexType::Normal:
+ decode(l.normal, bl);
+ break;
+ case BucketIndexType::Indexless:
+ break;
+ }
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const bucket_index_layout& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("type", l.type, f);
+ encode_json("normal", l.normal, f);
+ f->close_section();
+}
+void decode_json_obj(bucket_index_layout& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("type", l.type, obj);
+ JSONDecoder::decode_json("normal", l.normal, obj);
+}
+
+// bucket_index_layout_generation
+void encode(const bucket_index_layout_generation& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(1, 1, bl);
+ encode(l.gen, bl);
+ encode(l.layout, bl);
+ ENCODE_FINISH(bl);
+}
+void decode(bucket_index_layout_generation& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(1, bl);
+ decode(l.gen, bl);
+ decode(l.layout, bl);
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const bucket_index_layout_generation& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("gen", l.gen, f);
+ encode_json("layout", l.layout, f);
+ f->close_section();
+}
+void decode_json_obj(bucket_index_layout_generation& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("gen", l.gen, obj);
+ JSONDecoder::decode_json("layout", l.layout, obj);
+}
+
+// BucketLogType
+std::string_view to_string(const BucketLogType& t)
+{
+ switch (t) {
+ case BucketLogType::InIndex: return "InIndex";
+ default: return "Unknown";
+ }
+}
+bool parse(std::string_view str, BucketLogType& t)
+{
+ if (boost::iequals(str, "InIndex")) {
+ t = BucketLogType::InIndex;
+ return true;
+ }
+ return false;
+}
+void encode_json_impl(const char *name, const BucketLogType& t, ceph::Formatter *f)
+{
+ encode_json(name, to_string(t), f);
+}
+void decode_json_obj(BucketLogType& t, JSONObj *obj)
+{
+ std::string str;
+ decode_json_obj(str, obj);
+ parse(str, t);
+}
+
+// bucket_index_log_layout
+void encode(const bucket_index_log_layout& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(1, 1, bl);
+ encode(l.gen, bl);
+ encode(l.layout, bl);
+ ENCODE_FINISH(bl);
+}
+void decode(bucket_index_log_layout& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(1, bl);
+ decode(l.gen, bl);
+ decode(l.layout, bl);
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const bucket_index_log_layout& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("gen", l.gen, f);
+ encode_json("layout", l.layout, f);
+ f->close_section();
+}
+void decode_json_obj(bucket_index_log_layout& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("gen", l.gen, obj);
+ JSONDecoder::decode_json("layout", l.layout, obj);
+}
+
+// bucket_log_layout
+void encode(const bucket_log_layout& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(1, 1, bl);
+ encode(l.type, bl);
+ switch (l.type) {
+ case BucketLogType::InIndex:
+ encode(l.in_index, bl);
+ break;
+ }
+ ENCODE_FINISH(bl);
+}
+void decode(bucket_log_layout& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(1, bl);
+ decode(l.type, bl);
+ switch (l.type) {
+ case BucketLogType::InIndex:
+ decode(l.in_index, bl);
+ break;
+ }
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const bucket_log_layout& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("type", l.type, f);
+ if (l.type == BucketLogType::InIndex) {
+ encode_json("in_index", l.in_index, f);
+ }
+ f->close_section();
+}
+void decode_json_obj(bucket_log_layout& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("type", l.type, obj);
+ JSONDecoder::decode_json("in_index", l.in_index, obj);
+}
+
+// bucket_log_layout_generation
+void encode(const bucket_log_layout_generation& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(1, 1, bl);
+ encode(l.gen, bl);
+ encode(l.layout, bl);
+ ENCODE_FINISH(bl);
+}
+void decode(bucket_log_layout_generation& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(1, bl);
+ decode(l.gen, bl);
+ decode(l.layout, bl);
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const bucket_log_layout_generation& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("gen", l.gen, f);
+ encode_json("layout", l.layout, f);
+ f->close_section();
+}
+void decode_json_obj(bucket_log_layout_generation& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("gen", l.gen, obj);
+ JSONDecoder::decode_json("layout", l.layout, obj);
+}
+
+// BucketReshardState
+std::string_view to_string(const BucketReshardState& s)
+{
+ switch (s) {
+ case BucketReshardState::None: return "None";
+ case BucketReshardState::InProgress: return "InProgress";
+ default: return "Unknown";
+ }
+}
+bool parse(std::string_view str, BucketReshardState& s)
+{
+ if (boost::iequals(str, "None")) {
+ s = BucketReshardState::None;
+ return true;
+ }
+ if (boost::iequals(str, "InProgress")) {
+ s = BucketReshardState::InProgress;
+ return true;
+ }
+ return false;
+}
+void encode_json_impl(const char *name, const BucketReshardState& s, ceph::Formatter *f)
+{
+ encode_json(name, to_string(s), f);
+}
+void decode_json_obj(BucketReshardState& s, JSONObj *obj)
+{
+ std::string str;
+ decode_json_obj(str, obj);
+ parse(str, s);
+}
+
+
+// BucketLayout
+void encode(const BucketLayout& l, bufferlist& bl, uint64_t f)
+{
+ ENCODE_START(2, 1, bl);
+ encode(l.resharding, bl);
+ encode(l.current_index, bl);
+ encode(l.target_index, bl);
+ encode(l.logs, bl);
+ ENCODE_FINISH(bl);
+}
+void decode(BucketLayout& l, bufferlist::const_iterator& bl)
+{
+ DECODE_START(2, bl);
+ decode(l.resharding, bl);
+ decode(l.current_index, bl);
+ decode(l.target_index, bl);
+ if (struct_v < 2) {
+ l.logs.clear();
+ // initialize the log layout to match the current index layout
+ if (l.current_index.layout.type == BucketIndexType::Normal) {
+ l.logs.push_back(log_layout_from_index(0, l.current_index));
+ }
+ } else {
+ decode(l.logs, bl);
+ }
+ DECODE_FINISH(bl);
+}
+void encode_json_impl(const char *name, const BucketLayout& l, ceph::Formatter *f)
+{
+ f->open_object_section(name);
+ encode_json("resharding", l.resharding, f);
+ encode_json("current_index", l.current_index, f);
+ if (l.target_index) {
+ encode_json("target_index", *l.target_index, f);
+ }
+ f->open_array_section("logs");
+ for (const auto& log : l.logs) {
+ encode_json("log", log, f);
+ }
+ f->close_section(); // logs[]
+ f->close_section();
+}
+void decode_json_obj(BucketLayout& l, JSONObj *obj)
+{
+ JSONDecoder::decode_json("resharding", l.resharding, obj);
+ JSONDecoder::decode_json("current_index", l.current_index, obj);
+ JSONDecoder::decode_json("target_index", l.target_index, obj);
+ JSONDecoder::decode_json("logs", l.logs, obj);
+}
+
+} // namespace rgw