set(cls_otp_srcs otp/cls_otp.cc)
add_library(cls_otp SHARED ${cls_otp_srcs})
target_link_libraries(cls_otp OATH::OATH)
+ target_include_directories(cls_otp
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw/driver/rados"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/spawn/include")
set_target_properties(cls_otp PROPERTIES
VERSION "1.0.0"
SOVERSION "1"
${CMAKE_SOURCE_DIR}/src/common/ceph_json.cc)
add_library(cls_rgw SHARED ${cls_rgw_srcs})
target_link_libraries(cls_rgw json_spirit)
+ target_include_directories(cls_rgw
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw/driver/rados"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/spawn/include")
set_target_properties(cls_rgw PROPERTIES
VERSION "1.0.0"
SOVERSION "1"
rgw/cls_rgw_types.cc
rgw/cls_rgw_ops.cc)
add_library(cls_rgw_client STATIC ${cls_rgw_client_srcs})
+ target_include_directories(cls_rgw_client
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw/driver/rados"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/spawn/include")
endif (WITH_RADOSGW)
queue/cls_queue_src.cc
${CMAKE_SOURCE_DIR}/src/common/ceph_json.cc)
add_library(cls_rgw_gc SHARED ${cls_rgw_gc_srcs})
+ target_include_directories(cls_rgw_gc
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw/driver/rados"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/spawn/include")
set_target_properties(cls_rgw_gc PROPERTIES
VERSION "1.0.0"
SOVERSION "1"
set(cls_rgw_gc_client_srcs
rgw_gc/cls_rgw_gc_client.cc)
add_library(cls_rgw_gc_client STATIC ${cls_rgw_gc_client_srcs})
+ target_include_directories(cls_rgw_gc_client
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw/driver/rados"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/spawn/include")
endif (WITH_RADOSGW)
};
WRITE_CLASS_ENCODER(rgw_bucket_entry_ver)
-
-struct cls_rgw_obj_key {
- std::string name;
- std::string instance;
-
- cls_rgw_obj_key() {}
- cls_rgw_obj_key(const std::string &_name) : name(_name) {}
- cls_rgw_obj_key(const std::string& n, const std::string& i) : name(n), instance(i) {}
-
- std::string to_string() const {
- return fmt::format("{}({})", name, instance);
- }
-
- bool empty() const {
- return name.empty();
- }
-
- void set(const std::string& _name) {
- name = _name;
- instance.clear();
- }
-
- bool operator==(const cls_rgw_obj_key& k) const {
- return (name.compare(k.name) == 0) &&
- (instance.compare(k.instance) == 0);
- }
-
- bool operator!=(const cls_rgw_obj_key& k) const {
- return (name.compare(k.name) != 0) ||
- (instance.compare(k.instance) != 0);
- }
-
- bool operator<(const cls_rgw_obj_key& k) const {
- int r = name.compare(k.name);
- if (r == 0) {
- r = instance.compare(k.instance);
- }
- return (r < 0);
- }
-
- bool operator<=(const cls_rgw_obj_key& k) const {
- return !(k < *this);
- }
-
- void encode(ceph::buffer::list &bl) const {
- ENCODE_START(1, 1, bl);
- encode(name, bl);
- encode(instance, bl);
- ENCODE_FINISH(bl);
- }
- void decode(ceph::buffer::list::const_iterator &bl) {
- DECODE_START(1, bl);
- decode(name, bl);
- decode(instance, bl);
- DECODE_FINISH(bl);
- }
- void dump(ceph::Formatter *f) const {
- f->dump_string("name", name);
- f->dump_string("instance", instance);
- }
- void decode_json(JSONObj *obj);
- static void generate_test_instances(std::list<cls_rgw_obj_key*>& ls) {
- ls.push_back(new cls_rgw_obj_key);
- ls.push_back(new cls_rgw_obj_key);
- ls.back()->name = "name";
- ls.back()->instance = "instance";
- }
-
- size_t estimate_encoded_size() const {
- constexpr size_t start_overhead = sizeof(__u8) + sizeof(__u8) + sizeof(ceph_le32); // version and length prefix
- constexpr size_t string_overhead = sizeof(__u32); // strings are encoded with 32-bit length prefix
- return start_overhead +
- string_overhead + name.size() +
- string_overhead + instance.size();
- }
-};
-WRITE_CLASS_ENCODER(cls_rgw_obj_key)
+typedef rgw_obj_index_key cls_rgw_obj_key;
inline std::ostream& operator<<(std::ostream& out, const cls_rgw_obj_key& o) {
out << o.name;
*
*/
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
#pragma once
-#include "rgw_common.h"
-#include "rgw_compression_types.h"
-#include "rgw_sal.h"
-#include "rgw_zone.h"
+#include "rgw_zone_types.h"
+#include "rgw_bucket_types.h"
+#include "rgw_obj_types.h"
+#include "rgw_placement_types.h"
+
+#include "common/dout.h"
+#include "common/Formatter.h"
class RGWSI_Zone;
struct RGWZoneGroup;
struct RGWZoneParams;
class RGWRados;
+
namespace rgw { namespace sal {
class RadosStore;
} };
#include "rgw_user.h"
#include "rgw_bucket.h"
+#include "rgw_quota.h"
#include "services/svc_user.h"
#include "services/svc_meta.h"
#define CEPH_RGW_ZONE_H
#include <ostream>
+#include "rgw_zone_types.h"
#include "rgw_common.h"
#include "rgw_sal_fwd.h"
#include "rgw_sync_policy.h"
-#include "rgw_zone_features.h"
-
-namespace rgw_zone_defaults {
-
-extern std::string zone_names_oid_prefix;
-extern std::string region_info_oid_prefix;
-extern std::string realm_names_oid_prefix;
-extern std::string zone_group_info_oid_prefix;
-extern std::string realm_info_oid_prefix;
-extern std::string default_region_info_oid;
-extern std::string default_zone_group_info_oid;
-extern std::string region_map_oid;
-extern std::string default_realm_info_oid;
-extern std::string default_zonegroup_name;
-extern std::string default_zone_name;
-extern std::string zonegroup_names_oid_prefix;
-extern std::string RGW_DEFAULT_ZONE_ROOT_POOL;
-extern std::string RGW_DEFAULT_ZONEGROUP_ROOT_POOL;
-extern std::string RGW_DEFAULT_REALM_ROOT_POOL;
-extern std::string RGW_DEFAULT_PERIOD_ROOT_POOL;
-extern std::string avail_pools;
-extern std::string default_storage_pool_suffix;
-
-}
-
-class JSONObj;
-class RGWSyncModulesManager;
-
-
-struct RGWNameToId {
- std::string obj_id;
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(obj_id, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(obj_id, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWNameToId)
-struct RGWDefaultSystemMetaObjInfo {
- std::string default_id;
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(default_id, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(default_id, bl);
- DECODE_FINISH(bl);
- }
-
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWDefaultSystemMetaObjInfo)
+class RGWSyncModulesManager;
class RGWSI_SysObj;
class RGWSI_Zone;
};
WRITE_CLASS_ENCODER(RGWSystemMetaObj)
-struct RGWZoneStorageClass {
- boost::optional<rgw_pool> data_pool;
- boost::optional<std::string> compression_type;
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(data_pool, bl);
- encode(compression_type, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(data_pool, bl);
- decode(compression_type, bl);
- DECODE_FINISH(bl);
- }
-
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWZoneStorageClass)
-
-
-class RGWZoneStorageClasses {
- std::map<std::string, RGWZoneStorageClass> m;
-
- /* in memory only */
- RGWZoneStorageClass *standard_class;
-
-public:
- RGWZoneStorageClasses() {
- standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
- }
- RGWZoneStorageClasses(const RGWZoneStorageClasses& rhs) {
- m = rhs.m;
- standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
- }
- RGWZoneStorageClasses& operator=(const RGWZoneStorageClasses& rhs) {
- m = rhs.m;
- standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
- return *this;
- }
-
- const RGWZoneStorageClass& get_standard() const {
- return *standard_class;
- }
-
- bool find(const std::string& sc, const RGWZoneStorageClass **pstorage_class) const {
- auto iter = m.find(sc);
- if (iter == m.end()) {
- return false;
- }
- *pstorage_class = &iter->second;
- return true;
- }
-
- bool exists(const std::string& sc) const {
- if (sc.empty()) {
- return true;
- }
- auto iter = m.find(sc);
- return (iter != m.end());
- }
-
- const std::map<std::string, RGWZoneStorageClass>& get_all() const {
- return m;
- }
-
- std::map<std::string, RGWZoneStorageClass>& get_all() {
- return m;
- }
-
- void set_storage_class(const std::string& sc, const rgw_pool *data_pool, const std::string *compression_type) {
- const std::string *psc = ≻
- if (sc.empty()) {
- psc = &RGW_STORAGE_CLASS_STANDARD;
- }
- RGWZoneStorageClass& storage_class = m[*psc];
- if (data_pool) {
- storage_class.data_pool = *data_pool;
- }
- if (compression_type) {
- storage_class.compression_type = *compression_type;
- }
- }
-
- void remove_storage_class(const std::string& sc) {
- if (!sc.empty()) {
- m.erase(sc);
- }
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(m, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(m, bl);
- standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
- DECODE_FINISH(bl);
- }
-
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWZoneStorageClasses)
-
-struct RGWZonePlacementInfo {
- rgw_pool index_pool;
- rgw_pool data_extra_pool; /* if not set we should use data_pool */
- RGWZoneStorageClasses storage_classes;
- rgw::BucketIndexType index_type;
-
- RGWZonePlacementInfo() : index_type(rgw::BucketIndexType::Normal) {}
-
- void encode(bufferlist& bl) const {
- ENCODE_START(7, 1, bl);
- encode(index_pool.to_str(), bl);
- rgw_pool standard_data_pool = get_data_pool(RGW_STORAGE_CLASS_STANDARD);
- encode(standard_data_pool.to_str(), bl);
- encode(data_extra_pool.to_str(), bl);
- encode((uint32_t)index_type, bl);
- std::string standard_compression_type = get_compression_type(RGW_STORAGE_CLASS_STANDARD);
- encode(standard_compression_type, bl);
- encode(storage_classes, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(7, bl);
- std::string index_pool_str;
- std::string data_pool_str;
- decode(index_pool_str, bl);
- index_pool = rgw_pool(index_pool_str);
- decode(data_pool_str, bl);
- rgw_pool standard_data_pool(data_pool_str);
- if (struct_v >= 4) {
- std::string data_extra_pool_str;
- decode(data_extra_pool_str, bl);
- data_extra_pool = rgw_pool(data_extra_pool_str);
- }
- if (struct_v >= 5) {
- uint32_t it;
- decode(it, bl);
- index_type = (rgw::BucketIndexType)it;
- }
- std::string standard_compression_type;
- if (struct_v >= 6) {
- decode(standard_compression_type, bl);
- }
- if (struct_v >= 7) {
- decode(storage_classes, bl);
- } else {
- storage_classes.set_storage_class(RGW_STORAGE_CLASS_STANDARD, &standard_data_pool,
- (!standard_compression_type.empty() ? &standard_compression_type : nullptr));
- }
- DECODE_FINISH(bl);
- }
- const rgw_pool& get_data_extra_pool() const {
- static rgw_pool no_pool;
- if (data_extra_pool.empty()) {
- return storage_classes.get_standard().data_pool.get_value_or(no_pool);
- }
- return data_extra_pool;
- }
- const rgw_pool& get_data_pool(const std::string& sc) const {
- const RGWZoneStorageClass *storage_class;
- static rgw_pool no_pool;
-
- if (!storage_classes.find(sc, &storage_class)) {
- return storage_classes.get_standard().data_pool.get_value_or(no_pool);
- }
-
- return storage_class->data_pool.get_value_or(no_pool);
- }
- const rgw_pool& get_standard_data_pool() const {
- return get_data_pool(RGW_STORAGE_CLASS_STANDARD);
- }
-
- const std::string& get_compression_type(const std::string& sc) const {
- const RGWZoneStorageClass *storage_class;
- static std::string no_compression;
-
- if (!storage_classes.find(sc, &storage_class)) {
- return no_compression;
- }
- return storage_class->compression_type.get_value_or(no_compression);
- }
-
- bool storage_class_exists(const std::string& sc) const {
- return storage_classes.exists(sc);
- }
-
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-
-};
-WRITE_CLASS_ENCODER(RGWZonePlacementInfo)
-
struct RGWZoneParams : RGWSystemMetaObj {
rgw_pool domain_root;
rgw_pool control_pool;
/*
* return data pool of the head object
*/
- bool get_head_data_pool(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_pool *pool) const {
+ bool get_head_data_pool(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_pool* pool) const {
const rgw_data_placement_target& explicit_placement = obj.bucket.explicit_placement;
if (!explicit_placement.data_pool.empty()) {
if (!obj.in_extra_data) {
};
WRITE_CLASS_ENCODER(RGWZoneParams)
-
-struct RGWZone {
- std::string id;
- std::string name;
- std::list<std::string> endpoints;
- bool log_meta;
- bool log_data;
- bool read_only;
- std::string tier_type;
-
- std::string redirect_zone;
-
-/**
- * Represents the number of shards for the bucket index object, a value of zero
- * indicates there is no sharding. By default (no sharding, the name of the object
- * is '.dir.{marker}', with sharding, the name is '.dir.{marker}.{sharding_id}',
- * sharding_id is zero-based value. It is not recommended to set a too large value
- * (e.g. thousand) as it increases the cost for bucket listing.
- */
- uint32_t bucket_index_max_shards;
-
- // pre-shard buckets on creation to enable some write-parallism by default,
- // delay the need to reshard as the bucket grows, and (in multisite) get some
- // bucket index sharding where dynamic resharding is not supported
- static constexpr uint32_t default_bucket_index_max_shards = 11;
-
- bool sync_from_all;
- std::set<std::string> sync_from; /* list of zones to sync from */
-
- rgw::zone_features::set supported_features;
-
- RGWZone()
- : log_meta(false), log_data(false), read_only(false),
- bucket_index_max_shards(default_bucket_index_max_shards),
- sync_from_all(true) {}
-
- void encode(bufferlist& bl) const {
- ENCODE_START(8, 1, bl);
- encode(name, bl);
- encode(endpoints, bl);
- encode(log_meta, bl);
- encode(log_data, bl);
- encode(bucket_index_max_shards, bl);
- encode(id, bl);
- encode(read_only, bl);
- encode(tier_type, bl);
- encode(sync_from_all, bl);
- encode(sync_from, bl);
- encode(redirect_zone, bl);
- encode(supported_features, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(8, bl);
- decode(name, bl);
- if (struct_v < 4) {
- id = name;
- }
- decode(endpoints, bl);
- if (struct_v >= 2) {
- decode(log_meta, bl);
- decode(log_data, bl);
- }
- if (struct_v >= 3) {
- decode(bucket_index_max_shards, bl);
- }
- if (struct_v >= 4) {
- decode(id, bl);
- decode(read_only, bl);
- }
- if (struct_v >= 5) {
- decode(tier_type, bl);
- }
- if (struct_v >= 6) {
- decode(sync_from_all, bl);
- decode(sync_from, bl);
- }
- if (struct_v >= 7) {
- decode(redirect_zone, bl);
- }
- if (struct_v >= 8) {
- decode(supported_features, bl);
- }
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
- static void generate_test_instances(std::list<RGWZone*>& o);
-
- bool is_read_only() const { return read_only; }
-
- bool syncs_from(const std::string& zone_name) const {
- return (sync_from_all || sync_from.find(zone_name) != sync_from.end());
- }
-
- bool supports(std::string_view feature) const {
- return supported_features.contains(feature);
- }
-};
-WRITE_CLASS_ENCODER(RGWZone)
-
-struct RGWDefaultZoneGroupInfo {
- std::string default_zonegroup;
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(default_zonegroup, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(default_zonegroup, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
- //todo: implement ceph-dencoder
-};
-WRITE_CLASS_ENCODER(RGWDefaultZoneGroupInfo)
-
-struct RGWTierACLMapping {
- ACLGranteeTypeEnum type{ACL_TYPE_CANON_USER};
- std::string source_id;
- std::string dest_id;
-
- RGWTierACLMapping() = default;
-
- RGWTierACLMapping(ACLGranteeTypeEnum t,
- const std::string& s,
- const std::string& d) : type(t),
- source_id(s),
- dest_id(d) {}
-
- void init(const JSONFormattable& config) {
- const std::string& t = config["type"];
-
- if (t == "email") {
- type = ACL_TYPE_EMAIL_USER;
- } else if (t == "uri") {
- type = ACL_TYPE_GROUP;
- } else {
- type = ACL_TYPE_CANON_USER;
- }
-
- source_id = config["source_id"];
- dest_id = config["dest_id"];
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode((uint32_t)type, bl);
- encode(source_id, bl);
- encode(dest_id, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- uint32_t it;
- decode(it, bl);
- type = (ACLGranteeTypeEnum)it;
- decode(source_id, bl);
- decode(dest_id, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWTierACLMapping)
-
-struct RGWZoneGroupPlacementTierS3 {
-#define DEFAULT_MULTIPART_SYNC_PART_SIZE (32 * 1024 * 1024)
- std::string endpoint;
- RGWAccessKey key;
- std::string region;
- HostStyle host_style{PathStyle};
- std::string target_storage_class;
-
- /* Should below be bucket/zone specific?? */
- std::string target_path;
- std::map<std::string, RGWTierACLMapping> acl_mappings;
-
- uint64_t multipart_sync_threshold{DEFAULT_MULTIPART_SYNC_PART_SIZE};
- uint64_t multipart_min_part_size{DEFAULT_MULTIPART_SYNC_PART_SIZE};
-
- int update_params(const JSONFormattable& config);
- int clear_params(const JSONFormattable& config);
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(endpoint, bl);
- encode(key, bl);
- encode(region, bl);
- encode((uint32_t)host_style, bl);
- encode(target_storage_class, bl);
- encode(target_path, bl);
- encode(acl_mappings, bl);
- encode(multipart_sync_threshold, bl);
- encode(multipart_min_part_size, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(endpoint, bl);
- decode(key, bl);
- decode(region, bl);
-
- uint32_t it;
- decode(it, bl);
- host_style = (HostStyle)it;
-
- decode(target_storage_class, bl);
- decode(target_path, bl);
- decode(acl_mappings, bl);
- decode(multipart_sync_threshold, bl);
- decode(multipart_min_part_size, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTierS3)
-
-struct RGWZoneGroupPlacementTier {
- std::string tier_type;
- std::string storage_class;
- bool retain_head_object = false;
-
- struct _tier {
- RGWZoneGroupPlacementTierS3 s3;
- } t;
-
- int update_params(const JSONFormattable& config);
- int clear_params(const JSONFormattable& config);
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(tier_type, bl);
- encode(storage_class, bl);
- encode(retain_head_object, bl);
- if (tier_type == "cloud-s3") {
- encode(t.s3, bl);
- }
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(tier_type, bl);
- decode(storage_class, bl);
- decode(retain_head_object, bl);
- if (tier_type == "cloud-s3") {
- decode(t.s3, bl);
- }
- DECODE_FINISH(bl);
- }
-
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTier)
-
-struct RGWZoneGroupPlacementTarget {
- std::string name;
- std::set<std::string> tags;
- std::set<std::string> storage_classes;
- std::map<std::string, RGWZoneGroupPlacementTier> tier_targets;
-
- bool user_permitted(const std::list<std::string>& user_tags) const {
- if (tags.empty()) {
- return true;
- }
- for (auto& rule : user_tags) {
- if (tags.find(rule) != tags.end()) {
- return true;
- }
- }
- return false;
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(3, 1, bl);
- encode(name, bl);
- encode(tags, bl);
- encode(storage_classes, bl);
- encode(tier_targets, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(3, bl);
- decode(name, bl);
- decode(tags, bl);
- if (struct_v >= 2) {
- decode(storage_classes, bl);
- }
- if (storage_classes.empty()) {
- storage_classes.insert(RGW_STORAGE_CLASS_STANDARD);
- }
- if (struct_v >= 3) {
- decode(tier_targets, bl);
- }
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTarget)
-
struct RGWZoneGroup : public RGWSystemMetaObj {
std::string api_name;
std::list<std::string> endpoints;
#include "common/debug.h"
-#include "rgw_basic_types.h"
-
-#define RGW_PERM_NONE 0x00
-#define RGW_PERM_READ 0x01
-#define RGW_PERM_WRITE 0x02
-#define RGW_PERM_READ_ACP 0x04
-#define RGW_PERM_WRITE_ACP 0x08
-#define RGW_PERM_READ_OBJS 0x10
-#define RGW_PERM_WRITE_OBJS 0x20
-#define RGW_PERM_FULL_CONTROL ( RGW_PERM_READ | RGW_PERM_WRITE | \
- RGW_PERM_READ_ACP | RGW_PERM_WRITE_ACP )
-#define RGW_PERM_ALL_S3 RGW_PERM_FULL_CONTROL
-#define RGW_PERM_INVALID 0xFF00
-
-static constexpr char RGW_REFERER_WILDCARD[] = "*";
-
-enum ACLGranteeTypeEnum {
-/* numbers are encoded, should not change */
- ACL_TYPE_CANON_USER = 0,
- ACL_TYPE_EMAIL_USER = 1,
- ACL_TYPE_GROUP = 2,
- ACL_TYPE_UNKNOWN = 3,
- ACL_TYPE_REFERER = 4,
-};
-
-enum ACLGroupTypeEnum {
-/* numbers are encoded should not change */
- ACL_GROUP_NONE = 0,
- ACL_GROUP_ALL_USERS = 1,
- ACL_GROUP_AUTHENTICATED_USERS = 2,
-};
-
-class ACLPermission
-{
-protected:
- int flags;
-public:
- ACLPermission() : flags(0) {}
- ~ACLPermission() {}
- uint32_t get_permissions() const { return flags; }
- void set_permissions(uint32_t perm) { flags = perm; }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(2, 2, bl);
- encode(flags, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
- decode(flags, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(std::list<ACLPermission*>& o);
-
- friend bool operator==(const ACLPermission& lhs, const ACLPermission& rhs);
- friend bool operator!=(const ACLPermission& lhs, const ACLPermission& rhs);
-};
-WRITE_CLASS_ENCODER(ACLPermission)
-
-class ACLGranteeType
-{
-protected:
- __u32 type;
-public:
- ACLGranteeType() : type(ACL_TYPE_UNKNOWN) {}
- virtual ~ACLGranteeType() {}
-// virtual const char *to_string() = 0;
- ACLGranteeTypeEnum get_type() const { return (ACLGranteeTypeEnum)type; }
- void set(ACLGranteeTypeEnum t) { type = t; }
-// virtual void set(const char *s) = 0;
- void encode(bufferlist& bl) const {
- ENCODE_START(2, 2, bl);
- encode(type, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
- decode(type, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(std::list<ACLGranteeType*>& o);
-
- friend bool operator==(const ACLGranteeType& lhs, const ACLGranteeType& rhs);
- friend bool operator!=(const ACLGranteeType& lhs, const ACLGranteeType& rhs);
-};
-WRITE_CLASS_ENCODER(ACLGranteeType)
-
-class ACLGrantee
-{
-public:
- ACLGrantee() {}
- ~ACLGrantee() {}
-};
-
+#include "rgw_basic_types.h" //includes rgw_acl_types.h
class ACLGrant
{
--- /dev/null
+// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
+#pragma once
+
+#include <string>
+#include <list>
+#include <fmt/format.h>
+
+#include "include/types.h"
+#include "common/Formatter.h"
+
+#define RGW_PERM_NONE 0x00
+#define RGW_PERM_READ 0x01
+#define RGW_PERM_WRITE 0x02
+#define RGW_PERM_READ_ACP 0x04
+#define RGW_PERM_WRITE_ACP 0x08
+#define RGW_PERM_READ_OBJS 0x10
+#define RGW_PERM_WRITE_OBJS 0x20
+#define RGW_PERM_FULL_CONTROL ( RGW_PERM_READ | RGW_PERM_WRITE | \
+ RGW_PERM_READ_ACP | RGW_PERM_WRITE_ACP )
+#define RGW_PERM_ALL_S3 RGW_PERM_FULL_CONTROL
+#define RGW_PERM_INVALID 0xFF00
+
+static constexpr char RGW_REFERER_WILDCARD[] = "*";
+
+struct RGWAccessKey {
+ std::string id; // AccessKey
+ std::string key; // SecretKey
+ std::string subuser;
+
+ RGWAccessKey() {}
+ RGWAccessKey(std::string _id, std::string _key)
+ : id(std::move(_id)), key(std::move(_key)) {}
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(2, 2, bl);
+ encode(id, bl);
+ encode(key, bl);
+ encode(subuser, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
+ decode(id, bl);
+ decode(key, bl);
+ decode(subuser, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void dump_plain(Formatter *f) const;
+ void dump(Formatter *f, const std::string& user, bool swift) const;
+ static void generate_test_instances(std::list<RGWAccessKey*>& o);
+
+ void decode_json(JSONObj *obj);
+ void decode_json(JSONObj *obj, bool swift);
+};
+WRITE_CLASS_ENCODER(RGWAccessKey)
+
+struct RGWSubUser {
+ std::string name;
+ uint32_t perm_mask;
+
+ RGWSubUser() : perm_mask(0) {}
+ void encode(bufferlist& bl) const {
+ ENCODE_START(2, 2, bl);
+ encode(name, bl);
+ encode(perm_mask, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
+ decode(name, bl);
+ decode(perm_mask, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void dump(Formatter *f, const std::string& user) const;
+ static void generate_test_instances(std::list<RGWSubUser*>& o);
+
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWSubUser)
+
+class RGWUserCaps
+{
+ std::map<std::string, uint32_t> caps;
+
+ int get_cap(const std::string& cap, std::string& type, uint32_t *perm);
+ int add_cap(const std::string& cap);
+ int remove_cap(const std::string& cap);
+public:
+ static int parse_cap_perm(const std::string& str, uint32_t *perm);
+ int add_from_string(const std::string& str);
+ int remove_from_string(const std::string& str);
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(caps, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(caps, bl);
+ DECODE_FINISH(bl);
+ }
+ int check_cap(const std::string& cap, uint32_t perm) const;
+ bool is_valid_cap_type(const std::string& tp);
+ void dump(Formatter *f) const;
+ void dump(Formatter *f, const char *name) const;
+
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWUserCaps)
+
+enum ACLGranteeTypeEnum {
+/* numbers are encoded, should not change */
+ ACL_TYPE_CANON_USER = 0,
+ ACL_TYPE_EMAIL_USER = 1,
+ ACL_TYPE_GROUP = 2,
+ ACL_TYPE_UNKNOWN = 3,
+ ACL_TYPE_REFERER = 4,
+};
+
+enum ACLGroupTypeEnum {
+/* numbers are encoded should not change */
+ ACL_GROUP_NONE = 0,
+ ACL_GROUP_ALL_USERS = 1,
+ ACL_GROUP_AUTHENTICATED_USERS = 2,
+};
+
+class ACLPermission
+{
+protected:
+ int flags;
+public:
+ ACLPermission() : flags(0) {}
+ ~ACLPermission() {}
+ uint32_t get_permissions() const { return flags; }
+ void set_permissions(uint32_t perm) { flags = perm; }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(2, 2, bl);
+ encode(flags, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
+ decode(flags, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ static void generate_test_instances(std::list<ACLPermission*>& o);
+
+ friend bool operator==(const ACLPermission& lhs, const ACLPermission& rhs);
+ friend bool operator!=(const ACLPermission& lhs, const ACLPermission& rhs);
+};
+WRITE_CLASS_ENCODER(ACLPermission)
+
+class ACLGranteeType
+{
+protected:
+ __u32 type;
+public:
+ ACLGranteeType() : type(ACL_TYPE_UNKNOWN) {}
+ virtual ~ACLGranteeType() {}
+// virtual const char *to_string() = 0;
+ ACLGranteeTypeEnum get_type() const { return (ACLGranteeTypeEnum)type; }
+ void set(ACLGranteeTypeEnum t) { type = t; }
+// virtual void set(const char *s) = 0;
+ void encode(bufferlist& bl) const {
+ ENCODE_START(2, 2, bl);
+ encode(type, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
+ decode(type, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ static void generate_test_instances(std::list<ACLGranteeType*>& o);
+
+ friend bool operator==(const ACLGranteeType& lhs, const ACLGranteeType& rhs);
+ friend bool operator!=(const ACLGranteeType& lhs, const ACLGranteeType& rhs);
+};
+WRITE_CLASS_ENCODER(ACLGranteeType)
+
+class ACLGrantee
+{
+public:
+ ACLGrantee() {}
+ ~ACLGrantee() {}
+};
// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
#ifndef CEPH_RGW_BASIC_TYPES_H
#define CEPH_RGW_BASIC_TYPES_H
#include <string>
+#include <fmt/format.h>
#include "include/types.h"
+#include "rgw_compression_types.h"
+#include "rgw_pool_types.h"
+#include "rgw_acl_types.h"
+#include "rgw_zone_types.h"
+#include "rgw_user_types.h"
+#include "rgw_bucket_types.h"
+#include "rgw_obj_types.h"
+#include "rgw_obj_manifest.h"
+
+#include "common/Formatter.h"
class JSONObj;
class cls_user_bucket;
-struct rgw_user {
- std::string tenant;
- std::string id;
- std::string ns;
-
- rgw_user() {}
- explicit rgw_user(const std::string& s) {
- from_str(s);
- }
- rgw_user(const std::string& tenant, const std::string& id, const std::string& ns="")
- : tenant(tenant),
- id(id),
- ns(ns) {
- }
- rgw_user(std::string&& tenant, std::string&& id, std::string&& ns="")
- : tenant(std::move(tenant)),
- id(std::move(id)),
- ns(std::move(ns)) {
- }
-
- void encode(ceph::buffer::list& bl) const {
- ENCODE_START(2, 1, bl);
- encode(tenant, bl);
- encode(id, bl);
- encode(ns, bl);
- ENCODE_FINISH(bl);
- }
- void decode(ceph::buffer::list::const_iterator& bl) {
- DECODE_START(2, bl);
- decode(tenant, bl);
- decode(id, bl);
- if (struct_v >= 2) {
- decode(ns, bl);
- }
- DECODE_FINISH(bl);
- }
-
- void to_str(std::string& str) const {
- if (!tenant.empty()) {
- if (!ns.empty()) {
- str = tenant + '$' + ns + '$' + id;
- } else {
- str = tenant + '$' + id;
- }
- } else if (!ns.empty()) {
- str = '$' + ns + '$' + id;
- } else {
- str = id;
- }
- }
-
- void clear() {
- tenant.clear();
- id.clear();
- ns.clear();
- }
-
- bool empty() const {
- return id.empty();
- }
-
- std::string to_str() const {
- std::string s;
- to_str(s);
- return s;
- }
-
- void from_str(const std::string& str) {
- size_t pos = str.find('$');
- if (pos != std::string::npos) {
- tenant = str.substr(0, pos);
- std::string_view sv = str;
- std::string_view ns_id = sv.substr(pos + 1);
- size_t ns_pos = ns_id.find('$');
- if (ns_pos != std::string::npos) {
- ns = std::string(ns_id.substr(0, ns_pos));
- id = std::string(ns_id.substr(ns_pos + 1));
- } else {
- ns.clear();
- id = std::string(ns_id);
- }
- } else {
- tenant.clear();
- ns.clear();
- id = str;
- }
- }
-
- rgw_user& operator=(const std::string& str) {
- from_str(str);
- return *this;
- }
-
- int compare(const rgw_user& u) const {
- int r = tenant.compare(u.tenant);
- if (r != 0)
- return r;
- r = ns.compare(u.ns);
- if (r != 0) {
- return r;
- }
- return id.compare(u.id);
- }
- int compare(const std::string& str) const {
- rgw_user u(str);
- return compare(u);
- }
-
- bool operator!=(const rgw_user& rhs) const {
- return (compare(rhs) != 0);
- }
- bool operator==(const rgw_user& rhs) const {
- return (compare(rhs) == 0);
- }
- bool operator<(const rgw_user& rhs) const {
- if (tenant < rhs.tenant) {
- return true;
- } else if (tenant > rhs.tenant) {
- return false;
- }
- if (ns < rhs.ns) {
- return true;
- } else if (ns > rhs.ns) {
- return false;
- }
- return (id < rhs.id);
- }
- void dump(ceph::Formatter *f) const;
- static void generate_test_instances(std::list<rgw_user*>& o);
+enum RGWIntentEvent {
+ DEL_OBJ = 0,
+ DEL_DIR = 1,
};
-WRITE_CLASS_ENCODER(rgw_user)
-struct rgw_pool {
- std::string name;
- std::string ns;
-
- rgw_pool() = default;
- rgw_pool(const rgw_pool& _p) : name(_p.name), ns(_p.ns) {}
- rgw_pool(rgw_pool&&) = default;
- rgw_pool(const std::string& _s) {
- from_str(_s);
- }
- rgw_pool(const std::string& _name, const std::string& _ns) : name(_name), ns(_ns) {}
-
- std::string to_str() const;
- void from_str(const std::string& s);
-
- void init(const std::string& _s) {
- from_str(_s);
- }
-
- bool empty() const {
- return name.empty();
- }
-
- int compare(const rgw_pool& p) const {
- int r = name.compare(p.name);
- if (r != 0) {
- return r;
- }
- return ns.compare(p.ns);
- }
-
- void encode(ceph::buffer::list& bl) const {
- ENCODE_START(10, 10, bl);
- encode(name, bl);
- encode(ns, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode_from_bucket(ceph::buffer::list::const_iterator& bl);
-
- void decode(ceph::buffer::list::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(10, 3, 3, bl);
-
- decode(name, bl);
-
- if (struct_v < 10) {
-
- /*
- * note that rgw_pool can be used where rgw_bucket was used before
- * therefore we inherit rgw_bucket's old versions. However, we only
- * need the first field from rgw_bucket. unless we add more fields
- * in which case we'll need to look at struct_v, and check the actual
- * version. Anything older than 10 needs to be treated as old rgw_bucket
- */
-
- } else {
- decode(ns, bl);
- }
-
- DECODE_FINISH(bl);
- }
-
- rgw_pool& operator=(const rgw_pool&) = default;
-
- bool operator==(const rgw_pool& p) const {
- return (compare(p) == 0);
- }
- bool operator!=(const rgw_pool& p) const {
- return !(*this == p);
- }
- bool operator<(const rgw_pool& p) const {
- int r = name.compare(p.name);
- if (r == 0) {
- return (ns.compare(p.ns) < 0);
- }
- return (r < 0);
- }
-};
-WRITE_CLASS_ENCODER(rgw_pool)
-
-inline std::ostream& operator<<(std::ostream& out, const rgw_pool& p) {
- out << p.to_str();
- return out;
-}
-
-struct rgw_data_placement_target {
- rgw_pool data_pool;
- rgw_pool data_extra_pool;
- rgw_pool index_pool;
-
- rgw_data_placement_target() = default;
- rgw_data_placement_target(const rgw_data_placement_target&) = default;
- rgw_data_placement_target(rgw_data_placement_target&&) = default;
-
- rgw_data_placement_target(const rgw_pool& data_pool,
- const rgw_pool& data_extra_pool,
- const rgw_pool& index_pool)
- : data_pool(data_pool),
- data_extra_pool(data_extra_pool),
- index_pool(index_pool) {
- }
-
- rgw_data_placement_target&
- operator=(const rgw_data_placement_target&) = default;
-
- const rgw_pool& get_data_extra_pool() const {
- if (data_extra_pool.empty()) {
- return data_pool;
- }
- return data_extra_pool;
- }
-
- int compare(const rgw_data_placement_target& t) {
- int c = data_pool.compare(t.data_pool);
- if (c != 0) {
- return c;
- }
- c = data_extra_pool.compare(t.data_extra_pool);
- if (c != 0) {
- return c;
- }
- return index_pool.compare(t.index_pool);
- };
-
- void dump(ceph::Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-
-struct rgw_bucket_key {
- std::string tenant;
- std::string name;
- std::string bucket_id;
-
- rgw_bucket_key(const std::string& _tenant,
- const std::string& _name,
- const std::string& _bucket_id) : tenant(_tenant),
- name(_name),
- bucket_id(_bucket_id) {}
- rgw_bucket_key(const std::string& _tenant,
- const std::string& _name) : tenant(_tenant),
- name(_name) {}
-};
-
-struct rgw_bucket {
- std::string tenant;
- std::string name;
- std::string marker;
- std::string bucket_id;
- rgw_data_placement_target explicit_placement;
-
- rgw_bucket() { }
- // cppcheck-suppress noExplicitConstructor
- explicit rgw_bucket(const rgw_user& u, const cls_user_bucket& b);
-
- rgw_bucket(const std::string& _tenant,
- const std::string& _name,
- const std::string& _bucket_id) : tenant(_tenant),
- name(_name),
- bucket_id(_bucket_id) {}
- rgw_bucket(const rgw_bucket_key& bk) : tenant(bk.tenant),
- name(bk.name),
- bucket_id(bk.bucket_id) {}
- rgw_bucket(const rgw_bucket&) = default;
- rgw_bucket(rgw_bucket&&) = default;
-
- bool match(const rgw_bucket& b) const {
- return (tenant == b.tenant &&
- name == b.name &&
- (bucket_id == b.bucket_id ||
- bucket_id.empty() ||
- b.bucket_id.empty()));
- }
-
- void convert(cls_user_bucket *b) const;
-
- void encode(ceph::buffer::list& bl) const {
- ENCODE_START(10, 10, bl);
- encode(name, bl);
- encode(marker, bl);
- encode(bucket_id, bl);
- encode(tenant, bl);
- bool encode_explicit = !explicit_placement.data_pool.empty();
- encode(encode_explicit, bl);
- if (encode_explicit) {
- encode(explicit_placement.data_pool, bl);
- encode(explicit_placement.data_extra_pool, bl);
- encode(explicit_placement.index_pool, bl);
- }
- ENCODE_FINISH(bl);
- }
- void decode(ceph::buffer::list::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(10, 3, 3, bl);
- decode(name, bl);
- if (struct_v < 10) {
- decode(explicit_placement.data_pool.name, bl);
- }
- if (struct_v >= 2) {
- decode(marker, bl);
- if (struct_v <= 3) {
- uint64_t id;
- decode(id, bl);
- char buf[16];
- snprintf(buf, sizeof(buf), "%" PRIu64, id);
- bucket_id = buf;
- } else {
- decode(bucket_id, bl);
- }
- }
- if (struct_v < 10) {
- if (struct_v >= 5) {
- decode(explicit_placement.index_pool.name, bl);
- } else {
- explicit_placement.index_pool = explicit_placement.data_pool;
- }
- if (struct_v >= 7) {
- decode(explicit_placement.data_extra_pool.name, bl);
- }
- }
- if (struct_v >= 8) {
- decode(tenant, bl);
- }
- if (struct_v >= 10) {
- bool decode_explicit = !explicit_placement.data_pool.empty();
- decode(decode_explicit, bl);
- if (decode_explicit) {
- decode(explicit_placement.data_pool, bl);
- decode(explicit_placement.data_extra_pool, bl);
- decode(explicit_placement.index_pool, bl);
- }
- }
- DECODE_FINISH(bl);
- }
-
- void update_bucket_id(const std::string& new_bucket_id) {
- bucket_id = new_bucket_id;
- }
-
- // format a key for the bucket/instance. pass delim=0 to skip a field
- std::string get_key(char tenant_delim = '/',
- char id_delim = ':',
- size_t reserve = 0) const;
-
- const rgw_pool& get_data_extra_pool() const {
- return explicit_placement.get_data_extra_pool();
- }
-
- void dump(ceph::Formatter *f) const;
- void decode_json(JSONObj *obj);
- static void generate_test_instances(std::list<rgw_bucket*>& o);
-
- rgw_bucket& operator=(const rgw_bucket&) = default;
-
- bool operator<(const rgw_bucket& b) const {
- if (tenant < b.tenant) {
- return true;
- } else if (tenant > b.tenant) {
- return false;
- }
-
- if (name < b.name) {
- return true;
- } else if (name > b.name) {
- return false;
- }
-
- return (bucket_id < b.bucket_id);
- }
-
- bool operator==(const rgw_bucket& b) const {
- return (tenant == b.tenant) && (name == b.name) && \
- (bucket_id == b.bucket_id);
- }
- bool operator!=(const rgw_bucket& b) const {
- return (tenant != b.tenant) || (name != b.name) ||
- (bucket_id != b.bucket_id);
- }
-};
-WRITE_CLASS_ENCODER(rgw_bucket)
-
-inline std::ostream& operator<<(std::ostream& out, const rgw_bucket &b) {
- out << b.tenant << ":" << b.name << "[" << b.bucket_id << "])";
- return out;
-}
-
-struct rgw_bucket_shard {
- rgw_bucket bucket;
- int shard_id;
-
- rgw_bucket_shard() : shard_id(-1) {}
- rgw_bucket_shard(const rgw_bucket& _b, int _sid) : bucket(_b), shard_id(_sid) {}
-
- std::string get_key(char tenant_delim = '/', char id_delim = ':',
- char shard_delim = ':',
- size_t reserve = 0) const;
-
- bool operator<(const rgw_bucket_shard& b) const {
- if (bucket < b.bucket) {
- return true;
- }
- if (b.bucket < bucket) {
- return false;
- }
- return shard_id < b.shard_id;
- }
-
- bool operator==(const rgw_bucket_shard& b) const {
- return (bucket == b.bucket &&
- shard_id == b.shard_id);
- }
-};
-
-void encode(const rgw_bucket_shard& b, bufferlist& bl, uint64_t f=0);
-void decode(rgw_bucket_shard& b, bufferlist::const_iterator& bl);
-
-inline std::ostream& operator<<(std::ostream& out, const rgw_bucket_shard& bs) {
- if (bs.shard_id <= 0) {
- return out << bs.bucket;
- }
-
- return out << bs.bucket << ":" << bs.shard_id;
-}
+/** Store error returns for output at a different point in the program */
+struct rgw_err {
+ rgw_err();
+ void clear();
+ bool is_clear() const;
+ bool is_err() const;
+ friend std::ostream& operator<<(std::ostream& oss, const rgw_err &err);
+ int http_ret;
+ int ret;
+ std::string err_code;
+ std::string message;
+}; /* rgw_err */
struct rgw_zone_id {
std::string id;
return out << s;
}
+struct RGWUploadPartInfo {
+ uint32_t num;
+ uint64_t size;
+ uint64_t accounted_size{0};
+ std::string etag;
+ ceph::real_time modified;
+ RGWObjManifest manifest;
+ RGWCompressionInfo cs_info;
+
+ RGWUploadPartInfo() : num(0), size(0) {}
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(4, 2, bl);
+ encode(num, bl);
+ encode(size, bl);
+ encode(etag, bl);
+ encode(modified, bl);
+ encode(manifest, bl);
+ encode(cs_info, bl);
+ encode(accounted_size, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
+ decode(num, bl);
+ decode(size, bl);
+ decode(etag, bl);
+ decode(modified, bl);
+ if (struct_v >= 3)
+ decode(manifest, bl);
+ if (struct_v >= 4) {
+ decode(cs_info, bl);
+ decode(accounted_size, bl);
+ } else {
+ accounted_size = size;
+ }
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ static void generate_test_instances(std::list<RGWUploadPartInfo*>& o);
+};
+WRITE_CLASS_ENCODER(RGWUploadPartInfo)
-#endif
+#endif /* CEPH_RGW_BASIC_TYPES_H */
*
*/
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
#pragma once
#include <optional>
--- /dev/null
+// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * include files which can only be compiled in radosgw or OSD
+ * contexts (e.g., rgw_sal.h, rgw_common.h) */
+
+#pragma once
+
+#include <fmt/format.h>
+
+#include "rgw_pool_types.h"
+#include "rgw_user_types.h"
+#include "rgw_placement_types.h"
+
+#include "common/dout.h"
+#include "common/Formatter.h"
+
+struct cls_user_bucket;
+
+struct rgw_bucket_key {
+ std::string tenant;
+ std::string name;
+ std::string bucket_id;
+
+ rgw_bucket_key(const std::string& _tenant,
+ const std::string& _name,
+ const std::string& _bucket_id) : tenant(_tenant),
+ name(_name),
+ bucket_id(_bucket_id) {}
+ rgw_bucket_key(const std::string& _tenant,
+ const std::string& _name) : tenant(_tenant),
+ name(_name) {}
+};
+
+struct rgw_bucket {
+ std::string tenant;
+ std::string name;
+ std::string marker;
+ std::string bucket_id;
+ rgw_data_placement_target explicit_placement;
+
+ rgw_bucket() { }
+ // cppcheck-suppress noExplicitConstructor
+ explicit rgw_bucket(const rgw_user& u, const cls_user_bucket& b);
+
+ rgw_bucket(const std::string& _tenant,
+ const std::string& _name,
+ const std::string& _bucket_id) : tenant(_tenant),
+ name(_name),
+ bucket_id(_bucket_id) {}
+ rgw_bucket(const rgw_bucket_key& bk) : tenant(bk.tenant),
+ name(bk.name),
+ bucket_id(bk.bucket_id) {}
+ rgw_bucket(const rgw_bucket&) = default;
+ rgw_bucket(rgw_bucket&&) = default;
+
+ bool match(const rgw_bucket& b) const {
+ return (tenant == b.tenant &&
+ name == b.name &&
+ (bucket_id == b.bucket_id ||
+ bucket_id.empty() ||
+ b.bucket_id.empty()));
+ }
+
+ void convert(cls_user_bucket *b) const;
+
+ void encode(ceph::buffer::list& bl) const {
+ ENCODE_START(10, 10, bl);
+ encode(name, bl);
+ encode(marker, bl);
+ encode(bucket_id, bl);
+ encode(tenant, bl);
+ bool encode_explicit = !explicit_placement.data_pool.empty();
+ encode(encode_explicit, bl);
+ if (encode_explicit) {
+ encode(explicit_placement.data_pool, bl);
+ encode(explicit_placement.data_extra_pool, bl);
+ encode(explicit_placement.index_pool, bl);
+ }
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(ceph::buffer::list::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(10, 3, 3, bl);
+ decode(name, bl);
+ if (struct_v < 10) {
+ decode(explicit_placement.data_pool.name, bl);
+ }
+ if (struct_v >= 2) {
+ decode(marker, bl);
+ if (struct_v <= 3) {
+ uint64_t id;
+ decode(id, bl);
+ char buf[16];
+ snprintf(buf, sizeof(buf), "%" PRIu64, id);
+ bucket_id = buf;
+ } else {
+ decode(bucket_id, bl);
+ }
+ }
+ if (struct_v < 10) {
+ if (struct_v >= 5) {
+ decode(explicit_placement.index_pool.name, bl);
+ } else {
+ explicit_placement.index_pool = explicit_placement.data_pool;
+ }
+ if (struct_v >= 7) {
+ decode(explicit_placement.data_extra_pool.name, bl);
+ }
+ }
+ if (struct_v >= 8) {
+ decode(tenant, bl);
+ }
+ if (struct_v >= 10) {
+ bool decode_explicit = !explicit_placement.data_pool.empty();
+ decode(decode_explicit, bl);
+ if (decode_explicit) {
+ decode(explicit_placement.data_pool, bl);
+ decode(explicit_placement.data_extra_pool, bl);
+ decode(explicit_placement.index_pool, bl);
+ }
+ }
+ DECODE_FINISH(bl);
+ }
+
+ void update_bucket_id(const std::string& new_bucket_id) {
+ bucket_id = new_bucket_id;
+ }
+
+ // format a key for the bucket/instance. pass delim=0 to skip a field
+ std::string get_key(char tenant_delim = '/',
+ char id_delim = ':',
+ size_t reserve = 0) const;
+
+ const rgw_pool& get_data_extra_pool() const {
+ return explicit_placement.get_data_extra_pool();
+ }
+
+ void dump(ceph::Formatter *f) const;
+ void decode_json(JSONObj *obj);
+ static void generate_test_instances(std::list<rgw_bucket*>& o);
+
+ rgw_bucket& operator=(const rgw_bucket&) = default;
+
+ bool operator<(const rgw_bucket& b) const {
+ if (tenant < b.tenant) {
+ return true;
+ } else if (tenant > b.tenant) {
+ return false;
+ }
+
+ if (name < b.name) {
+ return true;
+ } else if (name > b.name) {
+ return false;
+ }
+
+ return (bucket_id < b.bucket_id);
+ }
+
+ bool operator==(const rgw_bucket& b) const {
+ return (tenant == b.tenant) && (name == b.name) && \
+ (bucket_id == b.bucket_id);
+ }
+ bool operator!=(const rgw_bucket& b) const {
+ return (tenant != b.tenant) || (name != b.name) ||
+ (bucket_id != b.bucket_id);
+ }
+};
+WRITE_CLASS_ENCODER(rgw_bucket)
+
+inline std::ostream& operator<<(std::ostream& out, const rgw_bucket &b) {
+ out << b.tenant << ":" << b.name << "[" << b.bucket_id << "])";
+ return out;
+}
+
+struct rgw_bucket_placement {
+ rgw_placement_rule placement_rule;
+ rgw_bucket bucket;
+
+ void dump(Formatter *f) const;
+}; /* rgw_bucket_placement */
+
+struct rgw_bucket_shard {
+ rgw_bucket bucket;
+ int shard_id;
+
+ rgw_bucket_shard() : shard_id(-1) {}
+ rgw_bucket_shard(const rgw_bucket& _b, int _sid) : bucket(_b), shard_id(_sid) {}
+
+ std::string get_key(char tenant_delim = '/', char id_delim = ':',
+ char shard_delim = ':',
+ size_t reserve = 0) const;
+
+ bool operator<(const rgw_bucket_shard& b) const {
+ if (bucket < b.bucket) {
+ return true;
+ }
+ if (b.bucket < bucket) {
+ return false;
+ }
+ return shard_id < b.shard_id;
+ }
+
+ bool operator==(const rgw_bucket_shard& b) const {
+ return (bucket == b.bucket &&
+ shard_id == b.shard_id);
+ }
+}; /* rgw_bucket_shard */
+
+void encode(const rgw_bucket_shard& b, bufferlist& bl, uint64_t f=0);
+void decode(rgw_bucket_shard& b, bufferlist::const_iterator& bl);
+
+inline std::ostream& operator<<(std::ostream& out, const rgw_bucket_shard& bs) {
+ if (bs.shard_id <= 0) {
+ return out << bs.bucket;
+ }
+
+ return out << bs.bucket << ":" << bs.shard_id;
+}
#include "rgw_cors.h"
#include "rgw_basic_types.h"
#include "rgw_iam_policy.h"
-#include "rgw_quota.h"
+#include "rgw_quota_types.h"
#include "rgw_string.h"
#include "common/async/yield_context.h"
#include "rgw_website.h"
typedef void *RGWAccessHandle;
-enum RGWIntentEvent {
- DEL_OBJ = 0,
- DEL_DIR = 1,
-};
-
-enum HostStyle {
- PathStyle = 0,
- VirtualStyle = 1,
-};
-
-/** Store error returns for output at a different point in the program */
-struct rgw_err {
- rgw_err();
- void clear();
- bool is_clear() const;
- bool is_err() const;
- friend std::ostream& operator<<(std::ostream& oss, const rgw_err &err);
-
- int http_ret;
- int ret;
- std::string err_code;
- std::string message;
-};
-
-
/* Helper class used for RGWHTTPArgs parsing */
class NameVal
{
class RGWAccessControlPolicy;
class JSONObj;
-struct RGWAccessKey {
- std::string id; // AccessKey
- std::string key; // SecretKey
- std::string subuser;
-
- RGWAccessKey() {}
- RGWAccessKey(std::string _id, std::string _key)
- : id(std::move(_id)), key(std::move(_key)) {}
-
- void encode(bufferlist& bl) const {
- ENCODE_START(2, 2, bl);
- encode(id, bl);
- encode(key, bl);
- encode(subuser, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
- decode(id, bl);
- decode(key, bl);
- decode(subuser, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void dump_plain(Formatter *f) const;
- void dump(Formatter *f, const std::string& user, bool swift) const;
- static void generate_test_instances(std::list<RGWAccessKey*>& o);
-
- void decode_json(JSONObj *obj);
- void decode_json(JSONObj *obj, bool swift);
-};
-WRITE_CLASS_ENCODER(RGWAccessKey)
-
-struct RGWSubUser {
- std::string name;
- uint32_t perm_mask;
-
- RGWSubUser() : perm_mask(0) {}
- void encode(bufferlist& bl) const {
- ENCODE_START(2, 2, bl);
- encode(name, bl);
- encode(perm_mask, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN_32(2, 2, 2, bl);
- decode(name, bl);
- decode(perm_mask, bl);
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void dump(Formatter *f, const std::string& user) const;
- static void generate_test_instances(std::list<RGWSubUser*>& o);
-
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWSubUser)
-
-class RGWUserCaps
-{
- std::map<std::string, uint32_t> caps;
-
- int get_cap(const std::string& cap, std::string& type, uint32_t *perm);
- int add_cap(const std::string& cap);
- int remove_cap(const std::string& cap);
-public:
- static int parse_cap_perm(const std::string& str, uint32_t *perm);
- int add_from_string(const std::string& str);
- int remove_from_string(const std::string& str);
-
- void encode(bufferlist& bl) const {
- ENCODE_START(1, 1, bl);
- encode(caps, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(1, bl);
- decode(caps, bl);
- DECODE_FINISH(bl);
- }
- int check_cap(const std::string& cap, uint32_t perm) const;
- bool is_valid_cap_type(const std::string& tp);
- void dump(Formatter *f) const;
- void dump(Formatter *f, const char *name) const;
-
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(RGWUserCaps)
-
void encode_json(const char *name, const obj_version& v, Formatter *f);
void encode_json(const char *name, const RGWUserCaps& val, Formatter *f);
void decode_json_obj(obj_version& v, JSONObj *obj);
-
-
enum RGWIdentityType
{
TYPE_NONE=0,
TYPE_WEB=5,
};
-static std::string RGW_STORAGE_CLASS_STANDARD = "STANDARD";
-
-struct rgw_placement_rule {
- std::string name;
- std::string storage_class;
-
- rgw_placement_rule() {}
- rgw_placement_rule(const std::string& _n, const std::string& _sc) : name(_n), storage_class(_sc) {}
- rgw_placement_rule(const rgw_placement_rule& _r, const std::string& _sc) : name(_r.name) {
- if (!_sc.empty()) {
- storage_class = _sc;
- } else {
- storage_class = _r.storage_class;
- }
- }
-
- bool empty() const {
- return name.empty() && storage_class.empty();
- }
-
- void inherit_from(const rgw_placement_rule& r) {
- if (name.empty()) {
- name = r.name;
- }
- if (storage_class.empty()) {
- storage_class = r.storage_class;
- }
- }
-
- void clear() {
- name.clear();
- storage_class.clear();
- }
-
- void init(const std::string& n, const std::string& c) {
- name = n;
- storage_class = c;
- }
-
- static const std::string& get_canonical_storage_class(const std::string& storage_class) {
- if (storage_class.empty()) {
- return RGW_STORAGE_CLASS_STANDARD;
- }
- return storage_class;
- }
-
- const std::string& get_storage_class() const {
- return get_canonical_storage_class(storage_class);
- }
-
- int compare(const rgw_placement_rule& r) const {
- int c = name.compare(r.name);
- if (c != 0) {
- return c;
- }
- return get_storage_class().compare(r.get_storage_class());
- }
-
- bool operator==(const rgw_placement_rule& r) const {
- return (name == r.name &&
- get_storage_class() == r.get_storage_class());
- }
-
- bool operator!=(const rgw_placement_rule& r) const {
- return !(*this == r);
- }
-
- void encode(bufferlist& bl) const {
- /* no ENCODE_START/END due to backward compatibility */
- std::string s = to_str();
- ceph::encode(s, bl);
- }
-
- void decode(bufferlist::const_iterator& bl) {
- std::string s;
- ceph::decode(s, bl);
- from_str(s);
- }
-
- std::string to_str() const {
- if (standard_storage_class()) {
- return name;
- }
- return to_str_explicit();
- }
-
- std::string to_str_explicit() const {
- return name + "/" + storage_class;
- }
-
- void from_str(const std::string& s) {
- size_t pos = s.find("/");
- if (pos == std::string::npos) {
- name = s;
- storage_class.clear();
- return;
- }
- name = s.substr(0, pos);
- storage_class = s.substr(pos + 1);
- }
-
- bool standard_storage_class() const {
- return storage_class.empty() || storage_class == RGW_STORAGE_CLASS_STANDARD;
- }
-};
-WRITE_CLASS_ENCODER(rgw_placement_rule)
-
void encode_json(const char *name, const rgw_placement_rule& val, ceph::Formatter *f);
void decode_json_obj(rgw_placement_rule& v, JSONObj *obj);
};
WRITE_CLASS_ENCODER(RGWUserInfo)
-struct rgw_raw_obj {
- rgw_pool pool;
- std::string oid;
- std::string loc;
-
- rgw_raw_obj() {}
- rgw_raw_obj(const rgw_pool& _pool, const std::string& _oid) {
- init(_pool, _oid);
- }
- rgw_raw_obj(const rgw_pool& _pool, const std::string& _oid, const std::string& _loc) : loc(_loc) {
- init(_pool, _oid);
- }
-
- void init(const rgw_pool& _pool, const std::string& _oid) {
- pool = _pool;
- oid = _oid;
- }
-
- bool empty() const {
- return oid.empty();
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(6, 6, bl);
- encode(pool, bl);
- encode(oid, bl);
- encode(loc, bl);
- ENCODE_FINISH(bl);
- }
-
- void decode_from_rgw_obj(bufferlist::const_iterator& bl);
-
- void decode(bufferlist::const_iterator& bl) {
- unsigned ofs = bl.get_off();
- DECODE_START(6, bl);
- if (struct_v < 6) {
- /*
- * this object was encoded as rgw_obj, prior to rgw_raw_obj been split out of it,
- * let's decode it as rgw_obj and convert it
- */
- bl.seek(ofs);
- decode_from_rgw_obj(bl);
- return;
- }
- decode(pool, bl);
- decode(oid, bl);
- decode(loc, bl);
- DECODE_FINISH(bl);
- }
-
- bool operator<(const rgw_raw_obj& o) const {
- int r = pool.compare(o.pool);
- if (r == 0) {
- r = oid.compare(o.oid);
- if (r == 0) {
- r = loc.compare(o.loc);
- }
- }
- return (r < 0);
- }
-
- bool operator==(const rgw_raw_obj& o) const {
- return (pool == o.pool && oid == o.oid && loc == o.loc);
- }
-
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-};
-WRITE_CLASS_ENCODER(rgw_raw_obj)
-
-inline std::ostream& operator<<(std::ostream& out, const rgw_raw_obj& o) {
- out << o.pool << ":" << o.oid;
- return out;
-}
-
-struct rgw_bucket_placement {
- rgw_placement_rule placement_rule;
- rgw_bucket bucket;
-
- void dump(Formatter *f) const;
-};
-
/// `RGWObjVersionTracker`
/// ======================
///
void init_meta_info(const DoutPrefixProvider *dpp, bool *found_bad_meta);
};
-typedef cls_rgw_obj_key rgw_obj_index_key;
-
-struct rgw_obj_key {
- std::string name;
- std::string instance;
- std::string ns;
-
- rgw_obj_key() {}
- // cppcheck-suppress noExplicitConstructor
- rgw_obj_key(const std::string& n) : name(n) {}
- rgw_obj_key(const std::string& n, const std::string& i) : name(n), instance(i) {}
- rgw_obj_key(const std::string& n, const std::string& i, const std::string& _ns) : name(n), instance(i), ns(_ns) {}
-
- rgw_obj_key(const rgw_obj_index_key& k) {
- parse_index_key(k.name, &name, &ns);
- instance = k.instance;
- }
-
- static void parse_index_key(const std::string& key, std::string *name, std::string *ns) {
- if (key[0] != '_') {
- *name = key;
- ns->clear();
- return;
- }
- if (key[1] == '_') {
- *name = key.substr(1);
- ns->clear();
- return;
- }
- ssize_t pos = key.find('_', 1);
- if (pos < 0) {
- /* shouldn't happen, just use key */
- *name = key;
- ns->clear();
- return;
- }
-
- *name = key.substr(pos + 1);
- *ns = key.substr(1, pos -1);
- }
-
- void set(const std::string& n) {
- name = n;
- instance.clear();
- ns.clear();
- }
-
- void set(const std::string& n, const std::string& i) {
- name = n;
- instance = i;
- ns.clear();
- }
-
- void set(const std::string& n, const std::string& i, const std::string& _ns) {
- name = n;
- instance = i;
- ns = _ns;
- }
-
- bool set(const rgw_obj_index_key& index_key) {
- if (!parse_raw_oid(index_key.name, this)) {
- return false;
- }
- instance = index_key.instance;
- return true;
- }
-
- void set_instance(const std::string& i) {
- instance = i;
- }
-
- const std::string& get_instance() const {
- return instance;
- }
-
- void set_ns(const std::string& _ns) {
- ns = _ns;
- }
-
- const std::string& get_ns() const {
- return ns;
- }
-
- std::string get_index_key_name() const {
- if (ns.empty()) {
- if (name.size() < 1 || name[0] != '_') {
- return name;
- }
- return std::string("_") + name;
- };
-
- char buf[ns.size() + 16];
- snprintf(buf, sizeof(buf), "_%s_", ns.c_str());
- return std::string(buf) + name;
- };
-
- void get_index_key(rgw_obj_index_key *key) const {
- key->name = get_index_key_name();
- key->instance = instance;
- }
-
- std::string get_loc() const {
- /*
- * For backward compatibility. Older versions used to have object locator on all objects,
- * however, the name was the effective object locator. This had the same effect as not
- * having object locator at all for most objects but the ones that started with underscore as
- * these were escaped.
- */
- if (name[0] == '_' && ns.empty()) {
- return name;
- }
-
- return {};
- }
-
- bool empty() const {
- return name.empty();
- }
-
- bool have_null_instance() const {
- return instance == "null";
- }
-
- bool have_instance() const {
- return !instance.empty();
- }
-
- bool need_to_encode_instance() const {
- return have_instance() && !have_null_instance();
- }
-
- std::string get_oid() const {
- if (ns.empty() && !need_to_encode_instance()) {
- if (name.size() < 1 || name[0] != '_') {
- return name;
- }
- return std::string("_") + name;
- }
-
- std::string oid = "_";
- oid.append(ns);
- if (need_to_encode_instance()) {
- oid.append(std::string(":") + instance);
- }
- oid.append("_");
- oid.append(name);
- return oid;
- }
-
- bool operator==(const rgw_obj_key& k) const {
- return (name.compare(k.name) == 0) &&
- (instance.compare(k.instance) == 0);
- }
-
- bool operator<(const rgw_obj_key& k) const {
- int r = name.compare(k.name);
- if (r == 0) {
- r = instance.compare(k.instance);
- }
- return (r < 0);
- }
-
- bool operator<=(const rgw_obj_key& k) const {
- return !(k < *this);
- }
-
- static void parse_ns_field(std::string& ns, std::string& instance) {
- int pos = ns.find(':');
- if (pos >= 0) {
- instance = ns.substr(pos + 1);
- ns = ns.substr(0, pos);
- } else {
- instance.clear();
- }
- }
-
- // takes an oid and parses out the namespace (ns), name, and
- // instance
- static bool parse_raw_oid(const std::string& oid, rgw_obj_key *key) {
- key->instance.clear();
- key->ns.clear();
- if (oid[0] != '_') {
- key->name = oid;
- return true;
- }
-
- if (oid.size() >= 2 && oid[1] == '_') {
- key->name = oid.substr(1);
- return true;
- }
-
- if (oid.size() < 3) // for namespace, min size would be 3: _x_
- return false;
-
- size_t pos = oid.find('_', 2); // oid must match ^_[^_].+$
- if (pos == std::string::npos)
- return false;
-
- key->ns = oid.substr(1, pos - 1);
- parse_ns_field(key->ns, key->instance);
-
- key->name = oid.substr(pos + 1);
- return true;
- }
-
- /**
- * Translate a namespace-mangled object name to the user-facing name
- * existing in the given namespace.
- *
- * If the object is part of the given namespace, it returns true
- * and cuts down the name to the unmangled version. If it is not
- * part of the given namespace, it returns false.
- */
- static bool oid_to_key_in_ns(const std::string& oid, rgw_obj_key *key, const std::string& ns) {
- bool ret = parse_raw_oid(oid, key);
- if (!ret) {
- return ret;
- }
-
- return (ns == key->ns);
- }
-
- /**
- * Given a mangled object name and an empty namespace std::string, this
- * function extracts the namespace into the std::string and sets the object
- * name to be the unmangled version.
- *
- * It returns true after successfully doing so, or
- * false if it fails.
- */
- static bool strip_namespace_from_name(std::string& name, std::string& ns, std::string& instance) {
- ns.clear();
- instance.clear();
- if (name[0] != '_') {
- return true;
- }
-
- size_t pos = name.find('_', 1);
- if (pos == std::string::npos) {
- return false;
- }
-
- if (name[1] == '_') {
- name = name.substr(1);
- return true;
- }
-
- size_t period_pos = name.find('.');
- if (period_pos < pos) {
- return false;
- }
-
- ns = name.substr(1, pos-1);
- name = name.substr(pos+1, std::string::npos);
-
- parse_ns_field(ns, instance);
- return true;
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(2, 1, bl);
- encode(name, bl);
- encode(instance, bl);
- encode(ns, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START(2, bl);
- decode(name, bl);
- decode(instance, bl);
- if (struct_v >= 2) {
- decode(ns, bl);
- }
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- void decode_json(JSONObj *obj);
-
- std::string to_str() const {
- if (instance.empty()) {
- return name;
- }
- char buf[name.size() + instance.size() + 16];
- snprintf(buf, sizeof(buf), "%s[%s]", name.c_str(), instance.c_str());
- return buf;
- }
-};
-WRITE_CLASS_ENCODER(rgw_obj_key)
-
-inline std::ostream& operator<<(std::ostream& out, const rgw_obj_key &o) {
- return out << o.to_str();
-}
-
struct req_init_state {
/* Keeps [[tenant]:]bucket until we parse the token. */
std::string url_bucket;
};
WRITE_CLASS_ENCODER(RGWBucketEnt)
-struct rgw_obj {
- rgw_bucket bucket;
- rgw_obj_key key;
-
- bool in_extra_data{false}; /* in-memory only member, does not serialize */
-
- // Represents the hash index source for this object once it is set (non-empty)
- std::string index_hash_source;
-
- rgw_obj() {}
- rgw_obj(const rgw_bucket& b, const std::string& name) : bucket(b), key(name) {}
- rgw_obj(const rgw_bucket& b, const rgw_obj_key& k) : bucket(b), key(k) {}
- rgw_obj(const rgw_bucket& b, const rgw_obj_index_key& k) : bucket(b), key(k) {}
-
- void init(const rgw_bucket& b, const rgw_obj_key& k) {
- bucket = b;
- key = k;
- }
- void init(const rgw_bucket& b, const std::string& name) {
- bucket = b;
- key.set(name);
- }
- void init(const rgw_bucket& b, const std::string& name, const std::string& i, const std::string& n) {
- bucket = b;
- key.set(name, i, n);
- }
- void init_ns(const rgw_bucket& b, const std::string& name, const std::string& n) {
- bucket = b;
- key.name = name;
- key.instance.clear();
- key.ns = n;
- }
-
- bool empty() const {
- return key.empty();
- }
-
- void set_key(const rgw_obj_key& k) {
- key = k;
- }
-
- std::string get_oid() const {
- return key.get_oid();
- }
-
- const std::string& get_hash_object() const {
- return index_hash_source.empty() ? key.name : index_hash_source;
- }
-
- void set_in_extra_data(bool val) {
- in_extra_data = val;
- }
-
- bool is_in_extra_data() const {
- return in_extra_data;
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(6, 6, bl);
- encode(bucket, bl);
- encode(key.ns, bl);
- encode(key.name, bl);
- encode(key.instance, bl);
-// encode(placement_id, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl);
- if (struct_v < 6) {
- std::string s;
- decode(bucket.name, bl); /* bucket.name */
- decode(s, bl); /* loc */
- decode(key.ns, bl);
- decode(key.name, bl);
- if (struct_v >= 2)
- decode(bucket, bl);
- if (struct_v >= 4)
- decode(key.instance, bl);
- if (key.ns.empty() && key.instance.empty()) {
- if (key.name[0] == '_') {
- key.name = key.name.substr(1);
- }
- } else {
- if (struct_v >= 5) {
- decode(key.name, bl);
- } else {
- ssize_t pos = key.name.find('_', 1);
- if (pos < 0) {
- throw buffer::malformed_input();
- }
- key.name = key.name.substr(pos + 1);
- }
- }
- } else {
- decode(bucket, bl);
- decode(key.ns, bl);
- decode(key.name, bl);
- decode(key.instance, bl);
-// decode(placement_id, bl);
- }
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(std::list<rgw_obj*>& o);
-
- bool operator==(const rgw_obj& o) const {
- return (key == o.key) &&
- (bucket == o.bucket);
- }
- bool operator<(const rgw_obj& o) const {
- int r = key.name.compare(o.key.name);
- if (r == 0) {
- r = bucket.bucket_id.compare(o.bucket.bucket_id); /* not comparing bucket.name, if bucket_id is equal so will be bucket.name */
- if (r == 0) {
- r = key.ns.compare(o.key.ns);
- if (r == 0) {
- r = key.instance.compare(o.key.instance);
- }
- }
- }
-
- return (r < 0);
- }
-
- const rgw_pool& get_explicit_data_pool() {
- if (!in_extra_data || bucket.explicit_placement.data_extra_pool.empty()) {
- return bucket.explicit_placement.data_pool;
- }
- return bucket.explicit_placement.data_extra_pool;
- }
-};
-WRITE_CLASS_ENCODER(rgw_obj)
-
struct rgw_cache_entry_info {
std::string cache_locator;
uint64_t gen;
#pragma once
-#include "rgw_common.h"
-
struct compression_block {
uint64_t old_ofs;
uint64_t new_ofs;
#include <map>
#include "rgw_xml.h"
+#include "rgw_obj_types.h"
#include "rgw_obj_manifest.h"
#include "rgw_compression_types.h"
#include "common/dout.h"
#define MULTIPART_UPLOAD_ID_PREFIX_LEGACY "2/"
#define MULTIPART_UPLOAD_ID_PREFIX "2~" // must contain a unique char that may not come up in gen_rand_alpha()
-class RGWMPObj;
-
-struct RGWUploadPartInfo {
- uint32_t num;
- uint64_t size;
- uint64_t accounted_size{0};
- std::string etag;
- ceph::real_time modified;
- RGWObjManifest manifest;
- RGWCompressionInfo cs_info;
-
- RGWUploadPartInfo() : num(0), size(0) {}
-
- void encode(bufferlist& bl) const {
- ENCODE_START(4, 2, bl);
- encode(num, bl);
- encode(size, bl);
- encode(etag, bl);
- encode(modified, bl);
- encode(manifest, bl);
- encode(cs_info, bl);
- encode(accounted_size, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
- decode(num, bl);
- decode(size, bl);
- decode(etag, bl);
- decode(modified, bl);
- if (struct_v >= 3)
- decode(manifest, bl);
- if (struct_v >= 4) {
- decode(cs_info, bl);
- decode(accounted_size, bl);
- } else {
- accounted_size = size;
- }
- DECODE_FINISH(bl);
- }
- void dump(Formatter *f) const;
- static void generate_test_instances(std::list<RGWUploadPartInfo*>& o);
-};
-WRITE_CLASS_ENCODER(RGWUploadPartInfo)
-
class RGWMultiCompleteUpload : public XMLObj
{
public:
--- /dev/null
+// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * include files which can only be compiled in radosgw or OSD
+ * contexts (e.g., rgw_sal.h, rgw_common.h) */
+
+#pragma once
+
+#include <fmt/format.h>
+
+#include "rgw_pool_types.h"
+#include "rgw_bucket_types.h"
+#include "rgw_user_types.h"
+
+#include "common/dout.h"
+#include "common/Formatter.h"
+
+struct rgw_obj_index_key { // cls_rgw_obj_key now aliases this type
+ std::string name;
+ std::string instance;
+
+ rgw_obj_index_key() {}
+ rgw_obj_index_key(const std::string &_name) : name(_name) {}
+ rgw_obj_index_key(const std::string& n, const std::string& i) : name(n), instance(i) {}
+
+ std::string to_string() const {
+ return fmt::format("{}({})", name, instance);
+ }
+
+ bool empty() const {
+ return name.empty();
+ }
+
+ void set(const std::string& _name) {
+ name = _name;
+ instance.clear();
+ }
+
+ bool operator==(const rgw_obj_index_key& k) const {
+ return (name.compare(k.name) == 0) &&
+ (instance.compare(k.instance) == 0);
+ }
+
+ bool operator!=(const rgw_obj_index_key& k) const {
+ return (name.compare(k.name) != 0) ||
+ (instance.compare(k.instance) != 0);
+ }
+
+ bool operator<(const rgw_obj_index_key& k) const {
+ int r = name.compare(k.name);
+ if (r == 0) {
+ r = instance.compare(k.instance);
+ }
+ return (r < 0);
+ }
+
+ bool operator<=(const rgw_obj_index_key& k) const {
+ return !(k < *this);
+ }
+
+ void encode(ceph::buffer::list &bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(name, bl);
+ encode(instance, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(ceph::buffer::list::const_iterator &bl) {
+ DECODE_START(1, bl);
+ decode(name, bl);
+ decode(instance, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(ceph::Formatter *f) const {
+ f->dump_string("name", name);
+ f->dump_string("instance", instance);
+ }
+ void decode_json(JSONObj *obj);
+ static void generate_test_instances(std::list<rgw_obj_index_key*>& ls) {
+ ls.push_back(new rgw_obj_index_key);
+ ls.push_back(new rgw_obj_index_key);
+ ls.back()->name = "name";
+ ls.back()->instance = "instance";
+ }
+
+ size_t estimate_encoded_size() const {
+ constexpr size_t start_overhead = sizeof(__u8) + sizeof(__u8) + sizeof(ceph_le32); // version and length prefix
+ constexpr size_t string_overhead = sizeof(__u32); // strings are encoded with 32-bit length prefix
+ return start_overhead +
+ string_overhead + name.size() +
+ string_overhead + instance.size();
+ }
+};
+WRITE_CLASS_ENCODER(rgw_obj_index_key)
+
+struct rgw_obj_key {
+ std::string name;
+ std::string instance;
+ std::string ns;
+
+ rgw_obj_key() {}
+
+ // cppcheck-suppress noExplicitConstructor
+ rgw_obj_key(const std::string& n) : name(n) {}
+ rgw_obj_key(const std::string& n, const std::string& i) : name(n), instance(i) {}
+ rgw_obj_key(const std::string& n, const std::string& i, const std::string& _ns) : name(n), instance(i), ns(_ns) {}
+
+ rgw_obj_key(const rgw_obj_index_key& k) {
+ parse_index_key(k.name, &name, &ns);
+ instance = k.instance;
+ }
+
+ static void parse_index_key(const std::string& key, std::string *name, std::string *ns) {
+ if (key[0] != '_') {
+ *name = key;
+ ns->clear();
+ return;
+ }
+ if (key[1] == '_') {
+ *name = key.substr(1);
+ ns->clear();
+ return;
+ }
+ ssize_t pos = key.find('_', 1);
+ if (pos < 0) {
+ /* shouldn't happen, just use key */
+ *name = key;
+ ns->clear();
+ return;
+ }
+
+ *name = key.substr(pos + 1);
+ *ns = key.substr(1, pos -1);
+ }
+
+ void set(const std::string& n) {
+ name = n;
+ instance.clear();
+ ns.clear();
+ }
+
+ void set(const std::string& n, const std::string& i) {
+ name = n;
+ instance = i;
+ ns.clear();
+ }
+
+ void set(const std::string& n, const std::string& i, const std::string& _ns) {
+ name = n;
+ instance = i;
+ ns = _ns;
+ }
+
+ bool set(const rgw_obj_index_key& index_key) {
+ if (!parse_raw_oid(index_key.name, this)) {
+ return false;
+ }
+ instance = index_key.instance;
+ return true;
+ }
+
+ void set_instance(const std::string& i) {
+ instance = i;
+ }
+
+ const std::string& get_instance() const {
+ return instance;
+ }
+
+ void set_ns(const std::string& _ns) {
+ ns = _ns;
+ }
+
+ const std::string& get_ns() const {
+ return ns;
+ }
+
+ std::string get_index_key_name() const {
+ if (ns.empty()) {
+ if (name.size() < 1 || name[0] != '_') {
+ return name;
+ }
+ return std::string("_") + name;
+ };
+
+ char buf[ns.size() + 16];
+ snprintf(buf, sizeof(buf), "_%s_", ns.c_str());
+ return std::string(buf) + name;
+ };
+
+ void get_index_key(rgw_obj_index_key* key) const {
+ key->name = get_index_key_name();
+ key->instance = instance;
+ }
+
+ std::string get_loc() const {
+ /*
+ * For backward compatibility. Older versions used to have object locator on all objects,
+ * however, the name was the effective object locator. This had the same effect as not
+ * having object locator at all for most objects but the ones that started with underscore as
+ * these were escaped.
+ */
+ if (name[0] == '_' && ns.empty()) {
+ return name;
+ }
+
+ return {};
+ }
+
+ bool empty() const {
+ return name.empty();
+ }
+
+ bool have_null_instance() const {
+ return instance == "null";
+ }
+
+ bool have_instance() const {
+ return !instance.empty();
+ }
+
+ bool need_to_encode_instance() const {
+ return have_instance() && !have_null_instance();
+ }
+
+ std::string get_oid() const {
+ if (ns.empty() && !need_to_encode_instance()) {
+ if (name.size() < 1 || name[0] != '_') {
+ return name;
+ }
+ return std::string("_") + name;
+ }
+
+ std::string oid = "_";
+ oid.append(ns);
+ if (need_to_encode_instance()) {
+ oid.append(std::string(":") + instance);
+ }
+ oid.append("_");
+ oid.append(name);
+ return oid;
+ }
+
+ bool operator==(const rgw_obj_key& k) const {
+ return (name.compare(k.name) == 0) &&
+ (instance.compare(k.instance) == 0);
+ }
+
+ bool operator<(const rgw_obj_key& k) const {
+ int r = name.compare(k.name);
+ if (r == 0) {
+ r = instance.compare(k.instance);
+ }
+ return (r < 0);
+ }
+
+ bool operator<=(const rgw_obj_key& k) const {
+ return !(k < *this);
+ }
+
+ static void parse_ns_field(std::string& ns, std::string& instance) {
+ int pos = ns.find(':');
+ if (pos >= 0) {
+ instance = ns.substr(pos + 1);
+ ns = ns.substr(0, pos);
+ } else {
+ instance.clear();
+ }
+ }
+
+ // takes an oid and parses out the namespace (ns), name, and
+ // instance
+ static bool parse_raw_oid(const std::string& oid, rgw_obj_key *key) {
+ key->instance.clear();
+ key->ns.clear();
+ if (oid[0] != '_') {
+ key->name = oid;
+ return true;
+ }
+
+ if (oid.size() >= 2 && oid[1] == '_') {
+ key->name = oid.substr(1);
+ return true;
+ }
+
+ if (oid.size() < 3) // for namespace, min size would be 3: _x_
+ return false;
+
+ size_t pos = oid.find('_', 2); // oid must match ^_[^_].+$
+ if (pos == std::string::npos)
+ return false;
+
+ key->ns = oid.substr(1, pos - 1);
+ parse_ns_field(key->ns, key->instance);
+
+ key->name = oid.substr(pos + 1);
+ return true;
+ }
+
+ /**
+ * Translate a namespace-mangled object name to the user-facing name
+ * existing in the given namespace.
+ *
+ * If the object is part of the given namespace, it returns true
+ * and cuts down the name to the unmangled version. If it is not
+ * part of the given namespace, it returns false.
+ */
+ static bool oid_to_key_in_ns(const std::string& oid, rgw_obj_key *key, const std::string& ns) {
+ bool ret = parse_raw_oid(oid, key);
+ if (!ret) {
+ return ret;
+ }
+
+ return (ns == key->ns);
+ }
+
+ /**
+ * Given a mangled object name and an empty namespace std::string, this
+ * function extracts the namespace into the std::string and sets the object
+ * name to be the unmangled version.
+ *
+ * It returns true after successfully doing so, or
+ * false if it fails.
+ */
+ static bool strip_namespace_from_name(std::string& name, std::string& ns, std::string& instance) {
+ ns.clear();
+ instance.clear();
+ if (name[0] != '_') {
+ return true;
+ }
+
+ size_t pos = name.find('_', 1);
+ if (pos == std::string::npos) {
+ return false;
+ }
+
+ if (name[1] == '_') {
+ name = name.substr(1);
+ return true;
+ }
+
+ size_t period_pos = name.find('.');
+ if (period_pos < pos) {
+ return false;
+ }
+
+ ns = name.substr(1, pos-1);
+ name = name.substr(pos+1, std::string::npos);
+
+ parse_ns_field(ns, instance);
+ return true;
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(2, 1, bl);
+ encode(name, bl);
+ encode(instance, bl);
+ encode(ns, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(2, bl);
+ decode(name, bl);
+ decode(instance, bl);
+ if (struct_v >= 2) {
+ decode(ns, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+
+ std::string to_str() const {
+ if (instance.empty()) {
+ return name;
+ }
+ char buf[name.size() + instance.size() + 16];
+ snprintf(buf, sizeof(buf), "%s[%s]", name.c_str(), instance.c_str());
+ return buf;
+ }
+};
+WRITE_CLASS_ENCODER(rgw_obj_key)
+
+inline std::ostream& operator<<(std::ostream& out, const rgw_obj_key &o) {
+ return out << o.to_str();
+}
+
+struct rgw_raw_obj {
+ rgw_pool pool;
+ std::string oid;
+ std::string loc;
+
+ rgw_raw_obj() {}
+ rgw_raw_obj(const rgw_pool& _pool, const std::string& _oid) {
+ init(_pool, _oid);
+ }
+ rgw_raw_obj(const rgw_pool& _pool, const std::string& _oid, const std::string& _loc) : loc(_loc) {
+ init(_pool, _oid);
+ }
+
+ void init(const rgw_pool& _pool, const std::string& _oid) {
+ pool = _pool;
+ oid = _oid;
+ }
+
+ bool empty() const {
+ return oid.empty();
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(6, 6, bl);
+ encode(pool, bl);
+ encode(oid, bl);
+ encode(loc, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode_from_rgw_obj(bufferlist::const_iterator& bl);
+
+ void decode(bufferlist::const_iterator& bl) {
+ unsigned ofs = bl.get_off();
+ DECODE_START(6, bl);
+ if (struct_v < 6) {
+ /*
+ * this object was encoded as rgw_obj, prior to rgw_raw_obj been split out of it,
+ * let's decode it as rgw_obj and convert it
+ */
+ bl.seek(ofs);
+ decode_from_rgw_obj(bl);
+ return;
+ }
+ decode(pool, bl);
+ decode(oid, bl);
+ decode(loc, bl);
+ DECODE_FINISH(bl);
+ }
+
+ bool operator<(const rgw_raw_obj& o) const {
+ int r = pool.compare(o.pool);
+ if (r == 0) {
+ r = oid.compare(o.oid);
+ if (r == 0) {
+ r = loc.compare(o.loc);
+ }
+ }
+ return (r < 0);
+ }
+
+ bool operator==(const rgw_raw_obj& o) const {
+ return (pool == o.pool && oid == o.oid && loc == o.loc);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(rgw_raw_obj)
+
+inline std::ostream& operator<<(std::ostream& out, const rgw_raw_obj& o) {
+ out << o.pool << ":" << o.oid;
+ return out;
+}
+
+struct rgw_obj {
+ rgw_bucket bucket;
+ rgw_obj_key key;
+
+ bool in_extra_data{false}; /* in-memory only member, does not serialize */
+
+ // Represents the hash index source for this object once it is set (non-empty)
+ std::string index_hash_source;
+
+ rgw_obj() {}
+ rgw_obj(const rgw_bucket& b, const std::string& name) : bucket(b), key(name) {}
+ rgw_obj(const rgw_bucket& b, const rgw_obj_key& k) : bucket(b), key(k) {}
+ rgw_obj(const rgw_bucket& b, const rgw_obj_index_key& k) : bucket(b), key(k) {}
+
+ void init(const rgw_bucket& b, const rgw_obj_key& k) {
+ bucket = b;
+ key = k;
+ }
+
+ void init(const rgw_bucket& b, const std::string& name) {
+ bucket = b;
+ key.set(name);
+ }
+
+ void init(const rgw_bucket& b, const std::string& name, const std::string& i, const std::string& n) {
+ bucket = b;
+ key.set(name, i, n);
+ }
+
+ void init_ns(const rgw_bucket& b, const std::string& name, const std::string& n) {
+ bucket = b;
+ key.name = name;
+ key.instance.clear();
+ key.ns = n;
+ }
+
+ bool empty() const {
+ return key.empty();
+ }
+
+ void set_key(const rgw_obj_key& k) {
+ key = k;
+ }
+
+ std::string get_oid() const {
+ return key.get_oid();
+ }
+
+ const std::string& get_hash_object() const {
+ return index_hash_source.empty() ? key.name : index_hash_source;
+ }
+
+ void set_in_extra_data(bool val) {
+ in_extra_data = val;
+ }
+
+ bool is_in_extra_data() const {
+ return in_extra_data;
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(6, 6, bl);
+ encode(bucket, bl);
+ encode(key.ns, bl);
+ encode(key.name, bl);
+ encode(key.instance, bl);
+// encode(placement_id, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl);
+ if (struct_v < 6) {
+ std::string s;
+ decode(bucket.name, bl); /* bucket.name */
+ decode(s, bl); /* loc */
+ decode(key.ns, bl);
+ decode(key.name, bl);
+ if (struct_v >= 2)
+ decode(bucket, bl);
+ if (struct_v >= 4)
+ decode(key.instance, bl);
+ if (key.ns.empty() && key.instance.empty()) {
+ if (key.name[0] == '_') {
+ key.name = key.name.substr(1);
+ }
+ } else {
+ if (struct_v >= 5) {
+ decode(key.name, bl);
+ } else {
+ ssize_t pos = key.name.find('_', 1);
+ if (pos < 0) {
+ throw buffer::malformed_input();
+ }
+ key.name = key.name.substr(pos + 1);
+ }
+ }
+ } else {
+ decode(bucket, bl);
+ decode(key.ns, bl);
+ decode(key.name, bl);
+ decode(key.instance, bl);
+// decode(placement_id, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ static void generate_test_instances(std::list<rgw_obj*>& o);
+
+ bool operator==(const rgw_obj& o) const {
+ return (key == o.key) &&
+ (bucket == o.bucket);
+ }
+ bool operator<(const rgw_obj& o) const {
+ int r = key.name.compare(o.key.name);
+ if (r == 0) {
+ r = bucket.bucket_id.compare(o.bucket.bucket_id); /* not comparing bucket.name, if bucket_id is equal so will be bucket.name */
+ if (r == 0) {
+ r = key.ns.compare(o.key.ns);
+ if (r == 0) {
+ r = key.instance.compare(o.key.instance);
+ }
+ }
+ }
+
+ return (r < 0);
+ }
+
+ const rgw_pool& get_explicit_data_pool() {
+ if (!in_extra_data || bucket.explicit_placement.data_extra_pool.empty()) {
+ return bucket.explicit_placement.data_pool;
+ }
+ return bucket.explicit_placement.data_extra_pool;
+ }
+};
+WRITE_CLASS_ENCODER(rgw_obj)
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab ft=cpp
+
+#pragma once
+
+#include <string>
+
+#include "include/types.h"
+
+#include "common/Formatter.h"
+
+
+static std::string RGW_STORAGE_CLASS_STANDARD = "STANDARD";
+
+struct rgw_placement_rule {
+ std::string name;
+ std::string storage_class;
+
+ rgw_placement_rule() {}
+ rgw_placement_rule(const std::string& _n, const std::string& _sc) : name(_n), storage_class(_sc) {}
+ rgw_placement_rule(const rgw_placement_rule& _r, const std::string& _sc) : name(_r.name) {
+ if (!_sc.empty()) {
+ storage_class = _sc;
+ } else {
+ storage_class = _r.storage_class;
+ }
+ }
+
+ bool empty() const {
+ return name.empty() && storage_class.empty();
+ }
+
+ void inherit_from(const rgw_placement_rule& r) {
+ if (name.empty()) {
+ name = r.name;
+ }
+ if (storage_class.empty()) {
+ storage_class = r.storage_class;
+ }
+ }
+
+ void clear() {
+ name.clear();
+ storage_class.clear();
+ }
+
+ void init(const std::string& n, const std::string& c) {
+ name = n;
+ storage_class = c;
+ }
+
+ static const std::string& get_canonical_storage_class(const std::string& storage_class) {
+ if (storage_class.empty()) {
+ return RGW_STORAGE_CLASS_STANDARD;
+ }
+ return storage_class;
+ }
+
+ const std::string& get_storage_class() const {
+ return get_canonical_storage_class(storage_class);
+ }
+
+ int compare(const rgw_placement_rule& r) const {
+ int c = name.compare(r.name);
+ if (c != 0) {
+ return c;
+ }
+ return get_storage_class().compare(r.get_storage_class());
+ }
+
+ bool operator==(const rgw_placement_rule& r) const {
+ return (name == r.name &&
+ get_storage_class() == r.get_storage_class());
+ }
+
+ bool operator!=(const rgw_placement_rule& r) const {
+ return !(*this == r);
+ }
+
+ void encode(bufferlist& bl) const {
+ /* no ENCODE_START/END due to backward compatibility */
+ std::string s = to_str();
+ ceph::encode(s, bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ std::string s;
+ ceph::decode(s, bl);
+ from_str(s);
+ }
+
+ std::string to_str() const {
+ if (standard_storage_class()) {
+ return name;
+ }
+ return to_str_explicit();
+ }
+
+ std::string to_str_explicit() const {
+ return name + "/" + storage_class;
+ }
+
+ void from_str(const std::string& s) {
+ size_t pos = s.find("/");
+ if (pos == std::string::npos) {
+ name = s;
+ storage_class.clear();
+ return;
+ }
+ name = s.substr(0, pos);
+ storage_class = s.substr(pos + 1);
+ }
+
+ bool standard_storage_class() const {
+ return storage_class.empty() || storage_class == RGW_STORAGE_CLASS_STANDARD;
+ }
+};
+WRITE_CLASS_ENCODER(rgw_placement_rule)
--- /dev/null
+// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
+#pragma once
+
+#include <string>
+#include <fmt/format.h>
+
+#include "include/types.h"
+#include "common/Formatter.h"
+
+class JSONObj;
+
+struct rgw_pool {
+ std::string name;
+ std::string ns;
+
+ rgw_pool() = default;
+ rgw_pool(const rgw_pool& _p) : name(_p.name), ns(_p.ns) {}
+ rgw_pool(rgw_pool&&) = default;
+ rgw_pool(const std::string& _s) {
+ from_str(_s);
+ }
+ rgw_pool(const std::string& _name, const std::string& _ns) : name(_name), ns(_ns) {}
+
+ std::string to_str() const;
+ void from_str(const std::string& s);
+
+ void init(const std::string& _s) {
+ from_str(_s);
+ }
+
+ bool empty() const {
+ return name.empty();
+ }
+
+ int compare(const rgw_pool& p) const {
+ int r = name.compare(p.name);
+ if (r != 0) {
+ return r;
+ }
+ return ns.compare(p.ns);
+ }
+
+ void encode(ceph::buffer::list& bl) const {
+ ENCODE_START(10, 10, bl);
+ encode(name, bl);
+ encode(ns, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode_from_bucket(ceph::buffer::list::const_iterator& bl);
+
+ void decode(ceph::buffer::list::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(10, 3, 3, bl);
+
+ decode(name, bl);
+
+ if (struct_v < 10) {
+
+ /*
+ * note that rgw_pool can be used where rgw_bucket was used before
+ * therefore we inherit rgw_bucket's old versions. However, we only
+ * need the first field from rgw_bucket. unless we add more fields
+ * in which case we'll need to look at struct_v, and check the actual
+ * version. Anything older than 10 needs to be treated as old rgw_bucket
+ */
+
+ } else {
+ decode(ns, bl);
+ }
+
+ DECODE_FINISH(bl);
+ }
+
+ rgw_pool& operator=(const rgw_pool&) = default;
+
+ bool operator==(const rgw_pool& p) const {
+ return (compare(p) == 0);
+ }
+ bool operator!=(const rgw_pool& p) const {
+ return !(*this == p);
+ }
+ bool operator<(const rgw_pool& p) const {
+ int r = name.compare(p.name);
+ if (r == 0) {
+ return (ns.compare(p.ns) < 0);
+ }
+ return (r < 0);
+ }
+};
+WRITE_CLASS_ENCODER(rgw_pool)
+
+inline std::ostream& operator<<(std::ostream& out, const rgw_pool& p) {
+ out << p.to_str();
+ return out;
+}
+
+struct rgw_data_placement_target {
+ rgw_pool data_pool;
+ rgw_pool data_extra_pool;
+ rgw_pool index_pool;
+
+ rgw_data_placement_target() = default;
+ rgw_data_placement_target(const rgw_data_placement_target&) = default;
+ rgw_data_placement_target(rgw_data_placement_target&&) = default;
+
+ rgw_data_placement_target(const rgw_pool& data_pool,
+ const rgw_pool& data_extra_pool,
+ const rgw_pool& index_pool)
+ : data_pool(data_pool),
+ data_extra_pool(data_extra_pool),
+ index_pool(index_pool) {
+ }
+
+ rgw_data_placement_target&
+ operator=(const rgw_data_placement_target&) = default;
+
+ const rgw_pool& get_data_extra_pool() const {
+ if (data_extra_pool.empty()) {
+ return data_pool;
+ }
+ return data_extra_pool;
+ }
+
+ int compare(const rgw_data_placement_target& t) {
+ int c = data_pool.compare(t.data_pool);
+ if (c != 0) {
+ return c;
+ }
+ c = data_extra_pool.compare(t.data_extra_pool);
+ if (c != 0) {
+ return c;
+ }
+ return index_pool.compare(t.index_pool);
+ };
+
+ void dump(ceph::Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
#include "common/config_fwd.h"
#include "common/lru_map.h"
-#include <atomic>
-
-#include "rgw/rgw_basic_types.h"
+#include "rgw/rgw_quota_types.h"
#include "common/async/yield_context.h"
#include "rgw_sal_fwd.h"
-static inline int64_t rgw_rounded_kb(int64_t bytes)
-{
- return (bytes + 1023) / 1024;
-}
-
-class JSONObj;
-
-struct RGWQuotaInfo {
- template<class T> friend class RGWQuotaCache;
-public:
- int64_t max_size;
- int64_t max_objects;
- bool enabled;
- /* Do we want to compare with raw, not rounded RGWStorageStats::size (true)
- * or maybe rounded-to-4KiB RGWStorageStats::size_rounded (false)? */
- bool check_on_raw;
-
- RGWQuotaInfo()
- : max_size(-1),
- max_objects(-1),
- enabled(false),
- check_on_raw(false) {
- }
-
- void encode(bufferlist& bl) const {
- ENCODE_START(3, 1, bl);
- if (max_size < 0) {
- encode(-rgw_rounded_kb(abs(max_size)), bl);
- } else {
- encode(rgw_rounded_kb(max_size), bl);
- }
- encode(max_objects, bl);
- encode(enabled, bl);
- encode(max_size, bl);
- encode(check_on_raw, bl);
- ENCODE_FINISH(bl);
- }
- void decode(bufferlist::const_iterator& bl) {
- DECODE_START_LEGACY_COMPAT_LEN(3, 1, 1, bl);
- int64_t max_size_kb;
- decode(max_size_kb, bl);
- decode(max_objects, bl);
- decode(enabled, bl);
- if (struct_v < 2) {
- max_size = max_size_kb * 1024;
- } else {
- decode(max_size, bl);
- }
- if (struct_v >= 3) {
- decode(check_on_raw, bl);
- }
- DECODE_FINISH(bl);
- }
-
- void dump(Formatter *f) const;
-
- void decode_json(JSONObj *obj);
-
-};
-WRITE_CLASS_ENCODER(RGWQuotaInfo)
-
-struct RGWQuota {
- RGWQuotaInfo user_quota;
- RGWQuotaInfo bucket_quota;
-};
-
-
struct rgw_bucket;
class RGWQuotaHandler {
--- /dev/null
+// -*- 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) 2013 Inktank, 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
+#pragma once
+
+static inline int64_t rgw_rounded_kb(int64_t bytes)
+{
+ return (bytes + 1023) / 1024;
+}
+
+class JSONObj;
+
+struct RGWQuotaInfo {
+ template<class T> friend class RGWQuotaCache;
+public:
+ int64_t max_size;
+ int64_t max_objects;
+ bool enabled;
+ /* Do we want to compare with raw, not rounded RGWStorageStats::size (true)
+ * or maybe rounded-to-4KiB RGWStorageStats::size_rounded (false)? */
+ bool check_on_raw;
+
+ RGWQuotaInfo()
+ : max_size(-1),
+ max_objects(-1),
+ enabled(false),
+ check_on_raw(false) {
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(3, 1, bl);
+ if (max_size < 0) {
+ encode(-rgw_rounded_kb(abs(max_size)), bl);
+ } else {
+ encode(rgw_rounded_kb(max_size), bl);
+ }
+ encode(max_objects, bl);
+ encode(enabled, bl);
+ encode(max_size, bl);
+ encode(check_on_raw, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START_LEGACY_COMPAT_LEN(3, 1, 1, bl);
+ int64_t max_size_kb;
+ decode(max_size_kb, bl);
+ decode(max_objects, bl);
+ decode(enabled, bl);
+ if (struct_v < 2) {
+ max_size = max_size_kb * 1024;
+ } else {
+ decode(max_size, bl);
+ }
+ if (struct_v >= 3) {
+ decode(check_on_raw, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+
+ void dump(Formatter *f) const;
+
+ void decode_json(JSONObj *obj);
+
+};
+WRITE_CLASS_ENCODER(RGWQuotaInfo)
+
+struct RGWQuota {
+ RGWQuotaInfo user_quota;
+ RGWQuotaInfo bucket_quota;
+};
#include "cls/log/cls_log_types.h"
#include "cls/timeindex/cls_timeindex_types.h"
#include "cls/otp/cls_otp_types.h"
+#include "rgw_quota.h"
#include "rgw_log.h"
#include "rgw_metadata.h"
#include "rgw_meta_sync_status.h"
--- /dev/null
+// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * include files which can only be compiled in radosgw or OSD
+ * contexts (e.g., rgw_sal.h, rgw_common.h) */
+
+#pragma once
+
+#include <string_view>
+#include <fmt/format.h>
+
+#include "common/dout.h"
+#include "common/Formatter.h"
+
+struct rgw_user {
+ std::string tenant;
+ std::string id;
+ std::string ns;
+
+ rgw_user() {}
+ explicit rgw_user(const std::string& s) {
+ from_str(s);
+ }
+ rgw_user(const std::string& tenant, const std::string& id, const std::string& ns="")
+ : tenant(tenant),
+ id(id),
+ ns(ns) {
+ }
+ rgw_user(std::string&& tenant, std::string&& id, std::string&& ns="")
+ : tenant(std::move(tenant)),
+ id(std::move(id)),
+ ns(std::move(ns)) {
+ }
+
+ void encode(ceph::buffer::list& bl) const {
+ ENCODE_START(2, 1, bl);
+ encode(tenant, bl);
+ encode(id, bl);
+ encode(ns, bl);
+ ENCODE_FINISH(bl);
+ }
+ void decode(ceph::buffer::list::const_iterator& bl) {
+ DECODE_START(2, bl);
+ decode(tenant, bl);
+ decode(id, bl);
+ if (struct_v >= 2) {
+ decode(ns, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+
+ void to_str(std::string& str) const {
+ if (!tenant.empty()) {
+ if (!ns.empty()) {
+ str = tenant + '$' + ns + '$' + id;
+ } else {
+ str = tenant + '$' + id;
+ }
+ } else if (!ns.empty()) {
+ str = '$' + ns + '$' + id;
+ } else {
+ str = id;
+ }
+ }
+
+ void clear() {
+ tenant.clear();
+ id.clear();
+ ns.clear();
+ }
+
+ bool empty() const {
+ return id.empty();
+ }
+
+ std::string to_str() const {
+ std::string s;
+ to_str(s);
+ return s;
+ }
+
+ void from_str(const std::string& str) {
+ size_t pos = str.find('$');
+ if (pos != std::string::npos) {
+ tenant = str.substr(0, pos);
+ std::string_view sv = str;
+ std::string_view ns_id = sv.substr(pos + 1);
+ size_t ns_pos = ns_id.find('$');
+ if (ns_pos != std::string::npos) {
+ ns = std::string(ns_id.substr(0, ns_pos));
+ id = std::string(ns_id.substr(ns_pos + 1));
+ } else {
+ ns.clear();
+ id = std::string(ns_id);
+ }
+ } else {
+ tenant.clear();
+ ns.clear();
+ id = str;
+ }
+ }
+
+ rgw_user& operator=(const std::string& str) {
+ from_str(str);
+ return *this;
+ }
+
+ int compare(const rgw_user& u) const {
+ int r = tenant.compare(u.tenant);
+ if (r != 0)
+ return r;
+ r = ns.compare(u.ns);
+ if (r != 0) {
+ return r;
+ }
+ return id.compare(u.id);
+ }
+ int compare(const std::string& str) const {
+ rgw_user u(str);
+ return compare(u);
+ }
+
+ bool operator!=(const rgw_user& rhs) const {
+ return (compare(rhs) != 0);
+ }
+ bool operator==(const rgw_user& rhs) const {
+ return (compare(rhs) == 0);
+ }
+ bool operator<(const rgw_user& rhs) const {
+ if (tenant < rhs.tenant) {
+ return true;
+ } else if (tenant > rhs.tenant) {
+ return false;
+ }
+ if (ns < rhs.ns) {
+ return true;
+ } else if (ns > rhs.ns) {
+ return false;
+ }
+ return (id < rhs.id);
+ }
+ void dump(ceph::Formatter *f) const;
+ static void generate_test_instances(std::list<rgw_user*>& o);
+};
+WRITE_CLASS_ENCODER(rgw_user)
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp
+/* N.B., this header defines fundamental serialized types. Do not
+ * include files which can only be compiled in radosgw or OSD
+ * contexts (e.g., rgw_sal.h, rgw_common.h) */
+
#pragma once
#include <string>
--- /dev/null
+// -*- 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) 2019 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.
+ *
+ */
+
+/* N.B., this header defines fundamental serialized types. Do not
+ * introduce changes or include files which can only be compiled in
+ * radosgw or OSD contexts (e.g., rgw_sal.h, rgw_common.h)
+ */
+
+#pragma once
+
+#include <string>
+#include <set>
+#include <map>
+#include <list>
+#include <boost/optional.hpp>
+
+#include <fmt/format.h>
+
+#include "include/types.h"
+#include "rgw_bucket_layout.h"
+#include "rgw_zone_features.h"
+#include "rgw_pool_types.h"
+#include "rgw_acl_types.h"
+#include "rgw_placement_types.h"
+
+#include "common/Formatter.h"
+
+class JSONObj;
+
+namespace rgw_zone_defaults {
+
+extern std::string zone_names_oid_prefix;
+extern std::string region_info_oid_prefix;
+extern std::string realm_names_oid_prefix;
+extern std::string zone_group_info_oid_prefix;
+extern std::string realm_info_oid_prefix;
+extern std::string default_region_info_oid;
+extern std::string default_zone_group_info_oid;
+extern std::string region_map_oid;
+extern std::string default_realm_info_oid;
+extern std::string default_zonegroup_name;
+extern std::string default_zone_name;
+extern std::string zonegroup_names_oid_prefix;
+extern std::string RGW_DEFAULT_ZONE_ROOT_POOL;
+extern std::string RGW_DEFAULT_ZONEGROUP_ROOT_POOL;
+extern std::string RGW_DEFAULT_REALM_ROOT_POOL;
+extern std::string RGW_DEFAULT_PERIOD_ROOT_POOL;
+extern std::string avail_pools;
+extern std::string default_storage_pool_suffix;
+
+} /* namespace rgw_zone_defaults */
+
+struct RGWNameToId {
+ std::string obj_id;
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(obj_id, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(obj_id, bl);
+ DECODE_FINISH(bl);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWNameToId)
+
+struct RGWDefaultSystemMetaObjInfo {
+ std::string default_id;
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(default_id, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(default_id, bl);
+ DECODE_FINISH(bl);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWDefaultSystemMetaObjInfo)
+
+struct RGWZoneStorageClass {
+ boost::optional<rgw_pool> data_pool;
+ boost::optional<std::string> compression_type;
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(data_pool, bl);
+ encode(compression_type, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(data_pool, bl);
+ decode(compression_type, bl);
+ DECODE_FINISH(bl);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWZoneStorageClass)
+
+class RGWZoneStorageClasses {
+ std::map<std::string, RGWZoneStorageClass> m;
+
+ /* in memory only */
+ RGWZoneStorageClass *standard_class;
+
+public:
+ RGWZoneStorageClasses() {
+ standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
+ }
+ RGWZoneStorageClasses(const RGWZoneStorageClasses& rhs) {
+ m = rhs.m;
+ standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
+ }
+ RGWZoneStorageClasses& operator=(const RGWZoneStorageClasses& rhs) {
+ m = rhs.m;
+ standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
+ return *this;
+ }
+
+ const RGWZoneStorageClass& get_standard() const {
+ return *standard_class;
+ }
+
+ bool find(const std::string& sc, const RGWZoneStorageClass** pstorage_class) const {
+ auto iter = m.find(sc);
+ if (iter == m.end()) {
+ return false;
+ }
+ *pstorage_class = &iter->second;
+ return true;
+ }
+
+ bool exists(const std::string& sc) const {
+ if (sc.empty()) {
+ return true;
+ }
+ auto iter = m.find(sc);
+ return (iter != m.end());
+ }
+
+ const std::map<std::string, RGWZoneStorageClass>& get_all() const {
+ return m;
+ }
+
+ std::map<std::string, RGWZoneStorageClass>& get_all() {
+ return m;
+ }
+
+ void set_storage_class(const std::string& sc, const rgw_pool* data_pool, const std::string* compression_type) {
+ const std::string *psc = ≻
+ if (sc.empty()) {
+ psc = &RGW_STORAGE_CLASS_STANDARD;
+ }
+ RGWZoneStorageClass& storage_class = m[*psc];
+ if (data_pool) {
+ storage_class.data_pool = *data_pool;
+ }
+ if (compression_type) {
+ storage_class.compression_type = *compression_type;
+ }
+ }
+
+ void remove_storage_class(const std::string& sc) {
+ if (!sc.empty()) {
+ m.erase(sc);
+ }
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(m, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(m, bl);
+ standard_class = &m[RGW_STORAGE_CLASS_STANDARD];
+ DECODE_FINISH(bl);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWZoneStorageClasses)
+
+struct RGWZonePlacementInfo {
+ rgw_pool index_pool;
+ rgw_pool data_extra_pool; /* if not set we should use data_pool */
+ RGWZoneStorageClasses storage_classes;
+ rgw::BucketIndexType index_type;
+
+ RGWZonePlacementInfo() : index_type(rgw::BucketIndexType::Normal) {}
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(7, 1, bl);
+ encode(index_pool.to_str(), bl);
+ rgw_pool standard_data_pool = get_data_pool(RGW_STORAGE_CLASS_STANDARD);
+ encode(standard_data_pool.to_str(), bl);
+ encode(data_extra_pool.to_str(), bl);
+ encode((uint32_t)index_type, bl);
+ std::string standard_compression_type = get_compression_type(RGW_STORAGE_CLASS_STANDARD);
+ encode(standard_compression_type, bl);
+ encode(storage_classes, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(7, bl);
+ std::string index_pool_str;
+ std::string data_pool_str;
+ decode(index_pool_str, bl);
+ index_pool = rgw_pool(index_pool_str);
+ decode(data_pool_str, bl);
+ rgw_pool standard_data_pool(data_pool_str);
+ if (struct_v >= 4) {
+ std::string data_extra_pool_str;
+ decode(data_extra_pool_str, bl);
+ data_extra_pool = rgw_pool(data_extra_pool_str);
+ }
+ if (struct_v >= 5) {
+ uint32_t it;
+ decode(it, bl);
+ index_type = (rgw::BucketIndexType)it;
+ }
+ std::string standard_compression_type;
+ if (struct_v >= 6) {
+ decode(standard_compression_type, bl);
+ }
+ if (struct_v >= 7) {
+ decode(storage_classes, bl);
+ } else {
+ storage_classes.set_storage_class(RGW_STORAGE_CLASS_STANDARD, &standard_data_pool,
+ (!standard_compression_type.empty() ? &standard_compression_type : nullptr));
+ }
+ DECODE_FINISH(bl);
+ }
+ const rgw_pool& get_data_extra_pool() const {
+ static rgw_pool no_pool;
+ if (data_extra_pool.empty()) {
+ return storage_classes.get_standard().data_pool.get_value_or(no_pool);
+ }
+ return data_extra_pool;
+ }
+ const rgw_pool& get_data_pool(const std::string& sc) const {
+ const RGWZoneStorageClass *storage_class;
+ static rgw_pool no_pool;
+
+ if (!storage_classes.find(sc, &storage_class)) {
+ return storage_classes.get_standard().data_pool.get_value_or(no_pool);
+ }
+
+ return storage_class->data_pool.get_value_or(no_pool);
+ }
+ const rgw_pool& get_standard_data_pool() const {
+ return get_data_pool(RGW_STORAGE_CLASS_STANDARD);
+ }
+
+ const std::string& get_compression_type(const std::string& sc) const {
+ const RGWZoneStorageClass *storage_class;
+ static std::string no_compression;
+
+ if (!storage_classes.find(sc, &storage_class)) {
+ return no_compression;
+ }
+ return storage_class->compression_type.get_value_or(no_compression);
+ }
+
+ bool storage_class_exists(const std::string& sc) const {
+ return storage_classes.exists(sc);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+
+};
+WRITE_CLASS_ENCODER(RGWZonePlacementInfo)
+
+struct RGWZone {
+ std::string id;
+ std::string name;
+ std::list<std::string> endpoints; // std::vector?
+ bool log_meta;
+ bool log_data;
+ bool read_only;
+ std::string tier_type;
+ std::string redirect_zone;
+
+/**
+ * Represents the number of shards for the bucket index object, a value of zero
+ * indicates there is no sharding. By default (no sharding, the name of the object
+ * is '.dir.{marker}', with sharding, the name is '.dir.{marker}.{sharding_id}',
+ * sharding_id is zero-based value. It is not recommended to set a too large value
+ * (e.g. thousand) as it increases the cost for bucket listing.
+ */
+ uint32_t bucket_index_max_shards;
+
+ // pre-shard buckets on creation to enable some write-parallism by default,
+ // delay the need to reshard as the bucket grows, and (in multisite) get some
+ // bucket index sharding where dynamic resharding is not supported
+ static constexpr uint32_t default_bucket_index_max_shards = 11;
+
+ bool sync_from_all;
+ std::set<std::string> sync_from; /* list of zones to sync from */
+
+ rgw::zone_features::set supported_features;
+
+ RGWZone()
+ : log_meta(false), log_data(false), read_only(false),
+ bucket_index_max_shards(default_bucket_index_max_shards),
+ sync_from_all(true) {}
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(8, 1, bl);
+ encode(name, bl);
+ encode(endpoints, bl);
+ encode(log_meta, bl);
+ encode(log_data, bl);
+ encode(bucket_index_max_shards, bl);
+ encode(id, bl);
+ encode(read_only, bl);
+ encode(tier_type, bl);
+ encode(sync_from_all, bl);
+ encode(sync_from, bl);
+ encode(redirect_zone, bl);
+ encode(supported_features, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(8, bl);
+ decode(name, bl);
+ if (struct_v < 4) {
+ id = name;
+ }
+ decode(endpoints, bl);
+ if (struct_v >= 2) {
+ decode(log_meta, bl);
+ decode(log_data, bl);
+ }
+ if (struct_v >= 3) {
+ decode(bucket_index_max_shards, bl);
+ }
+ if (struct_v >= 4) {
+ decode(id, bl);
+ decode(read_only, bl);
+ }
+ if (struct_v >= 5) {
+ decode(tier_type, bl);
+ }
+ if (struct_v >= 6) {
+ decode(sync_from_all, bl);
+ decode(sync_from, bl);
+ }
+ if (struct_v >= 7) {
+ decode(redirect_zone, bl);
+ }
+ if (struct_v >= 8) {
+ decode(supported_features, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+ static void generate_test_instances(std::list<RGWZone*>& o);
+
+ bool is_read_only() const { return read_only; }
+
+ bool syncs_from(const std::string& zone_name) const {
+ return (sync_from_all || sync_from.find(zone_name) != sync_from.end());
+ }
+
+ bool supports(std::string_view feature) const {
+ return supported_features.contains(feature);
+ }
+};
+WRITE_CLASS_ENCODER(RGWZone)
+
+struct RGWDefaultZoneGroupInfo {
+ std::string default_zonegroup;
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(default_zonegroup, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(default_zonegroup, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+ //todo: implement ceph-dencoder
+};
+WRITE_CLASS_ENCODER(RGWDefaultZoneGroupInfo)
+
+struct RGWTierACLMapping {
+ ACLGranteeTypeEnum type{ACL_TYPE_CANON_USER};
+ std::string source_id;
+ std::string dest_id;
+
+ RGWTierACLMapping() = default;
+
+ RGWTierACLMapping(ACLGranteeTypeEnum t,
+ const std::string& s,
+ const std::string& d) : type(t),
+ source_id(s),
+ dest_id(d) {}
+
+ void init(const JSONFormattable& config) {
+ const std::string& t = config["type"];
+
+ if (t == "email") {
+ type = ACL_TYPE_EMAIL_USER;
+ } else if (t == "uri") {
+ type = ACL_TYPE_GROUP;
+ } else {
+ type = ACL_TYPE_CANON_USER;
+ }
+
+ source_id = config["source_id"];
+ dest_id = config["dest_id"];
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode((uint32_t)type, bl);
+ encode(source_id, bl);
+ encode(dest_id, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ uint32_t it;
+ decode(it, bl);
+ type = (ACLGranteeTypeEnum)it;
+ decode(source_id, bl);
+ decode(dest_id, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWTierACLMapping)
+
+enum HostStyle {
+ PathStyle = 0,
+ VirtualStyle = 1,
+};
+
+struct RGWZoneGroupPlacementTierS3 {
+#define DEFAULT_MULTIPART_SYNC_PART_SIZE (32 * 1024 * 1024)
+ std::string endpoint;
+ RGWAccessKey key;
+ std::string region;
+ HostStyle host_style{PathStyle};
+ std::string target_storage_class;
+
+ /* Should below be bucket/zone specific?? */
+ std::string target_path;
+ std::map<std::string, RGWTierACLMapping> acl_mappings;
+
+ uint64_t multipart_sync_threshold{DEFAULT_MULTIPART_SYNC_PART_SIZE};
+ uint64_t multipart_min_part_size{DEFAULT_MULTIPART_SYNC_PART_SIZE};
+
+ int update_params(const JSONFormattable& config);
+ int clear_params(const JSONFormattable& config);
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(endpoint, bl);
+ encode(key, bl);
+ encode(region, bl);
+ encode((uint32_t)host_style, bl); // XXX kill C-style casts
+ encode(target_storage_class, bl);
+ encode(target_path, bl);
+ encode(acl_mappings, bl);
+ encode(multipart_sync_threshold, bl);
+ encode(multipart_min_part_size, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(endpoint, bl);
+ decode(key, bl);
+ decode(region, bl);
+
+ uint32_t it;
+ decode(it, bl);
+ host_style = (HostStyle)it; // XXX can't this be HostStyle(it)?
+
+ decode(target_storage_class, bl);
+ decode(target_path, bl);
+ decode(acl_mappings, bl);
+ decode(multipart_sync_threshold, bl);
+ decode(multipart_min_part_size, bl);
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTierS3)
+
+struct RGWZoneGroupPlacementTier {
+ std::string tier_type;
+ std::string storage_class;
+ bool retain_head_object = false;
+
+ struct _tier {
+ RGWZoneGroupPlacementTierS3 s3;
+ } t;
+
+ int update_params(const JSONFormattable& config);
+ int clear_params(const JSONFormattable& config);
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(1, 1, bl);
+ encode(tier_type, bl);
+ encode(storage_class, bl);
+ encode(retain_head_object, bl);
+ if (tier_type == "cloud-s3") {
+ encode(t.s3, bl);
+ }
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(1, bl);
+ decode(tier_type, bl);
+ decode(storage_class, bl);
+ decode(retain_head_object, bl);
+ if (tier_type == "cloud-s3") {
+ decode(t.s3, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTier)
+
+struct RGWZoneGroupPlacementTarget {
+ std::string name;
+ std::set<std::string> tags;
+ std::set<std::string> storage_classes;
+ std::map<std::string, RGWZoneGroupPlacementTier> tier_targets;
+
+ bool user_permitted(const std::list<std::string>& user_tags) const {
+ if (tags.empty()) {
+ return true;
+ }
+ for (auto& rule : user_tags) {
+ if (tags.find(rule) != tags.end()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void encode(bufferlist& bl) const {
+ ENCODE_START(3, 1, bl);
+ encode(name, bl);
+ encode(tags, bl);
+ encode(storage_classes, bl);
+ encode(tier_targets, bl);
+ ENCODE_FINISH(bl);
+ }
+
+ void decode(bufferlist::const_iterator& bl) {
+ DECODE_START(3, bl);
+ decode(name, bl);
+ decode(tags, bl);
+ if (struct_v >= 2) {
+ decode(storage_classes, bl);
+ }
+ if (storage_classes.empty()) {
+ storage_classes.insert(RGW_STORAGE_CLASS_STANDARD);
+ }
+ if (struct_v >= 3) {
+ decode(tier_targets, bl);
+ }
+ DECODE_FINISH(bl);
+ }
+ void dump(Formatter *f) const;
+ void decode_json(JSONObj *obj);
+};
+WRITE_CLASS_ENCODER(RGWZoneGroupPlacementTarget)
add_executable(ceph_test_rados_api_tier_pp
tier_cxx.cc
$<TARGET_OBJECTS:unit-main>)
+target_include_directories(ceph_test_rados_api_tier_pp
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw/driver/rados"
+ PUBLIC "${CMAKE_SOURCE_DIR}/src/rgw")
target_link_libraries(ceph_test_rados_api_tier_pp
librados global ${UNITTEST_LIBS} Boost::system radostest-cxx cls_cas_internal
cls_cas_client spawn)
projects / ceph-ci.git / commitdiff