From: Daniel Gryniewicz Date: Mon, 30 Sep 2019 18:43:18 +0000 (-0400) Subject: Project Zipper - Bucket X-Git-Tag: v15.1.0~904^2 X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=e5775fee5c3940ac7578e0bba898296685375212;p=ceph-ci.git Project Zipper - Bucket Implement the zipper container Bucket, and portions of User needed to make it work. Zipper is still a WIP, there's more to do before it's complete. Signed-off-by: Daniel Gryniewicz --- diff --git a/src/rgw/rgw_bucket.cc b/src/rgw/rgw_bucket.cc index 55135fc00de..24aa82358c1 100644 --- a/src/rgw/rgw_bucket.cc +++ b/src/rgw/rgw_bucket.cc @@ -55,8 +55,6 @@ #define BUCKET_TAG_TIMEOUT 30 -using namespace rgw::sal; - /* * The tenant_name is always returned on purpose. May be empty, of course. @@ -147,7 +145,7 @@ void rgw_parse_url_bucket(const string &bucket, const string& auth_tenant, * Get all the buckets owned by a user and fill up an RGWUserBuckets with them. * Returns: 0 on success, -ERR# on failure. */ -int rgw_read_user_buckets(RGWRadosStore * store, +int rgw_read_user_buckets(rgw::sal::RGWRadosStore * store, const rgw_user& user_id, rgw::sal::RGWBucketList& buckets, const string& marker, @@ -250,7 +248,7 @@ static void dump_mulipart_index_results(list& objs_to_unlink, } } -void check_bad_user_bucket_mapping(RGWRadosStore *store, const rgw_user& user_id, +void check_bad_user_bucket_mapping(rgw::sal::RGWRadosStore *store, const rgw_user& user_id, bool fix) { rgw::sal::RGWBucketList user_buckets; @@ -269,13 +267,13 @@ void check_bad_user_bucket_mapping(RGWRadosStore *store, const rgw_user& user_id return; } - map& buckets = user_buckets.get_buckets(); - for (map::iterator i = buckets.begin(); + map& buckets = user_buckets.get_buckets(); + for (map::iterator i = buckets.begin(); i != buckets.end(); ++i) { marker = i->first; - RGWSalBucket* bucket = i->second; + rgw::sal::RGWBucket* bucket = i->second; RGWBucketInfo bucket_info; real_time mtime; @@ -313,7 +311,7 @@ static bool bucket_object_check_filter(const string& oid) return rgw_obj_key::oid_to_key_in_ns(oid, &key, ns); } -int rgw_remove_object(RGWRadosStore *store, const RGWBucketInfo& bucket_info, const rgw_bucket& bucket, rgw_obj_key& key) +int rgw_remove_object(rgw::sal::RGWRadosStore *store, const RGWBucketInfo& bucket_info, const rgw_bucket& bucket, rgw_obj_key& key) { RGWObjectCtx rctx(store); @@ -327,7 +325,7 @@ int rgw_remove_object(RGWRadosStore *store, const RGWBucketInfo& bucket_info, co } /* xxx dang */ -static int rgw_remove_bucket(RGWRadosStore *store, rgw_bucket& bucket, bool delete_children, optional_yield y) +static int rgw_remove_bucket(rgw::sal::RGWRadosStore *store, rgw_bucket& bucket, bool delete_children, optional_yield y) { int ret; map stats; @@ -429,7 +427,7 @@ static int drain_handles(list& pending) return ret; } -int rgw_remove_bucket_bypass_gc(RGWRadosStore *store, rgw_bucket& bucket, +int rgw_remove_bucket_bypass_gc(rgw::sal::RGWRadosStore *store, rgw_bucket& bucket, int concurrent_max, bool keep_index_consistent, optional_yield y) { @@ -577,7 +575,7 @@ static void set_err_msg(std::string *sink, std::string msg) *sink = msg; } -int RGWBucket::init(RGWRadosStore *storage, RGWBucketAdminOpState& op_state, +int RGWBucket::init(rgw::sal::RGWRadosStore *storage, RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg, map *pattrs) { @@ -1176,7 +1174,7 @@ int RGWBucket::get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolic } -int RGWBucketAdminOp::get_policy(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +int RGWBucketAdminOp::get_policy(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWAccessControlPolicy& policy) { RGWBucket bucket; @@ -1195,7 +1193,7 @@ int RGWBucketAdminOp::get_policy(RGWRadosStore *store, RGWBucketAdminOpState& op /* Wrappers to facilitate RESTful interface */ -int RGWBucketAdminOp::get_policy(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +int RGWBucketAdminOp::get_policy(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher) { RGWAccessControlPolicy policy(store->ctx()); @@ -1217,7 +1215,7 @@ int RGWBucketAdminOp::get_policy(RGWRadosStore *store, RGWBucketAdminOpState& op return 0; } -int RGWBucketAdminOp::dump_s3_policy(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +int RGWBucketAdminOp::dump_s3_policy(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, ostream& os) { RGWAccessControlPolicy_S3 policy(store->ctx()); @@ -1231,7 +1229,7 @@ int RGWBucketAdminOp::dump_s3_policy(RGWRadosStore *store, RGWBucketAdminOpState return 0; } -int RGWBucketAdminOp::unlink(RGWRadosStore *store, RGWBucketAdminOpState& op_state) +int RGWBucketAdminOp::unlink(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state) { RGWBucket bucket; @@ -1242,7 +1240,7 @@ int RGWBucketAdminOp::unlink(RGWRadosStore *store, RGWBucketAdminOpState& op_sta return bucket.unlink(op_state, null_yield); } -int RGWBucketAdminOp::link(RGWRadosStore *store, RGWBucketAdminOpState& op_state, string *err) +int RGWBucketAdminOp::link(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, string *err) { RGWBucket bucket; map attrs; @@ -1272,7 +1270,7 @@ int RGWBucketAdminOp::chown(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpStat } -int RGWBucketAdminOp::check_index(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +int RGWBucketAdminOp::check_index(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher, optional_yield y) { int ret; @@ -1307,7 +1305,7 @@ int RGWBucketAdminOp::check_index(RGWRadosStore *store, RGWBucketAdminOpState& o return 0; } -int RGWBucketAdminOp::remove_bucket(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +int RGWBucketAdminOp::remove_bucket(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, optional_yield y, bool bypass_gc, bool keep_index_consistent) { RGWBucket bucket; @@ -1324,7 +1322,7 @@ int RGWBucketAdminOp::remove_bucket(RGWRadosStore *store, RGWBucketAdminOpState& return ret; } -int RGWBucketAdminOp::remove_object(RGWRadosStore *store, RGWBucketAdminOpState& op_state) +int RGWBucketAdminOp::remove_object(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state) { RGWBucket bucket; @@ -1335,7 +1333,7 @@ int RGWBucketAdminOp::remove_object(RGWRadosStore *store, RGWBucketAdminOpState& return bucket.remove_object(op_state); } -int RGWBucketAdminOp::sync_bucket(RGWRadosStore *store, RGWBucketAdminOpState& op_state, string *err_msg) +int RGWBucketAdminOp::sync_bucket(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, string *err_msg) { RGWBucket bucket; map attrs; @@ -1347,7 +1345,7 @@ int RGWBucketAdminOp::sync_bucket(RGWRadosStore *store, RGWBucketAdminOpState& o return bucket.sync(op_state, &attrs, err_msg); } -static int bucket_stats(RGWRadosStore *store, const std::string& tenant_name, std::string& bucket_name, Formatter *formatter) +static int bucket_stats(rgw::sal::RGWRadosStore *store, const std::string& tenant_name, std::string& bucket_name, Formatter *formatter) { RGWBucketInfo bucket_info; map stats; @@ -1410,7 +1408,7 @@ static int bucket_stats(RGWRadosStore *store, const std::string& tenant_name, st return 0; } -int RGWBucketAdminOp::limit_check(RGWRadosStore *store, +int RGWBucketAdminOp::limit_check(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, const std::list& user_ids, RGWFormatterFlusher& flusher, @@ -1449,7 +1447,7 @@ int RGWBucketAdminOp::limit_check(RGWRadosStore *store, if (ret < 0) return ret; - map& m_buckets = buckets.get_buckets(); + map& m_buckets = buckets.get_buckets(); for (const auto& iter : m_buckets) { auto bucket = iter.second; @@ -1531,7 +1529,7 @@ int RGWBucketAdminOp::limit_check(RGWRadosStore *store, return ret; } /* RGWBucketAdminOp::limit_check */ -int RGWBucketAdminOp::info(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +int RGWBucketAdminOp::info(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher) { int ret = 0; @@ -1558,8 +1556,8 @@ int RGWBucketAdminOp::info(RGWRadosStore *store, RGWBucketAdminOpState& op_state if (ret < 0) return ret; - map& m = buckets.get_buckets(); - map::iterator iter; + map& m = buckets.get_buckets(); + map::iterator iter; for (iter = m.begin(); iter != m.end(); ++iter) { std::string obj_name = iter->first; @@ -1611,7 +1609,7 @@ int RGWBucketAdminOp::info(RGWRadosStore *store, RGWBucketAdminOpState& op_state return 0; } -int RGWBucketAdminOp::set_quota(RGWRadosStore *store, RGWBucketAdminOpState& op_state) +int RGWBucketAdminOp::set_quota(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state) { RGWBucket bucket; @@ -1621,7 +1619,7 @@ int RGWBucketAdminOp::set_quota(RGWRadosStore *store, RGWBucketAdminOpState& op_ return bucket.set_quota(op_state); } -static int purge_bucket_instance(RGWRadosStore *store, const RGWBucketInfo& bucket_info) +static int purge_bucket_instance(rgw::sal::RGWRadosStore *store, const RGWBucketInfo& bucket_info) { int max_shards = (bucket_info.num_shards > 0 ? bucket_info.num_shards : 1); for (int i = 0; i < max_shards; i++) { @@ -1652,7 +1650,7 @@ inline auto split_tenant(const std::string& bucket_name){ } using bucket_instance_ls = std::vector; -void get_stale_instances(RGWRadosStore *store, const std::string& bucket_name, +void get_stale_instances(rgw::sal::RGWRadosStore *store, const std::string& bucket_name, const vector& lst, bucket_instance_ls& stale_instances) { @@ -1738,11 +1736,11 @@ void get_stale_instances(RGWRadosStore *store, const std::string& bucket_name, return; } -static int process_stale_instances(RGWRadosStore *store, RGWBucketAdminOpState& op_state, +static int process_stale_instances(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher, std::function process_f) + rgw::sal::RGWRadosStore*)> process_f) { std::string marker; void *handle; @@ -1788,13 +1786,13 @@ static int process_stale_instances(RGWRadosStore *store, RGWBucketAdminOpState& return 0; } -int RGWBucketAdminOp::list_stale_instances(RGWRadosStore *store, +int RGWBucketAdminOp::list_stale_instances(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher) { auto process_f = [](const bucket_instance_ls& lst, Formatter *formatter, - RGWRadosStore*){ + rgw::sal::RGWRadosStore*){ for (const auto& binfo: lst) formatter->dump_string("key", binfo.bucket.get_key()); }; @@ -1802,13 +1800,13 @@ int RGWBucketAdminOp::list_stale_instances(RGWRadosStore *store, } -int RGWBucketAdminOp::clear_stale_instances(RGWRadosStore *store, +int RGWBucketAdminOp::clear_stale_instances(rgw::sal::RGWRadosStore *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher) { auto process_f = [](const bucket_instance_ls& lst, Formatter *formatter, - RGWRadosStore *store){ + rgw::sal::RGWRadosStore *store){ for (const auto &binfo: lst) { int ret = purge_bucket_instance(store, binfo); if (ret == 0){ diff --git a/src/rgw/rgw_bucket.h b/src/rgw/rgw_bucket.h index 94826b6315c..8e382848a1f 100644 --- a/src/rgw/rgw_bucket.h +++ b/src/rgw/rgw_bucket.h @@ -37,11 +37,6 @@ extern int rgw_bucket_parse_bucket_key(CephContext *cct, const string& key, extern std::string rgw_make_bucket_entry_name(const std::string& tenant_name, const std::string& bucket_name); -static inline void rgw_make_bucket_entry_name(const string& tenant_name, - const string& bucket_name, - std::string& bucket_entry) { - bucket_entry = rgw_make_bucket_entry_name(tenant_name, bucket_name); -} extern void rgw_parse_url_bucket(const string& bucket, const string& auth_tenant, diff --git a/src/rgw/rgw_file.h b/src/rgw/rgw_file.h index 92bcda3fcd5..856e2f60324 100644 --- a/src/rgw/rgw_file.h +++ b/src/rgw/rgw_file.h @@ -1382,10 +1382,10 @@ public: void send_response_data(rgw::sal::RGWBucketList& buckets) override { if (!sent_data) return; - map& m = buckets.get_buckets(); + map& m = buckets.get_buckets(); for (const auto& iter : m) { boost::string_ref marker{iter.first}; - rgw::sal::RGWSalBucket* ent = iter.second; + rgw::sal::RGWBucket* ent = iter.second; if (! this->operator()(ent->get_name(), marker)) { /* caller cannot accept more */ lsubdout(cct, rgw, 5) << "ListBuckets rcb failed" diff --git a/src/rgw/rgw_lc.cc b/src/rgw/rgw_lc.cc index 211c5edd453..58ea81ebec3 100644 --- a/src/rgw/rgw_lc.cc +++ b/src/rgw/rgw_lc.cc @@ -42,7 +42,6 @@ const char* LC_STATUS[] = { }; using namespace librados; -using namespace rgw::sal; bool LCRule::valid() const { @@ -222,7 +221,7 @@ void *RGWLC::LCWorker::entry() { return NULL; } -void RGWLC::initialize(CephContext *_cct, RGWRadosStore *_store) { +void RGWLC::initialize(CephContext *_cct, rgw::sal::RGWRadosStore *_store) { cct = _cct; store = _store; max_objs = cct->_conf->rgw_lc_max_objs; @@ -470,7 +469,7 @@ static inline bool has_all_tags(const lc_op& rule_action, } class LCObjsLister { - RGWRadosStore *store; + rgw::sal::RGWRadosStore *store; RGWBucketInfo& bucket_info; RGWRados::Bucket target; RGWRados::Bucket::List list_op; @@ -483,7 +482,7 @@ class LCObjsLister { int64_t delay_ms; public: - LCObjsLister(RGWRadosStore *_store, RGWBucketInfo& _bucket_info) : + LCObjsLister(rgw::sal::RGWRadosStore *_store, RGWBucketInfo& _bucket_info) : store(_store), bucket_info(_bucket_info), target(store->getRados(), bucket_info), list_op(&target) { list_op.params.list_versions = bucket_info.versioned(); @@ -561,12 +560,12 @@ public: struct op_env { lc_op& op; - RGWRadosStore *store; + rgw::sal::RGWRadosStore *store; RGWLC *lc; RGWBucketInfo& bucket_info; LCObjsLister& ol; - op_env(lc_op& _op, RGWRadosStore *_store, RGWLC *_lc, RGWBucketInfo& _bucket_info, + op_env(lc_op& _op, rgw::sal::RGWRadosStore *_store, RGWLC *_lc, RGWBucketInfo& _bucket_info, LCObjsLister& _ol) : op(_op), store(_store), lc(_lc), bucket_info(_bucket_info), ol(_ol) {} }; @@ -577,7 +576,7 @@ struct lc_op_ctx { op_env& env; rgw_bucket_dir_entry& o; - RGWRadosStore *store; + rgw::sal::RGWRadosStore *store; RGWBucketInfo& bucket_info; lc_op& op; LCObjsLister& ol; @@ -1394,7 +1393,7 @@ static std::string get_lc_shard_name(const rgw_bucket& bucket){ } template -static int guard_lc_modify(RGWRadosStore* store, const rgw_bucket& bucket, const string& cookie, const F& f) { +static int guard_lc_modify(rgw::sal::RGWRadosStore* store, const rgw_bucket& bucket, const string& cookie, const F& f) { CephContext *cct = store->ctx(); string shard_id = get_lc_shard_name(bucket); diff --git a/src/rgw/rgw_log.cc b/src/rgw/rgw_log.cc index bdc6d55be4e..096917cde95 100644 --- a/src/rgw/rgw_log.cc +++ b/src/rgw/rgw_log.cc @@ -339,7 +339,7 @@ int rgw_log_op(RGWRados *store, RGWREST* const rest, struct req_state *s, } else { bucket_id = s->bucket.bucket_id; } - rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name, entry.bucket); + entry.bucket = rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name); if (check_utf8(entry.bucket.c_str(), entry.bucket.size()) != 0) { ldout(s->cct, 5) << "not logging op on bucket with non-utf8 name" << dendl; diff --git a/src/rgw/rgw_metadata.cc b/src/rgw/rgw_metadata.cc index 2f4b9f9fd4c..fb5f12cc578 100644 --- a/src/rgw/rgw_metadata.cc +++ b/src/rgw/rgw_metadata.cc @@ -25,8 +25,6 @@ #include -using namespace rgw::sal; - #define dout_subsys ceph_subsys_rgw const std::string RGWMetadataLogHistory::oid = "meta.history"; diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc index f72e46fe0e1..bc34151cd6c 100644 --- a/src/rgw/rgw_op.cc +++ b/src/rgw/rgw_op.cc @@ -204,11 +204,18 @@ static int get_user_policy_from_attr(CephContext * const cct, return 0; } -static int get_bucket_instance_policy_from_attr(CephContext *cct, - RGWUserCtl *user_ctl, - RGWBucketInfo& bucket_info, - map& bucket_attrs, - RGWAccessControlPolicy *policy) +/** + * Get the AccessControlPolicy for an object off of disk. + * policy: must point to a valid RGWACL, and will be filled upon return. + * bucket: name of the bucket containing the object. + * object: name of the object to get the ACL for. + * Returns: 0 on success, -ERR# otherwise. + */ +int rgw_op_get_bucket_policy_from_attr(CephContext *cct, + RGWUserCtl *user_ctl, + RGWBucketInfo& bucket_info, + map& bucket_attrs, + RGWAccessControlPolicy *policy) { map::iterator aiter = bucket_attrs.find(RGW_ATTR_ACL); @@ -275,22 +282,6 @@ static int get_obj_policy_from_attr(CephContext *cct, } -/** - * Get the AccessControlPolicy for an object off of disk. - * policy: must point to a valid RGWACL, and will be filled upon return. - * bucket: name of the bucket containing the object. - * object: name of the object to get the ACL for. - * Returns: 0 on success, -ERR# otherwise. - */ -int rgw_op_get_bucket_policy_from_attr(CephContext *cct, - RGWUserCtl *user_ctl, - RGWBucketInfo& bucket_info, - map& bucket_attrs, - RGWAccessControlPolicy *policy) -{ - return get_bucket_instance_policy_from_attr(cct, user_ctl, bucket_info, bucket_attrs, policy); -} - static boost::optional get_iam_policy_from_attr(CephContext* cct, rgw::sal::RGWRadosStore* store, map& attrs, @@ -621,7 +612,7 @@ int rgw_build_bucket_policies(rgw::sal::RGWRadosStore* store, struct req_state* if (ret < 0) { if (ret != -ENOENT) { string bucket_log; - rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name, bucket_log); + bucket_log = rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name); ldpp_dout(s, 0) << "NOTICE: couldn't get bucket from bucket_name (name=" << bucket_log << ")" << dendl; return ret; @@ -2346,7 +2337,7 @@ void RGWListBuckets::execute() decltype(policies_stats)::mapped_type()); } - std::map& m = buckets.get_buckets(); + std::map& m = buckets.get_buckets(); for (const auto& kv : m) { const auto& bucket = kv.second; @@ -2373,7 +2364,7 @@ void RGWListBuckets::execute() } if (!m.empty()) { - map::reverse_iterator riter = m.rbegin(); + map::reverse_iterator riter = m.rbegin(); marker = riter->first; handle_listing_chunk(std::move(buckets)); @@ -2486,7 +2477,7 @@ void RGWStatAccount::execute() decltype(policies_stats)::mapped_type()); } - std::map& m = buckets.get_buckets(); + std::map& m = buckets.get_buckets(); for (const auto& kv : m) { const auto& bucket = kv.second; @@ -3057,10 +3048,10 @@ void RGWCreateBucket::execute() buffer::list aclbl; buffer::list corsbl; bool existed; - string bucket_name; - rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name, bucket_name); + string bucket_name = rgw_make_bucket_entry_name(s->bucket_tenant, s->bucket_name); rgw_raw_obj obj(store->svc()->zone->get_zone_params().domain_root, bucket_name); obj_version objv, *pobjv = NULL; + rgw::sal::RGWRadosUser user(store, *s->user); op_ret = get_params(); if (op_ret < 0) @@ -3099,15 +3090,20 @@ void RGWCreateBucket::execute() /* we need to make sure we read bucket info, it's not read before for this * specific request */ - op_ret = store->getRados()->get_bucket_info(store->svc(), s->bucket_tenant, s->bucket_name, - s->bucket_info, nullptr, s->yield, &s->bucket_attrs); + s->bucket.tenant = s->bucket_tenant; + s->bucket.name = s->bucket_name; + rgw::sal::RGWBucket* bucket = NULL; + op_ret = store->get_bucket(user, s->bucket, &bucket); if (op_ret < 0 && op_ret != -ENOENT) return; s->bucket_exists = (op_ret != -ENOENT); s->bucket_owner.set_id(s->user->user_id); - s->bucket_owner.set_name(s->user->display_name); + s->bucket_owner.set_name(user.get_display_name()); if (s->bucket_exists) { + s->bucket_info = bucket->get_info(); + s->bucket_attrs = bucket->get_attrs(); + delete bucket; int r = rgw_op_get_bucket_policy_from_attr(s->cct, store->ctl()->user, s->bucket_info, s->bucket_attrs, &old_policy); if (r >= 0) { diff --git a/src/rgw/rgw_op.h b/src/rgw/rgw_op.h index 38b2800118c..4481c7bccba 100644 --- a/src/rgw/rgw_op.h +++ b/src/rgw/rgw_op.h @@ -781,7 +781,7 @@ public: class RGWListBucket : public RGWOp { protected: - rgw::sal::RGWSalBucket* bucket; + rgw::sal::RGWBucket* bucket; string prefix; rgw_obj_key marker; rgw_obj_key next_marker; @@ -944,7 +944,7 @@ public: class RGWStatBucket : public RGWOp { protected: - rgw::sal::RGWSalBucket* bucket; + rgw::sal::RGWBucket* bucket; public: RGWStatBucket() : bucket(nullptr) {} diff --git a/src/rgw/rgw_rest_s3.cc b/src/rgw/rgw_rest_s3.cc index e9dca22ae8b..0faa7d05d98 100644 --- a/src/rgw/rgw_rest_s3.cc +++ b/src/rgw/rgw_rest_s3.cc @@ -75,7 +75,7 @@ void list_all_buckets_end(struct req_state *s) s->formatter->close_section(); } -void dump_bucket(struct req_state *s, rgw::sal::RGWSalBucket& obj) +void dump_bucket(struct req_state *s, rgw::sal::RGWBucket& obj) { s->formatter->open_object_section("Bucket"); s->formatter->dump_string("Name", obj.get_name()); @@ -624,11 +624,11 @@ void RGWListBuckets_ObjStore_S3::send_response_data(rgw::sal::RGWBucketList& buc if (!sent_data) return; - map& m = buckets.get_buckets(); - map::iterator iter; + map& m = buckets.get_buckets(); + map::iterator iter; for (iter = m.begin(); iter != m.end(); ++iter) { - rgw::sal::RGWSalBucket* obj = iter->second; + rgw::sal::RGWBucket* obj = iter->second; dump_bucket(s, *obj); } rgw_flush_formatter(s, s->formatter); @@ -1483,7 +1483,7 @@ void RGWGetBucketWebsite_ObjStore_S3::send_response() rgw_flush_formatter_and_reset(s, s->formatter); } -static void dump_bucket_metadata(struct req_state *s, rgw::sal::RGWSalBucket* bucket) +static void dump_bucket_metadata(struct req_state *s, rgw::sal::RGWBucket* bucket) { dump_header(s, "X-RGW-Object-Count", static_cast(bucket->get_count())); dump_header(s, "X-RGW-Bytes-Used", static_cast(bucket->get_size())); diff --git a/src/rgw/rgw_rest_swift.cc b/src/rgw/rgw_rest_swift.cc index 41c904fd9cd..db3b3ff5448 100644 --- a/src/rgw/rgw_rest_swift.cc +++ b/src/rgw/rgw_rest_swift.cc @@ -213,7 +213,7 @@ void RGWListBuckets_ObjStore_SWIFT::send_response_data(rgw::sal::RGWBucketList& * in applying the filter earlier as we really need to go through all * entries regardless of it (the headers like X-Account-Container-Count * aren't affected by specifying prefix). */ - const std::map& m = buckets.get_buckets(); + const std::map& m = buckets.get_buckets(); for (auto iter = m.lower_bound(prefix); iter != m.end() && boost::algorithm::starts_with(iter->first, prefix); ++iter) { @@ -221,7 +221,7 @@ void RGWListBuckets_ObjStore_SWIFT::send_response_data(rgw::sal::RGWBucketList& } } -void RGWListBuckets_ObjStore_SWIFT::dump_bucket_entry(const rgw::sal::RGWSalBucket& obj) +void RGWListBuckets_ObjStore_SWIFT::dump_bucket_entry(const rgw::sal::RGWBucket& obj) { s->formatter->open_object_section("container"); s->formatter->dump_string("name", obj.get_name()); @@ -248,7 +248,7 @@ void RGWListBuckets_ObjStore_SWIFT::send_response_data_reversed(rgw::sal::RGWBuc * in applying the filter earlier as we really need to go through all * entries regardless of it (the headers like X-Account-Container-Count * aren't affected by specifying prefix). */ - std::map& m = buckets.get_buckets(); + std::map& m = buckets.get_buckets(); auto iter = m.rbegin(); for (/* initialized above */; @@ -340,7 +340,7 @@ int RGWListBucket_ObjStore_SWIFT::get_params() } static void dump_container_metadata(struct req_state *, - const rgw::sal::RGWSalBucket*, + const rgw::sal::RGWBucket*, const RGWQuotaInfo&, const RGWBucketWebsiteConf&); @@ -450,7 +450,7 @@ next: } // RGWListBucket_ObjStore_SWIFT::send_response static void dump_container_metadata(struct req_state *s, - const rgw::sal::RGWSalBucket* bucket, + const rgw::sal::RGWBucket* bucket, const RGWQuotaInfo& quota, const RGWBucketWebsiteConf& ws_conf) { diff --git a/src/rgw/rgw_rest_swift.h b/src/rgw/rgw_rest_swift.h index 41bff74e85f..0066ef87408 100644 --- a/src/rgw/rgw_rest_swift.h +++ b/src/rgw/rgw_rest_swift.h @@ -57,7 +57,7 @@ public: void send_response_begin(bool has_buckets) override; void send_response_data(rgw::sal::RGWBucketList& buckets) override; void send_response_data_reversed(rgw::sal::RGWBucketList& buckets); - void dump_bucket_entry(const rgw::sal::RGWSalBucket& obj); + void dump_bucket_entry(const rgw::sal::RGWBucket& obj); void send_response_end() override; bool should_get_stats() override { return need_stats; } diff --git a/src/rgw/rgw_sal.cc b/src/rgw/rgw_sal.cc index df40fdf7254..1de0642c852 100644 --- a/src/rgw/rgw_sal.cc +++ b/src/rgw/rgw_sal.cc @@ -58,12 +58,17 @@ RGWBucketList::~RGWBucketList() buckets.clear(); } -RGWSalBucket* RGWRadosUser::add_bucket(rgw_bucket& bucket, +RGWBucket* RGWRadosUser::add_bucket(rgw_bucket& bucket, ceph::real_time creation_time) { return NULL; } +std::string& RGWRadosUser::get_display_name() +{ + return info.display_name; +} + RGWObject *RGWRadosBucket::create_object(const rgw_obj_key &key) { if (!object) { @@ -79,10 +84,9 @@ int RGWRadosBucket::remove_bucket(bool delete_children, optional_yield y) map stats; std::vector objs; map common_prefixes; - RGWBucketInfo info; string bucket_ver, master_ver; - ret = get_bucket_info(info, y); + ret = get_bucket_info(y); if (ret < 0) return ret; @@ -151,10 +155,10 @@ int RGWRadosBucket::remove_bucket(bool delete_children, optional_yield y) return ret; } -int RGWRadosBucket::get_bucket_info(RGWBucketInfo &info, optional_yield y) +int RGWRadosBucket::get_bucket_info(optional_yield y) { return store->getRados()->get_bucket_info(store->svc(), ent.bucket.tenant, ent.bucket.name, info, - NULL, y); + NULL, y, &attrs); } int RGWRadosBucket::get_bucket_stats(RGWBucketInfo& bucket_info, int shard_id, @@ -165,9 +169,14 @@ int RGWRadosBucket::get_bucket_stats(RGWBucketInfo& bucket_info, int shard_id, return store->getRados()->get_bucket_stats(bucket_info, shard_id, bucket_ver, master_ver, stats, max_marker, syncstopped); } -int RGWRadosBucket::sync_user_stats(RGWBucketInfo& bucket_info) +int RGWRadosBucket::read_bucket_stats(optional_yield y) { - return store->ctl()->bucket->sync_user_stats(user.user, bucket_info, &ent); + return store->ctl()->bucket->read_bucket_stats(ent.bucket, &ent, y); +} + +int RGWRadosBucket::sync_user_stats() +{ + return store->ctl()->bucket->sync_user_stats(user.user, info, &ent); } int RGWRadosBucket::update_container_stats(void) @@ -194,14 +203,53 @@ int RGWRadosBucket::update_container_stats(void) return 0; } -int RGWRadosBucket::set_acl(RGWAccessControlPolicy &acl, RGWBucketInfo& bucket_info, optional_yield y) +int RGWRadosBucket::check_bucket_shards(void) +{ + return store->getRados()->check_bucket_shards(info, ent.bucket, get_count()); +} + +int RGWRadosBucket::link(RGWUser* new_user, optional_yield y) +{ + RGWBucketEntryPoint ep; + ep.bucket = ent.bucket; + ep.owner = new_user->get_user(); + ep.creation_time = get_creation_time(); + ep.linked = true; + map ep_attrs; + rgw_ep_info ep_data{ep, ep_attrs}; + + return store->ctl()->bucket->link_bucket(new_user->get_user(), info.bucket, + ceph::real_time(), y, true, &ep_data); +} + +int RGWRadosBucket::unlink(RGWUser* new_user, optional_yield y) +{ + return -1; +} + +int RGWRadosBucket::chown(RGWUser* new_user, RGWUser* old_user, optional_yield y) +{ + string obj_marker; + + return store->ctl()->bucket->chown(store, info, new_user->get_user(), + old_user->get_display_name(), obj_marker, y); +} + +bool RGWRadosBucket::is_owner(RGWUser* user) +{ + get_bucket_info(null_yield); + + return (info.owner.compare(user->get_user()) == 0); +} + +int RGWRadosBucket::set_acl(RGWAccessControlPolicy &acl, optional_yield y) { bufferlist aclbl; acls = acl; acl.encode(aclbl); - return store->ctl()->bucket->set_acl(acl.get_owner(), ent.bucket, bucket_info, aclbl, null_yield); + return store->ctl()->bucket->set_acl(acl.get_owner(), ent.bucket, info, aclbl, null_yield); } RGWUser *RGWRadosStore::get_user(const rgw_user &u) @@ -209,7 +257,7 @@ RGWUser *RGWRadosStore::get_user(const rgw_user &u) return new RGWRadosUser(this, u); } -//RGWSalBucket *RGWRadosStore::create_bucket(RGWUser &u, const rgw_bucket &b) +//RGWBucket *RGWRadosStore::create_bucket(RGWUser &u, const rgw_bucket &b) //{ //if (!bucket) { //bucket = new RGWRadosBucket(this, u, b); @@ -223,6 +271,27 @@ void RGWRadosStore::finalize(void) { rados->finalize(); } +int RGWRadosStore::get_bucket(RGWUser& u, const rgw_bucket& b, RGWBucket** bucket) +{ + int ret; + RGWBucket* bp; + + *bucket = nullptr; + + bp = new RGWRadosBucket(this, u, b); + if (!bp) { + return -ENOMEM; + } + ret = bp->get_bucket_info(null_yield); + if (ret < 0) { + delete bp; + return ret; + } + + *bucket = bp; + return 0; +} + } // namespace rgw::sal rgw::sal::RGWRadosStore *RGWStoreManager::init_storage_provider(CephContext *cct, bool use_gc_thread, bool use_lc_thread, bool quota_threads, bool run_sync_thread, bool run_reshard_thread, bool use_cache) diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h index bd803b741f2..7d8523fb503 100644 --- a/src/rgw/rgw_sal.h +++ b/src/rgw/rgw_sal.h @@ -23,20 +23,20 @@ namespace rgw { namespace sal { #define RGW_SAL_VERSION 1 class RGWUser; -class RGWSalBucket; +class RGWBucket; class RGWObject; class RGWBucketList; -typedef std::map RGWAttrs; +typedef std::map RGWAttrs; class RGWStore { public: RGWStore() {} virtual ~RGWStore() = default; - virtual RGWUser* get_user(const rgw_user &u) = 0; - virtual RGWSalBucket* get_bucket(RGWUser &u, const rgw_bucket &b) = 0; - //virtual RGWSalBucket* create_bucket(RGWUser &u, const rgw_bucket &b) = 0; + virtual RGWUser* get_user(const rgw_user& u) = 0; + virtual int get_bucket(RGWUser& u, const rgw_bucket& b, RGWBucket** bucket) = 0; + //virtual RGWBucket* create_bucket(RGWUser& u, const rgw_bucket& b) = 0; virtual RGWBucketList* list_buckets(void) = 0; virtual void finalize(void)=0; @@ -47,63 +47,82 @@ class RGWStore { class RGWUser { protected: rgw_user user; + RGWUserInfo info; public: RGWUser() : user() {} - RGWUser(const rgw_user &_u) : user(_u) {} + RGWUser(const rgw_user& _u) : user(_u) {} + RGWUser(const RGWUserInfo& _i) : user(_i.user_id), info(_i) {} virtual ~RGWUser() = default; virtual int list_buckets(const string& marker, const string& end_marker, - uint64_t max, bool need_stats, RGWBucketList &buckets) = 0; - virtual RGWSalBucket* add_bucket(rgw_bucket& bucket, ceph::real_time creation_time) = 0; - friend class RGWSalBucket; + uint64_t max, bool need_stats, RGWBucketList& buckets) = 0; + virtual RGWBucket* add_bucket(rgw_bucket& bucket, ceph::real_time creation_time) = 0; + friend class RGWBucket; + virtual std::string& get_display_name() = 0; std::string& get_tenant() { return user.tenant; } + + /* xxx dang temporary; will be removed when User is complete */ rgw_user& get_user() { return user; } }; -class RGWSalBucket { +class RGWBucket { protected: RGWBucketEnt ent; + RGWBucketInfo info; + RGWUser *owner; + RGWAttrs attrs; public: - RGWSalBucket() : ent() {} - RGWSalBucket(const rgw_bucket &_b) { ent.bucket = _b; } - RGWSalBucket(const RGWBucketEnt &_e) : ent(_e) {} - virtual ~RGWSalBucket() = default; + RGWBucket() : ent(), owner(nullptr), attrs() {} + RGWBucket(const rgw_bucket& _b) : ent(), attrs() { ent.bucket = _b; } + RGWBucket(const RGWBucketEnt& _e) : ent(_e), attrs() {} + virtual ~RGWBucket() = default; - virtual RGWObject* get_object(const rgw_obj_key &key) = 0; + virtual RGWObject* get_object(const rgw_obj_key& key) = 0; virtual RGWBucketList* list(void) = 0; - virtual RGWObject* create_object(const rgw_obj_key &key /* Attributes */) = 0; - virtual RGWAttrs& get_attrs(void) = 0; - virtual int set_attrs(RGWAttrs &attrs) = 0; + virtual RGWObject* create_object(const rgw_obj_key& key /* Attributes */) = 0; + virtual RGWAttrs& get_attrs(void) { return attrs; } + virtual int set_attrs(RGWAttrs& a) { attrs = a; return 0; } virtual int remove_bucket(bool delete_children, optional_yield y) = 0; virtual RGWAccessControlPolicy& get_acl(void) = 0; - virtual int set_acl(RGWAccessControlPolicy &acl, RGWBucketInfo& bucket_info, optional_yield y) = 0; - virtual int get_bucket_info(RGWBucketInfo &info, optional_yield y) = 0; + virtual int set_acl(RGWAccessControlPolicy& acl, optional_yield y) = 0; + virtual int get_bucket_info(optional_yield y) = 0; virtual int get_bucket_stats(RGWBucketInfo& bucket_info, int shard_id, std::string *bucket_ver, std::string *master_ver, std::map& stats, std::string *max_marker = nullptr, bool *syncstopped = nullptr) = 0; - virtual int sync_user_stats(RGWBucketInfo &info) = 0; + virtual int read_bucket_stats(optional_yield y) = 0; + virtual int sync_user_stats() = 0; virtual int update_container_stats(void) = 0; - - std::string get_name() const { return ent.bucket.name; } - std::string get_tenant() const { return ent.bucket.tenant; } - std::string get_marker() const { return ent.bucket.marker; } - std::string get_bucket_id() const { return ent.bucket.bucket_id; } + virtual int check_bucket_shards(void) = 0; + virtual int link(RGWUser* new_user, optional_yield y) = 0; + virtual int unlink(RGWUser* new_user, optional_yield y) = 0; + virtual int chown(RGWUser* new_user, RGWUser* old_user, optional_yield y) = 0; + virtual bool is_owner(RGWUser *user) = 0; + + const std::string& get_name() const { return ent.bucket.name; } + const std::string& get_tenant() const { return ent.bucket.tenant; } + const std::string& get_marker() const { return ent.bucket.marker; } + const std::string& get_bucket_id() const { return ent.bucket.bucket_id; } size_t get_size() const { return ent.size; } size_t get_size_rounded() const { return ent.size_rounded; } uint64_t get_count() const { return ent.count; } rgw_placement_rule get_placement_rule() const { return ent.placement_rule; } ceph::real_time& get_creation_time() { return ent.creation_time; }; + void convert(cls_user_bucket_entry *b) const { + ent.convert(b); + } + /* dang - This is temporary, until the API is completed */ rgw_bucket& get_bi() { return ent.bucket; } + RGWBucketInfo& get_info() { return info; } - friend inline ostream& operator<<(ostream& out, const RGWSalBucket &b) { + friend inline ostream& operator<<(ostream& out, const RGWBucket& b) { out << b.ent.bucket; return out; } @@ -111,11 +130,11 @@ class RGWSalBucket { friend class RGWBucketList; protected: - virtual void set_ent(RGWBucketEnt &_ent) { ent = _ent; } + virtual void set_ent(RGWBucketEnt& _ent) { ent = _ent; } }; class RGWBucketList { - std::map buckets; + std::map buckets; bool truncated; public: @@ -124,13 +143,13 @@ public: RGWBucketList& operator=(const RGWBucketList&) = default; ~RGWBucketList(); - map& get_buckets() { return buckets; } - bool is_truncated(void) { return truncated; } + map& get_buckets() { return buckets; } + bool is_truncated(void) const { return truncated; } void set_truncated(bool trunc) { truncated = trunc; } - void add(RGWSalBucket* bucket) { + void add(RGWBucket* bucket) { buckets[bucket->ent.bucket.name] = bucket; } - size_t count() { return buckets.size(); } + size_t count() const { return buckets.size(); } }; @@ -140,16 +159,16 @@ class RGWObject { public: RGWObject() : key() {} - RGWObject(const rgw_obj_key &_k) : key(_k) {} + RGWObject(const rgw_obj_key& _k) : key(_k) {} virtual ~RGWObject() = default; - virtual int read(off_t offset, off_t length, std::iostream &stream) = 0; - virtual int write(off_t offset, off_t length, std::iostream &stream) = 0; + virtual int read(off_t offset, off_t length, std::iostream& stream) = 0; + virtual int write(off_t offset, off_t length, std::iostream& stream) = 0; virtual RGWAttrs& get_attrs(void) = 0; - virtual int set_attrs(RGWAttrs &attrs) = 0; + virtual int set_attrs(RGWAttrs& attrs) = 0; virtual int delete_object(void) = 0; virtual RGWAccessControlPolicy& get_acl(void) = 0; - virtual int set_acl(const RGWAccessControlPolicy &acl) = 0; + virtual int set_acl(const RGWAccessControlPolicy& acl) = 0; }; @@ -160,12 +179,14 @@ class RGWRadosUser : public RGWUser { RGWRadosStore *store; public: - RGWRadosUser(RGWRadosStore *_st, const rgw_user &_u) : RGWUser(_u), store(_st) { } + RGWRadosUser(RGWRadosStore *_st, const rgw_user& _u) : RGWUser(_u), store(_st) { } + RGWRadosUser(RGWRadosStore *_st, const RGWUserInfo& _i) : RGWUser(_i), store(_st) { } RGWRadosUser() {} int list_buckets(const string& marker, const string& end_marker, - uint64_t max, bool need_stats, RGWBucketList &buckets); - RGWSalBucket* add_bucket(rgw_bucket& bucket, ceph::real_time creation_time); + uint64_t max, bool need_stats, RGWBucketList& buckets); + RGWBucket* add_bucket(rgw_bucket& bucket, ceph::real_time creation_time); + virtual std::string& get_display_name() override; friend class RGWRadosBucket; }; @@ -182,27 +203,26 @@ class RGWRadosObject : public RGWObject { acls() { } - RGWRadosObject(RGWRadosStore *_st, const rgw_obj_key &_k) + RGWRadosObject(RGWRadosStore *_st, const rgw_obj_key& _k) : RGWObject(_k), store(_st), attrs(), acls() { } - int read(off_t offset, off_t length, std::iostream &stream) { return length; } - int write(off_t offset, off_t length, std::iostream &stream) { return length; } + int read(off_t offset, off_t length, std::iostream& stream) { return length; } + int write(off_t offset, off_t length, std::iostream& stream) { return length; } RGWAttrs& get_attrs(void) { return attrs; } - int set_attrs(RGWAttrs &a) { attrs = a; return 0; } + int set_attrs(RGWAttrs& a) { attrs = a; return 0; } int delete_object(void) { return 0; } RGWAccessControlPolicy& get_acl(void) { return acls; } - int set_acl(const RGWAccessControlPolicy &acl) { acls = acl; return 0; } + int set_acl(const RGWAccessControlPolicy& acl) { acls = acl; return 0; } }; -class RGWRadosBucket : public RGWSalBucket { +class RGWRadosBucket : public RGWBucket { private: RGWRadosStore *store; RGWRadosObject *object; - RGWAttrs attrs; RGWAccessControlPolicy acls; RGWRadosUser user; @@ -210,68 +230,66 @@ class RGWRadosBucket : public RGWSalBucket { RGWRadosBucket() : store(nullptr), object(nullptr), - attrs(), acls(), user() { } - RGWRadosBucket(RGWRadosStore *_st, RGWUser &_u, const rgw_bucket &_b) - : RGWSalBucket(_b), + RGWRadosBucket(RGWRadosStore *_st, RGWUser& _u, const rgw_bucket& _b) + : RGWBucket(_b), store(_st), object(nullptr), - attrs(), acls(), user(dynamic_cast(_u)) { } - RGWRadosBucket(RGWRadosStore *_st, RGWUser &_u, const RGWBucketEnt &_e) - : RGWSalBucket(_e), + RGWRadosBucket(RGWRadosStore *_st, RGWUser& _u, const RGWBucketEnt& _e) + : RGWBucket(_e), store(_st), object(nullptr), - attrs(), acls(), user(dynamic_cast(_u)) { } ~RGWRadosBucket() { } - RGWObject* get_object(const rgw_obj_key &key) { return object; } + RGWObject* get_object(const rgw_obj_key& key) { return object; } RGWBucketList* list(void) { return new RGWBucketList(); } - RGWObject* create_object(const rgw_obj_key &key /* Attributes */) override; - RGWAttrs& get_attrs(void) { return attrs; } - int set_attrs(RGWAttrs &a) { attrs = a; return 0; } + RGWObject* create_object(const rgw_obj_key& key /* Attributes */) override; virtual int remove_bucket(bool delete_children, optional_yield y) override; RGWAccessControlPolicy& get_acl(void) { return acls; } - virtual int set_acl(RGWAccessControlPolicy &acl, RGWBucketInfo& bucket_info, optional_yield y) override; - virtual int get_bucket_info(RGWBucketInfo &info, optional_yield y) override; + virtual int set_acl(RGWAccessControlPolicy& acl, optional_yield y) override; + virtual int get_bucket_info(optional_yield y) override; virtual int get_bucket_stats(RGWBucketInfo& bucket_info, int shard_id, std::string *bucket_ver, std::string *master_ver, std::map& stats, std::string *max_marker = nullptr, bool *syncstopped = nullptr) override; - virtual int sync_user_stats(RGWBucketInfo &info) override; + virtual int read_bucket_stats(optional_yield y) override; + virtual int sync_user_stats() override; virtual int update_container_stats(void) override; + virtual int check_bucket_shards(void) override; + virtual int link(RGWUser* new_user, optional_yield y) override; + virtual int unlink(RGWUser* new_user, optional_yield y) override; + virtual int chown(RGWUser* new_user, RGWUser* old_user, optional_yield y) override; + virtual bool is_owner(RGWUser *user) override; }; class RGWRadosStore : public RGWStore { private: RGWRados *rados; - RGWRadosBucket *bucket; RGWUserCtl *user_ctl; public: RGWRadosStore() - : rados(nullptr), - bucket(nullptr) { + : rados(nullptr) { } ~RGWRadosStore() { - delete bucket; delete rados; } - virtual RGWUser* get_user(const rgw_user &u); - virtual RGWSalBucket* get_bucket(RGWUser &u, const rgw_bucket &b) { return bucket; } - //virtual RGWSalBucket* create_bucket(RGWUser &u, const rgw_bucket &b); + virtual RGWUser* get_user(const rgw_user& u); + virtual int get_bucket(RGWUser& u, const rgw_bucket& b, RGWBucket** bucket) override; + //virtual RGWBucket* create_bucket(RGWUser& u, const rgw_bucket& b); virtual RGWBucketList* list_buckets(void) { return new RGWBucketList(); } void setRados(RGWRados * st) { rados = st; } diff --git a/src/rgw/rgw_user.cc b/src/rgw/rgw_user.cc index 6876d2320c5..48b47ed1e9c 100644 --- a/src/rgw/rgw_user.cc +++ b/src/rgw/rgw_user.cc @@ -64,26 +64,25 @@ int rgw_user_sync_all_stats(rgw::sal::RGWRadosStore *store, const rgw_user& user ldout(cct, 0) << "failed to read user buckets: ret=" << ret << dendl; return ret; } - map& buckets = user_buckets.get_buckets(); - for (map::iterator i = buckets.begin(); + map& buckets = user_buckets.get_buckets(); + for (map::iterator i = buckets.begin(); i != buckets.end(); ++i) { marker = i->first; - rgw::sal::RGWSalBucket* bucket = i->second; - RGWBucketInfo bucket_info; + rgw::sal::RGWBucket* bucket = i->second; - ret = bucket->get_bucket_info(bucket_info, null_yield); + ret = bucket->get_bucket_info(null_yield); if (ret < 0) { ldout(cct, 0) << "ERROR: could not read bucket info: bucket=" << bucket << " ret=" << ret << dendl; continue; } - ret = bucket->sync_user_stats(bucket_info); + ret = bucket->sync_user_stats(); if (ret < 0) { ldout(cct, 0) << "ERROR: could not sync bucket stats: ret=" << ret << dendl; return ret; } - ret = store->getRados()->check_bucket_shards(bucket_info, bucket_info.bucket, bucket->get_count()); + ret = bucket->check_bucket_shards(); if (ret < 0) { ldout(cct, 0) << "ERROR in check_bucket_shards: " << cpp_strerror(-ret)<< dendl; } @@ -115,19 +114,18 @@ int rgw_user_get_all_buckets_stats(rgw::sal::RGWRadosStore *store, const rgw_use ldout(cct, 0) << "failed to read user buckets: ret=" << ret << dendl; return ret; } - std::map& m = buckets.get_buckets(); + std::map& m = buckets.get_buckets(); for (const auto& i : m) { marker = i.first; - rgw::sal::RGWSalBucket* bucket_ent = i.second; - RGWBucketEnt stats; - ret = store->ctl()->bucket->read_bucket_stats(bucket_ent->get_bi(), &stats, null_yield); + rgw::sal::RGWBucket* bucket_ent = i.second; + ret = bucket_ent->read_bucket_stats(null_yield); if (ret < 0) { ldout(cct, 0) << "ERROR: could not get bucket stats: ret=" << ret << dendl; return ret; } cls_user_bucket_entry entry; - stats.convert(&entry); + bucket_ent->convert(&entry); buckets_usage_map.emplace(bucket_ent->get_name(), entry); } done = (buckets.count() < max_entries); @@ -1602,18 +1600,17 @@ int RGWUser::execute_rename(RGWUserAdminOpState& op_state, std::string *err_msg) } } - rgw::sal::RGWUser* old_user = new rgw::sal::RGWRadosUser(store, op_state.get_user_id()); - RGWUserInfo old_user_info = op_state.get_user_info(); - rgw::sal::RGWUser* new_user = new rgw::sal::RGWRadosUser(store, op_state.get_new_uid()); - if (old_user->get_tenant() != new_user->get_tenant()) { + rgw::sal::RGWRadosUser old_user(store, op_state.get_user_info()); + rgw::sal::RGWRadosUser new_user(store, op_state.get_new_uid()); + if (old_user.get_tenant() != new_user.get_tenant()) { set_err_msg(err_msg, "users have to be under the same tenant namespace " - + old_user->get_tenant() + " != " + new_user->get_tenant()); + + old_user.get_tenant() + " != " + new_user.get_tenant()); return -EINVAL; } // create a stub user and write only the uid index and buckets object RGWUserInfo stub_user_info; - stub_user_info.user_id = new_user->get_user(); + stub_user_info.user_id = new_user.get_user(); RGWObjVersionTracker objv; const bool exclusive = !op_state.get_overwrite_new_user(); // overwrite if requested @@ -1632,60 +1629,47 @@ int RGWUser::execute_rename(RGWUserAdminOpState& op_state, std::string *err_msg) } RGWAccessControlPolicy policy_instance; - policy_instance.create_default(new_user->get_user(), old_user_info.display_name); + policy_instance.create_default(new_user.get_user(), old_user.get_display_name()); //unlink and link buckets to new user string marker; - string obj_marker; CephContext *cct = store->ctx(); size_t max_buckets = cct->_conf->rgw_list_buckets_max_chunk; - RGWBucketCtl* bucket_ctl = store->ctl()->bucket; rgw::sal::RGWBucketList buckets; do { - ret = old_user->list_buckets(marker, "", max_buckets, false, buckets); + ret = old_user.list_buckets(marker, "", max_buckets, false, buckets); if (ret < 0) { set_err_msg(err_msg, "unable to list user buckets"); return ret; } - map& m = buckets.get_buckets(); - std::map::iterator it; + map& m = buckets.get_buckets(); + std::map::iterator it; for (it = m.begin(); it != m.end(); ++it) { - rgw::sal::RGWSalBucket* bucket = it->second; + rgw::sal::RGWBucket* bucket = it->second; marker = it->first; - RGWBucketInfo bucket_info; - ret = bucket->get_bucket_info(bucket_info, null_yield); + ret = bucket->get_bucket_info(null_yield); if (ret < 0) { set_err_msg(err_msg, "failed to fetch bucket info for bucket=" + bucket->get_name()); return ret; } - ret = bucket->set_acl(policy_instance, bucket_info, null_yield); + ret = bucket->set_acl(policy_instance, null_yield); if (ret < 0) { set_err_msg(err_msg, "failed to set acl on bucket " + bucket->get_name()); return ret; } - RGWBucketEntryPoint ep; - ep.bucket = bucket_info.bucket; - ep.owner = new_user->get_user(); - ep.creation_time = bucket_info.creation_time; - ep.linked = true; - map ep_attrs; - rgw_ep_info ep_data{ep, ep_attrs}; - - ret = bucket_ctl->link_bucket(new_user->get_user(), bucket_info.bucket, - ceph::real_time(), null_yield, true, &ep_data); + ret = bucket->link(&new_user, null_yield); if (ret < 0) { set_err_msg(err_msg, "failed to link bucket " + bucket->get_name()); return ret; } - ret = bucket_ctl->chown(store, bucket_info, new_user->get_user(), - old_user_info.display_name, obj_marker, null_yield); + ret = bucket->chown(&new_user, &old_user, null_yield); if (ret < 0) { set_err_msg(err_msg, "failed to run bucket chown" + cpp_strerror(-ret)); return ret; @@ -1697,10 +1681,10 @@ int RGWUser::execute_rename(RGWUserAdminOpState& op_state, std::string *err_msg) // update the 'stub user' with all of the other fields and rewrite all of the // associated index objects RGWUserInfo& user_info = op_state.get_user_info(); - user_info.user_id = new_user->get_user(); + user_info.user_id = new_user.get_user(); op_state.objv = objv; - rename_swift_keys(new_user->get_user(), user_info.swift_keys); + rename_swift_keys(new_user.get_user(), user_info.swift_keys); return update(op_state, err_msg); } @@ -1898,13 +1882,13 @@ int RGWUser::execute_remove(RGWUserAdminOpState& op_state, std::string *err_msg, return ret; } - std::map& m = buckets.get_buckets(); + std::map& m = buckets.get_buckets(); if (!m.empty() && !purge_data) { set_err_msg(err_msg, "must specify purge data to remove user with buckets"); return -EEXIST; // change to code that maps to 409: conflict } - std::map::iterator it; + std::map::iterator it; for (it = m.begin(); it != m.end(); ++it) { ret = it->second->remove_bucket(true, y); if (ret < 0) { @@ -2053,12 +2037,12 @@ int RGWUser::execute_modify(RGWUserAdminOpState& op_state, std::string *err_msg) return ret; } - std::map& m = buckets.get_buckets(); - std::map::iterator iter; + std::map& m = buckets.get_buckets(); + std::map::iterator iter; vector bucket_names; for (iter = m.begin(); iter != m.end(); ++iter) { - rgw::sal::RGWSalBucket* obj = iter->second; + rgw::sal::RGWBucket* obj = iter->second; bucket_names.push_back(obj->get_bi()); marker = iter->first;