rgw: use rgw_owner in RGWBucketEntryPoint

Signed-off-by: Casey Bodley <cbodley@redhat.com>
(cherry picked from commit 469b7e83d723021555886dc7c46d178190f59829)

diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc
index d5304fec4993bd2bf87a698d36e241a55eca44cb..8cde25fc1990d9eb689d8ecd0daf6f2ce79646e3 100644 (file)
--- 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<rgw::sal::RadosStore*>(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<rgw::sal::RadosStore*>(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<rgw::sal::RadosStore*>(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<rgw::sal::RadosStore*>(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<rgw::sal::RadosStore*>(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<rgw::sal::RadosStore*>(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<rgw::sal::RadosStore*>(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<RGWBucketEntryMetadataObject *>(_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<RGWBucketEntryMetadataObject *>(_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 a1a59dc321e51da77faf7292145e4733996a4ad0..52098b839c7b0c912289d151da474c8b9749fa5a 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.h
+++ b/src/rgw/driver/rados/rgw_bucket.h
@@ -10,6 +10,7 @@
 #include <boost/container/flat_map.hpp>
 #include <boost/container/flat_set.hpp>
 
+#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 804ffdb876184000f0fa57b4ab4f80a329d63b07..0796afcfa6fed8aefdfb471aadbd61309e5c36fc 100644 (file)
--- 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 0d20f50a7d9e208d26ab32c331cefc82133ed989..1f07922976602e1a6ee5998de2df6a48c415976c 100644 (file)
--- 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 8b6d4992c3df2ea05611ba812d231586dbc42119..d0a3bac1896ac592fa50899d9e9bc68d5dfaf284 100644 (file)
--- 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 8d726431fba7f500769ef21492df6b18dbe1f6e8..d8b4610ecafc7016f69d37eee4f981e8c70e4e41 100644 (file)
--- 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 c2da007b0fee66f61494b0b5a52b8f367f9f9fe6..486df8c71bea74d76d13a86d0a5abce0ac9b7ac9 100644 (file)
--- 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 5a1e70be34ebe11c8124b93ee39d6f7442a641cf..a19248f2e9af53957cc976cc0bb49dc303d6ddf6 100644 (file)
--- 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 38abb3d1adfdfc6db727d4d2fcf9d3b601c7d1a7..4ca691ca665d53871b956872eaecdeab09e76a19 100644 (file)
--- 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 61b1d19a9b26e5f4b6b361cbcfc382717f164963..dd696e01e43b211d4f15ade3c67dfb9b03817255 100644 (file)
--- 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<rgw_user>(&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 cf46df6e3d11bfbcd2822be0ac1a6f1c648d42d7..6ff412a8a2649602723433cfc91383fbab2395ad 100644 (file)
--- 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 1ac0212fa9aa48b218c455d0ca10e926073a56e4..aa43f9c0c18a040fb4b82c42f1f6320a7b9d22e2 100644 (file)
--- 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<user_info_cache_entry>;
   std::unique_ptr<RGWChainedCacheImpl_user_info_cache_entry> 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,