From: Casey Bodley Date: Fri, 1 Dec 2023 21:13:02 +0000 (-0500) Subject: rgw: use rgw_owner in RGWBucketEntryPoint X-Git-Tag: testing/wip-yuriw-testing-20240416.150233~10^2~143 X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=774b0bf1b5fcb9315470c3f2199caeedf1c19b05;p=ceph-ci.git rgw: use rgw_owner in RGWBucketEntryPoint Signed-off-by: Casey Bodley (cherry picked from commit 469b7e83d723021555886dc7c46d178190f59829) --- diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc index d5304fec499..8cde25fc199 100644 --- a/src/rgw/driver/rados/rgw_bucket.cc +++ b/src/rgw/driver/rados/rgw_bucket.cc @@ -1,6 +1,7 @@ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- // vim: ts=8 sw=2 smarttab ft=cpp +#include "include/function2.hpp" #include "rgw_acl_s3.h" #include "rgw_tag_s3.h" @@ -12,6 +13,8 @@ #include "services/svc_bucket.h" #include "services/svc_user.h" +#include "account.h" +#include "buckets.h" #include "rgw_reshard.h" #include "rgw_pubsub.h" @@ -983,15 +986,21 @@ int RGWBucketAdminOp::dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpS return 0; } -int RGWBucketAdminOp::unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y) +int RGWBucketAdminOp::unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, string *err) { - RGWBucket bucket; + auto radosdriver = dynamic_cast(driver); + if (!radosdriver) { + set_err_msg(err, "rados store only"); + return -ENOTSUP; + } + RGWBucket bucket; int ret = bucket.init(driver, op_state, y, dpp); if (ret < 0) return ret; - return static_cast(driver)->ctl()->bucket->unlink_bucket(op_state.get_user_id(), op_state.get_bucket()->get_info().bucket, y, dpp, true); + auto* rados = radosdriver->getRados()->get_rados_handle(); + return radosdriver->ctl()->bucket->unlink_bucket(*rados, op_state.get_user_id(), op_state.get_bucket()->get_info().bucket, y, dpp, true); } int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, string *err) @@ -1000,6 +1009,11 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s set_err_msg(err, "empty user id"); return -EINVAL; } + auto radosdriver = dynamic_cast(driver); + if (!radosdriver) { + set_err_msg(err, "rados store only"); + return -ENOTSUP; + } RGWBucket bucket; int ret = bucket.init(driver, op_state, y, dpp, err); @@ -1057,7 +1071,8 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s return -EIO; } - int r = static_cast(driver)->ctl()->bucket->unlink_bucket(owner.id, old_bucket->get_info().bucket, y, dpp, false); + auto* rados = radosdriver->getRados()->get_rados_handle(); + int r = radosdriver->ctl()->bucket->unlink_bucket(*rados, owner.id, old_bucket->get_info().bucket, y, dpp, false); if (r < 0) { set_err_msg(err, "could not unlink policy from user " + owner.id.to_str()); return r; @@ -1098,7 +1113,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s rgw::sal::Attrs ep_attrs; rgw_ep_info ep_data{ep, ep_attrs}; - r = static_cast(driver)->ctl()->bucket->link_bucket(op_state.get_user_id(), loc_bucket->get_info().bucket, loc_bucket->get_info().creation_time, y, dpp, true, &ep_data); + r = radosdriver->ctl()->bucket->link_bucket(*rados, op_state.get_user_id(), loc_bucket->get_info().bucket, loc_bucket->get_info().creation_time, y, dpp, true, &ep_data); if (r < 0) { set_err_msg(err, "failed to relink bucket"); return r; @@ -1106,7 +1121,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s if (*loc_bucket != *old_bucket) { // like RGWRados::delete_bucket -- excepting no bucket_index work. - r = static_cast(driver)->ctl()->bucket->remove_bucket_entrypoint_info( + r = radosdriver->ctl()->bucket->remove_bucket_entrypoint_info( old_bucket->get_key(), y, dpp, RGWBucketCtl::Bucket::RemoveParams() .set_objv_tracker(&ep_data.ep_objv)); @@ -1114,7 +1129,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s set_err_msg(err, "failed to unlink old bucket " + old_bucket->get_tenant() + "/" + old_bucket->get_name()); return r; } - r = static_cast(driver)->ctl()->bucket->remove_bucket_instance_info( + r = radosdriver->ctl()->bucket->remove_bucket_instance_info( old_bucket->get_key(), old_bucket->get_info(), y, dpp, RGWBucketCtl::BucketInstance::RemoveParams() @@ -1934,6 +1949,7 @@ void RGWBucketCompleteInfo::decode_json(JSONObj *obj) { class RGWBucketMetadataHandler : public RGWBucketMetadataHandlerBase { public: + librados::Rados& rados; struct Svc { RGWSI_Bucket *bucket{nullptr}; } svc; @@ -1942,7 +1958,8 @@ public: RGWBucketCtl *bucket{nullptr}; } ctl; - RGWBucketMetadataHandler() {} + explicit RGWBucketMetadataHandler(librados::Rados& rados) + : rados(rados) {} void init(RGWSI_Bucket *bucket_svc, RGWBucketCtl *bucket_ctl) override { @@ -2010,7 +2027,7 @@ public: * it immediately and don't want to invalidate our cached objv_version or the bucket obj removal * will incorrectly fail. */ - ret = ctl.bucket->unlink_bucket(be.owner, be.bucket, y, dpp, false); + ret = ctl.bucket->unlink_bucket(rados, be.owner, be.bucket, y, dpp, false); if (ret < 0) { ldpp_dout(dpp, -1) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl; } @@ -2039,17 +2056,19 @@ public: class RGWMetadataHandlerPut_Bucket : public RGWMetadataHandlerPut_SObj { RGWBucketMetadataHandler *bhandler; + librados::Rados& rados; RGWBucketEntryMetadataObject *obj; public: - RGWMetadataHandlerPut_Bucket(RGWBucketMetadataHandler *_handler, + RGWMetadataHandlerPut_Bucket(RGWBucketMetadataHandler *_handler, librados::Rados& rados, RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker, optional_yield y, - RGWMDLogSyncType type, bool from_remote_zone) : RGWMetadataHandlerPut_SObj(_handler, op, entry, _obj, objv_tracker, y, type, from_remote_zone), - bhandler(_handler) { - obj = static_cast(_obj); - } - ~RGWMetadataHandlerPut_Bucket() {} + RGWMDLogSyncType type, bool from_remote_zone) + : RGWMetadataHandlerPut_SObj(_handler, op, entry, _obj, objv_tracker, y, type, from_remote_zone), + bhandler(_handler), + rados(rados), + obj(static_cast(_obj)) + {} void encode_obj(bufferlist *bl) override { obj->get_ep().encode(*bl); @@ -2066,7 +2085,8 @@ int RGWBucketMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op, string& const DoutPrefixProvider *dpp, RGWMDLogSyncType type, bool from_remote_zone) { - RGWMetadataHandlerPut_Bucket put_op(this, op, entry, obj, objv_tracker, y, type, from_remote_zone); + RGWMetadataHandlerPut_Bucket put_op(this, rados, op, entry, obj, objv_tracker, + y, type, from_remote_zone); return do_put_operate(&put_op, dpp); } @@ -2102,9 +2122,9 @@ int RGWMetadataHandlerPut_Bucket::put_post(const DoutPrefixProvider *dpp) /* link bucket */ if (be.linked) { - ret = bhandler->ctl.bucket->link_bucket(be.owner, be.bucket, be.creation_time, y, dpp, false); + ret = bhandler->ctl.bucket->link_bucket(rados, be.owner, be.bucket, be.creation_time, y, dpp, false); } else { - ret = bhandler->ctl.bucket->unlink_bucket(be.owner, be.bucket, y, dpp, false); + ret = bhandler->ctl.bucket->unlink_bucket(rados, be.owner, be.bucket, y, dpp, false); } return ret; @@ -2261,7 +2281,8 @@ WRITE_CLASS_ENCODER(archive_meta_info) class RGWArchiveBucketMetadataHandler : public RGWBucketMetadataHandler { public: - RGWArchiveBucketMetadataHandler() {} + explicit RGWArchiveBucketMetadataHandler(librados::Rados& rados) + : RGWBucketMetadataHandler(rados) {} int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y, const DoutPrefixProvider *dpp) override { @@ -2356,7 +2377,7 @@ public: /* link new bucket */ - ret = ctl.bucket->link_bucket(new_be.owner, new_be.bucket, new_be.creation_time, y, dpp, false); + ret = ctl.bucket->link_bucket(rados, new_be.owner, new_be.bucket, new_be.creation_time, y, dpp, false); if (ret < 0) { ldpp_dout(dpp, 0) << "ERROR: failed to link new bucket for bucket=" << new_be.bucket << " ret=" << ret << dendl; return ret; @@ -2364,7 +2385,7 @@ public: /* clean up old stuff */ - ret = ctl.bucket->unlink_bucket(be.owner, entry_bucket, y, dpp, false); + ret = ctl.bucket->unlink_bucket(rados, be.owner, entry_bucket, y, dpp, false); if (ret < 0) { ldpp_dout(dpp, -1) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl; } @@ -3096,7 +3117,8 @@ int RGWBucketCtl::set_bucket_instance_attrs(RGWBucketInfo& bucket_info, } -int RGWBucketCtl::link_bucket(const rgw_user& user_id, +int RGWBucketCtl::link_bucket(librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, ceph::real_time creation_time, optional_yield y, @@ -3105,13 +3127,28 @@ int RGWBucketCtl::link_bucket(const rgw_user& user_id, rgw_ep_info *pinfo) { return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) { - return do_link_bucket(ctx, user_id, bucket, creation_time, + return do_link_bucket(ctx, rados, owner, bucket, creation_time, update_entrypoint, pinfo, y, dpp); }); } +static rgw_raw_obj get_owner_buckets_obj(RGWSI_User* svc_user, + RGWSI_Zone* svc_zone, + const rgw_owner& owner) +{ + return std::visit(fu2::overload( + [&] (const rgw_user& uid) { + return svc_user->get_buckets_obj(uid); + }, + [&] (const rgw_account_id& account_id) { + const RGWZoneParams& zone = svc_zone->get_zone_params(); + return rgwrados::account::get_buckets_obj(zone, account_id); + }), owner); +} + int RGWBucketCtl::do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx, - const rgw_user& user_id, + librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, ceph::real_time creation_time, bool update_entrypoint, @@ -3146,10 +3183,12 @@ int RGWBucketCtl::do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx, } } - ret = svc.user->add_bucket(dpp, user_id, bucket, creation_time, y); + const auto& buckets_obj = get_owner_buckets_obj(svc.user, svc.zone, owner); + ret = rgwrados::buckets::add(dpp, y, rados, buckets_obj, + bucket, creation_time); if (ret < 0) { - ldpp_dout(dpp, 0) << "ERROR: error adding bucket to user directory:" - << " user=" << user_id + ldpp_dout(dpp, 0) << "ERROR: error adding bucket to owner directory:" + << " owner=" << owner << " bucket=" << bucket << " err=" << cpp_strerror(-ret) << dendl; @@ -3160,7 +3199,7 @@ int RGWBucketCtl::do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx, return 0; ep.linked = true; - ep.owner = user_id; + ep.owner = owner; ep.bucket = bucket; ret = svc.bucket->store_bucket_entrypoint_info( ctx, meta_key, ep, false, real_time(), pattrs, &rot, y, dpp); @@ -3170,7 +3209,7 @@ int RGWBucketCtl::do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx, return 0; done_err: - int r = do_unlink_bucket(ctx, user_id, bucket, true, y, dpp); + int r = do_unlink_bucket(ctx, rados, owner, bucket, true, y, dpp); if (r < 0) { ldpp_dout(dpp, 0) << "ERROR: failed unlinking bucket on error cleanup: " << cpp_strerror(-r) << dendl; @@ -3178,21 +3217,25 @@ done_err: return ret; } -int RGWBucketCtl::unlink_bucket(const rgw_user& user_id, const rgw_bucket& bucket, optional_yield y, const DoutPrefixProvider *dpp, bool update_entrypoint) +int RGWBucketCtl::unlink_bucket(librados::Rados& rados, const rgw_owner& owner, + const rgw_bucket& bucket, optional_yield y, + const DoutPrefixProvider *dpp, bool update_entrypoint) { return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) { - return do_unlink_bucket(ctx, user_id, bucket, update_entrypoint, y, dpp); + return do_unlink_bucket(ctx, rados, owner, bucket, update_entrypoint, y, dpp); }); } int RGWBucketCtl::do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx, - const rgw_user& user_id, + librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, bool update_entrypoint, optional_yield y, const DoutPrefixProvider *dpp) { - int ret = svc.user->remove_bucket(dpp, user_id, bucket, y); + const auto& buckets_obj = get_owner_buckets_obj(svc.user, svc.zone, owner); + int ret = rgwrados::buckets::remove(dpp, y, rados, buckets_obj, bucket); if (ret < 0) { ldpp_dout(dpp, 0) << "ERROR: error removing bucket from directory: " << cpp_strerror(-ret)<< dendl; @@ -3214,8 +3257,8 @@ int RGWBucketCtl::do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx, if (!ep.linked) return 0; - if (ep.owner != user_id) { - ldpp_dout(dpp, 0) << "bucket entry point user mismatch, can't unlink bucket: " << ep.owner << " != " << user_id << dendl; + if (ep.owner != owner) { + ldpp_dout(dpp, 0) << "bucket entry point owner mismatch, can't unlink bucket: " << ep.owner << " != " << owner << dendl; return -EINVAL; } @@ -3305,9 +3348,9 @@ int RGWBucketCtl::bucket_imports_data(const rgw_bucket& bucket, return handler->bucket_imports_data(); } -RGWBucketMetadataHandlerBase* RGWBucketMetaHandlerAllocator::alloc() +RGWBucketMetadataHandlerBase* RGWBucketMetaHandlerAllocator::alloc(librados::Rados& rados) { - return new RGWBucketMetadataHandler(); + return new RGWBucketMetadataHandler(rados); } RGWBucketInstanceMetadataHandlerBase* RGWBucketInstanceMetaHandlerAllocator::alloc(rgw::sal::Driver* driver) @@ -3315,9 +3358,9 @@ RGWBucketInstanceMetadataHandlerBase* RGWBucketInstanceMetaHandlerAllocator::all return new RGWBucketInstanceMetadataHandler(driver); } -RGWBucketMetadataHandlerBase* RGWArchiveBucketMetaHandlerAllocator::alloc() +RGWBucketMetadataHandlerBase* RGWArchiveBucketMetaHandlerAllocator::alloc(librados::Rados& rados) { - return new RGWArchiveBucketMetadataHandler(); + return new RGWArchiveBucketMetadataHandler(rados); } RGWBucketInstanceMetadataHandlerBase* RGWArchiveBucketInstanceMetaHandlerAllocator::alloc(rgw::sal::Driver* driver) diff --git a/src/rgw/driver/rados/rgw_bucket.h b/src/rgw/driver/rados/rgw_bucket.h index a1a59dc321e..52098b839c7 100644 --- a/src/rgw/driver/rados/rgw_bucket.h +++ b/src/rgw/driver/rados/rgw_bucket.h @@ -10,6 +10,7 @@ #include #include +#include "include/rados/librados_fwd.hpp" #include "include/types.h" #include "rgw_common.h" #include "rgw_tools.h" @@ -188,7 +189,7 @@ public: class RGWBucketMetaHandlerAllocator { public: - static RGWBucketMetadataHandlerBase *alloc(); + static RGWBucketMetadataHandlerBase *alloc(librados::Rados& rados); }; class RGWBucketInstanceMetaHandlerAllocator { @@ -198,7 +199,7 @@ public: class RGWArchiveBucketMetaHandlerAllocator { public: - static RGWBucketMetadataHandlerBase *alloc(); + static RGWBucketMetadataHandlerBase *alloc(librados::Rados& rados); }; class RGWArchiveBucketInstanceMetaHandlerAllocator { @@ -372,7 +373,7 @@ public: static int dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, std::ostream& os, const DoutPrefixProvider *dpp, optional_yield y); - static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y); + static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = nullptr); static int link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL); static int chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const std::string& marker, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL); @@ -678,7 +679,8 @@ public: const DoutPrefixProvider *dpp); /* user/bucket */ - int link_bucket(const rgw_user& user_id, + int link_bucket(librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, ceph::real_time creation_time, optional_yield y, @@ -686,7 +688,8 @@ public: bool update_entrypoint = true, rgw_ep_info *pinfo = nullptr); - int unlink_bucket(const rgw_user& user_id, + int unlink_bucket(librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, optional_yield y, const DoutPrefixProvider *dpp, @@ -744,7 +747,8 @@ private: const DoutPrefixProvider *dpp); int do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx, - const rgw_user& user, + librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, ceph::real_time creation_time, bool update_entrypoint, @@ -753,7 +757,8 @@ private: const DoutPrefixProvider *dpp); int do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx, - const rgw_user& user_id, + librados::Rados& rados, + const rgw_owner& owner, const rgw_bucket& bucket, bool update_entrypoint, optional_yield y, diff --git a/src/rgw/driver/rados/rgw_data_sync.cc b/src/rgw/driver/rados/rgw_data_sync.cc index 804ffdb8761..0796afcfa6f 100644 --- a/src/rgw/driver/rados/rgw_data_sync.cc +++ b/src/rgw/driver/rados/rgw_data_sync.cc @@ -3126,8 +3126,8 @@ public: RGWDataSyncModule *get_data_handler() override { return &data_handler; } - RGWMetadataHandler *alloc_bucket_meta_handler() override { - return RGWArchiveBucketMetaHandlerAllocator::alloc(); + RGWMetadataHandler *alloc_bucket_meta_handler(librados::Rados& rados) override { + return RGWArchiveBucketMetaHandlerAllocator::alloc(rados); } RGWBucketInstanceMetadataHandlerBase *alloc_bucket_instance_meta_handler(rgw::sal::Driver* driver) override { return RGWArchiveBucketInstanceMetaHandlerAllocator::alloc(driver); diff --git a/src/rgw/driver/rados/rgw_rados.cc b/src/rgw/driver/rados/rgw_rados.cc index 0d20f50a7d9..1f079229766 100644 --- a/src/rgw/driver/rados/rgw_rados.cc +++ b/src/rgw/driver/rados/rgw_rados.cc @@ -1411,7 +1411,7 @@ int RGWRados::init_begin(CephContext* _cct, const DoutPrefixProvider *dpp, return ret; } - ret = ctl.init(&svc, driver, dpp); + ret = ctl.init(&svc, driver, *get_rados_handle(), dpp); if (ret < 0) { ldpp_dout(dpp, 0) << "ERROR: failed to init ctls (ret=" << cpp_strerror(-ret) << ")" << dendl; return ret; diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc index 8b6d4992c3d..d0a3bac1896 100644 --- a/src/rgw/driver/rados/rgw_sal_rados.cc +++ b/src/rgw/driver/rados/rgw_sal_rados.cc @@ -360,7 +360,9 @@ int RadosBucket::remove(const DoutPrefixProvider* dpp, ldpp_dout(dpp, -1) << "ERROR: unable to remove notifications from bucket. ret=" << ps_ret << dendl; } - ret = store->ctl()->bucket->unlink_bucket(info.owner, info.bucket, y, dpp, false); + librados::Rados& rados = *store->getRados()->get_rados_handle(); + ret = store->ctl()->bucket->unlink_bucket(rados, info.owner, + info.bucket, y, dpp, false); if (ret < 0) { ldpp_dout(dpp, -1) << "ERROR: unable to remove user bucket information" << dendl; } @@ -571,7 +573,8 @@ int RadosBucket::link(const DoutPrefixProvider* dpp, const rgw_user& new_user, o Attrs ep_attrs; rgw_ep_info ep_data{ep, ep_attrs}; - int r = store->ctl()->bucket->link_bucket(new_user, info.bucket, + librados::Rados& rados = *store->getRados()->get_rados_handle(); + int r = store->ctl()->bucket->link_bucket(rados, new_user, info.bucket, get_creation_time(), y, dpp, update_entrypoint, &ep_data); if (r < 0) @@ -585,13 +588,16 @@ int RadosBucket::link(const DoutPrefixProvider* dpp, const rgw_user& new_user, o int RadosBucket::unlink(const DoutPrefixProvider* dpp, const rgw_user& owner, optional_yield y, bool update_entrypoint) { - return store->ctl()->bucket->unlink_bucket(owner, info.bucket, y, dpp, update_entrypoint); + librados::Rados& rados = *store->getRados()->get_rados_handle(); + return store->ctl()->bucket->unlink_bucket(rados, owner, info.bucket, + y, dpp, update_entrypoint); } int RadosBucket::chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y) { std::string obj_marker; - int r = this->unlink(dpp, info.owner, y); + // unlink from the owner, but don't update the entrypoint until link() + int r = this->unlink(dpp, info.owner, y, false); if (r < 0) { return r; } diff --git a/src/rgw/driver/rados/rgw_service.cc b/src/rgw/driver/rados/rgw_service.cc index 8d726431fba..d8b4610ecaf 100644 --- a/src/rgw/driver/rados/rgw_service.cc +++ b/src/rgw/driver/rados/rgw_service.cc @@ -375,7 +375,8 @@ RGWCtlDef::_meta::_meta() {} RGWCtlDef::_meta::~_meta() {} -int RGWCtlDef::init(RGWServices& svc, rgw::sal::Driver* driver, const DoutPrefixProvider *dpp) +int RGWCtlDef::init(RGWServices& svc, rgw::sal::Driver* driver, + librados::Rados& rados, const DoutPrefixProvider *dpp) { meta.mgr.reset(new RGWMetadataManager(svc.meta)); @@ -383,10 +384,10 @@ int RGWCtlDef::init(RGWServices& svc, rgw::sal::Driver* driver, const DoutPrefix auto sync_module = svc.sync_modules->get_sync_module(); if (sync_module) { - meta.bucket.reset(sync_module->alloc_bucket_meta_handler()); + meta.bucket.reset(sync_module->alloc_bucket_meta_handler(rados)); meta.bucket_instance.reset(sync_module->alloc_bucket_instance_meta_handler(driver)); } else { - meta.bucket.reset(RGWBucketMetaHandlerAllocator::alloc()); + meta.bucket.reset(RGWBucketMetaHandlerAllocator::alloc(rados)); meta.bucket_instance.reset(RGWBucketInstanceMetaHandlerAllocator::alloc(driver)); } @@ -430,12 +431,13 @@ int RGWCtlDef::init(RGWServices& svc, rgw::sal::Driver* driver, const DoutPrefix return 0; } -int RGWCtl::init(RGWServices *_svc, rgw::sal::Driver* driver, const DoutPrefixProvider *dpp) +int RGWCtl::init(RGWServices *_svc, rgw::sal::Driver* driver, + librados::Rados& rados, const DoutPrefixProvider *dpp) { svc = _svc; cct = svc->cct; - int r = _ctl.init(*svc, driver, dpp); + int r = _ctl.init(*svc, driver, rados, dpp); if (r < 0) { ldpp_dout(dpp, 0) << "ERROR: failed to start init ctls (" << cpp_strerror(-r) << dendl; return r; diff --git a/src/rgw/driver/rados/rgw_service.h b/src/rgw/driver/rados/rgw_service.h index c2da007b0fe..486df8c71be 100644 --- a/src/rgw/driver/rados/rgw_service.h +++ b/src/rgw/driver/rados/rgw_service.h @@ -212,7 +212,8 @@ struct RGWCtlDef { RGWCtlDef(); ~RGWCtlDef(); - int init(RGWServices& svc, rgw::sal::Driver* driver, const DoutPrefixProvider *dpp); + int init(RGWServices& svc, rgw::sal::Driver* driver, + librados::Rados& rados, const DoutPrefixProvider *dpp); }; struct RGWCtl { @@ -238,5 +239,6 @@ struct RGWCtl { RGWBucketCtl *bucket{nullptr}; RGWOTPCtl *otp{nullptr}; - int init(RGWServices *_svc, rgw::sal::Driver* driver, const DoutPrefixProvider *dpp); + int init(RGWServices *_svc, rgw::sal::Driver* driver, + librados::Rados& rados, const DoutPrefixProvider *dpp); }; diff --git a/src/rgw/driver/rados/rgw_sync_module.cc b/src/rgw/driver/rados/rgw_sync_module.cc index 5a1e70be34e..a19248f2e9a 100644 --- a/src/rgw/driver/rados/rgw_sync_module.cc +++ b/src/rgw/driver/rados/rgw_sync_module.cc @@ -16,9 +16,9 @@ #define dout_subsys ceph_subsys_rgw -RGWMetadataHandler *RGWSyncModuleInstance::alloc_bucket_meta_handler() +RGWMetadataHandler *RGWSyncModuleInstance::alloc_bucket_meta_handler(librados::Rados& rados) { - return RGWBucketMetaHandlerAllocator::alloc(); + return RGWBucketMetaHandlerAllocator::alloc(rados); } RGWBucketInstanceMetadataHandlerBase* RGWSyncModuleInstance::alloc_bucket_instance_meta_handler(rgw::sal::Driver* driver) diff --git a/src/rgw/driver/rados/rgw_sync_module.h b/src/rgw/driver/rados/rgw_sync_module.h index 38abb3d1adf..4ca691ca665 100644 --- a/src/rgw/driver/rados/rgw_sync_module.h +++ b/src/rgw/driver/rados/rgw_sync_module.h @@ -3,6 +3,7 @@ #pragma once +#include "include/rados/librados_fwd.hpp" #include "rgw_common.h" #include "rgw_coroutine.h" @@ -55,7 +56,7 @@ public: virtual bool supports_user_writes() { return false; } - virtual RGWMetadataHandler *alloc_bucket_meta_handler(); + virtual RGWMetadataHandler *alloc_bucket_meta_handler(librados::Rados& rados); virtual RGWBucketInstanceMetadataHandlerBase *alloc_bucket_instance_meta_handler(rgw::sal::Driver* driver); // indication whether the sync module start with full sync (default behavior) diff --git a/src/rgw/rgw_common.h b/src/rgw/rgw_common.h index 61b1d19a9b2..dd696e01e43 100644 --- a/src/rgw/rgw_common.h +++ b/src/rgw/rgw_common.h @@ -26,6 +26,7 @@ #include "common/ceph_crypto.h" #include "common/random_string.h" #include "common/tracer.h" +#include "common/versioned_variant.h" #include "rgw_acl.h" #include "rgw_bucket_layout.h" #include "rgw_cors.h" @@ -1038,7 +1039,7 @@ WRITE_CLASS_ENCODER(RGWBucketInfo) struct RGWBucketEntryPoint { rgw_bucket bucket; - rgw_user owner; + rgw_owner owner; ceph::real_time creation_time; bool linked; @@ -1048,13 +1049,19 @@ struct RGWBucketEntryPoint RGWBucketEntryPoint() : linked(false), has_bucket_info(false) {} void encode(bufferlist& bl) const { + const rgw_user* user = std::get_if(&owner); ENCODE_START(10, 8, bl); encode(bucket, bl); - encode(owner.id, bl); + if (user) { + encode(user->id, bl); + } else { + encode(std::string{}, bl); // empty user id + } encode(linked, bl); uint64_t ctime = (uint64_t)real_clock::to_time_t(creation_time); encode(ctime, bl); - encode(owner, bl); + // 'rgw_user owner' converted to 'rgw_owner' + ceph::converted_variant::encode(owner, bl); encode(creation_time, bl); ENCODE_FINISH(bl); } @@ -1069,7 +1076,8 @@ struct RGWBucketEntryPoint } has_bucket_info = false; decode(bucket, bl); - decode(owner.id, bl); + std::string user_id; + decode(user_id, bl); decode(linked, bl); uint64_t ctime; decode(ctime, bl); @@ -1077,7 +1085,9 @@ struct RGWBucketEntryPoint creation_time = real_clock::from_time_t((time_t)ctime); } if (struct_v >= 9) { - decode(owner, bl); + ceph::converted_variant::decode(owner, bl); + } else { + owner = rgw_user{"", user_id}; } if (struct_v >= 10) { decode(creation_time, bl); diff --git a/src/rgw/services/svc_user.h b/src/rgw/services/svc_user.h index cf46df6e3d1..6ff412a8a26 100644 --- a/src/rgw/services/svc_user.h +++ b/src/rgw/services/svc_user.h @@ -42,6 +42,8 @@ public: /* base svc_user interfaces */ + virtual rgw_raw_obj get_buckets_obj(const rgw_user& user_id) const = 0; + virtual int read_user_info(RGWSI_MetaBackend::Context *ctx, const rgw_user& user, RGWUserInfo *info, diff --git a/src/rgw/services/svc_user_rados.h b/src/rgw/services/svc_user_rados.h index 1ac0212fa9a..aa43f9c0c18 100644 --- a/src/rgw/services/svc_user_rados.h +++ b/src/rgw/services/svc_user_rados.h @@ -53,7 +53,7 @@ class RGWSI_User_RADOS : public RGWSI_User using RGWChainedCacheImpl_user_info_cache_entry = RGWChainedCacheImpl; std::unique_ptr uinfo_cache; - rgw_raw_obj get_buckets_obj(const rgw_user& user_id) const; + rgw_raw_obj get_buckets_obj(const rgw_user& user_id) const override; int get_user_info_from_index(RGWSI_MetaBackend::Context *ctx, const std::string& key,