Merge pull request ceph#54379 from cbodley/wip-rgw-sal-bucket-owner

rgw/sal: Bucket owner as rgw_user

Reviewed-by: Daniel Gryniewicz <[email protected]>

Author: cbodley

src/rgw/driver/d4n/rgw_sal_d4n.cc

@@ -326,7 +326,6 @@ int D4NFilterObject::D4NFilterReadOp::prepare(optional_yield y, const DoutPrefix
     ldpp_dout(dpp, 20) << "D4N Filter: Cache get object operation failed." << dendl;
   } else {
     /* Set metadata locally */
-    RGWQuotaInfo quota_info;
     RGWObjState* astate;
     source->get_obj_state(dpp, &astate, y);
 
@@ -343,16 +342,9 @@ int D4NFilterObject::D4NFilterReadOp::prepare(optional_yield y, const DoutPrefix
 	source->set_instance(it->second);
       } else if (!std::strcmp(it->first.data(), "source_zone_short_id")) {
 	astate->zone_short_id = static_cast<uint32_t>(std::stoul(it->second));
-      } else if (!std::strcmp(it->first.data(), "user_quota.max_size")) {
-        quota_info.max_size = std::stoull(it->second);
-      } else if (!std::strcmp(it->first.data(), "user_quota.max_objects")) {
-        quota_info.max_objects = std::stoull(it->second);
-      } else if (!std::strcmp(it->first.data(), "max_buckets")) {
-        source->get_bucket()->get_owner()->set_max_buckets(std::stoull(it->second));
       }
     }
 
-    source->get_bucket()->get_owner()->set_info(quota_info);
     source->set_obj_state(*astate);
 
     /* Set attributes locally */
@@ -491,19 +483,6 @@ int D4NFilterWriter::complete(size_t accounted_size, const std::string& etag,
     bl.clear();
   }
 
-  RGWUserInfo info = obj->get_bucket()->get_owner()->get_info();
-  bl.append(std::to_string(info.quota.user_quota.max_size));
-  baseAttrs.insert({"user_quota.max_size", bl});
-  bl.clear();
-
-  bl.append(std::to_string(info.quota.user_quota.max_objects));
-  baseAttrs.insert({"user_quota.max_objects", bl});
-  bl.clear();
-
-  bl.append(std::to_string(obj->get_bucket()->get_owner()->get_max_buckets()));
-  baseAttrs.insert({"max_buckets", bl});
-  bl.clear();
-
   baseAttrs.insert(attrs.begin(), attrs.end());
 
   int setObjReturn = filter->get_d4n_cache()->setObject(obj->get_key().get_oid(), &baseAttrs);

src/rgw/driver/d4n/rgw_sal_d4n.h

@@ -78,8 +78,8 @@ class D4NFilterBucket : public FilterBucket {
     D4NFilterDriver* filter;
 
   public:
-    D4NFilterBucket(std::unique_ptr<Bucket> _next, User* _user, D4NFilterDriver* _filter) :
-      FilterBucket(std::move(_next), _user), 
+    D4NFilterBucket(std::unique_ptr<Bucket> _next, D4NFilterDriver* _filter) :
+      FilterBucket(std::move(_next)),
       filter(_filter) {}
     virtual ~D4NFilterBucket() = default;
 

src/rgw/driver/posix/rgw_sal_posix.cc

@@ -348,16 +348,16 @@ std::unique_ptr<Object> POSIXDriver::get_object(const rgw_obj_key& k)
   return std::make_unique<POSIXObject>(this, k);
 }
 
-int POSIXDriver::load_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
+int POSIXDriver::load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
 {
-  *bucket = std::make_unique<POSIXBucket>(this, root_fd, b, u);
+  *bucket = std::make_unique<POSIXBucket>(this, root_fd, b);
   return (*bucket)->load_bucket(dpp, y);
 }
 
-std::unique_ptr<Bucket> POSIXDriver::get_bucket(User* u, const RGWBucketInfo& i)
+std::unique_ptr<Bucket> POSIXDriver::get_bucket(const RGWBucketInfo& i)
 {
   /* Don't need to fetch the bucket info, use the provided one */
-  return std::make_unique<POSIXBucket>(this, root_fd, i, u);
+  return std::make_unique<POSIXBucket>(this, root_fd, i);
 }
 
 std::string POSIXDriver::zone_unique_trans_id(const uint64_t unique_num)
@@ -525,8 +525,7 @@ int POSIXBucket::create(const DoutPrefixProvider* dpp,
 			const CreateParams& params,
 			optional_yield y)
 {
-  ceph_assert(owner);
-  info.owner = owner->get_id();
+  info.owner = params.owner;
 
   info.bucket.marker = params.marker;
   info.bucket.bucket_id = params.bucket_id;
@@ -632,7 +631,7 @@ int POSIXDriver::mint_listing_entry(const std::string &bname,
     POSIXObject *pobj;
     int ret;
 
-    ret = load_bucket(nullptr, nullptr, rgw_bucket(std::string(), bname),
+    ret = load_bucket(nullptr, rgw_bucket(std::string(), bname),
                       &b, null_yield);
     if (ret < 0)
       return ret;
@@ -883,10 +882,6 @@ int POSIXBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y)
   mtime = ceph::real_clock::from_time_t(stx.stx_mtime.tv_sec);
   info.creation_time = ceph::real_clock::from_time_t(stx.stx_btime.tv_sec);
 
-  if (owner) {
-    info.owner = owner->get_id();
-  }
-
   ret = open(dpp);
   if (ret < 0) {
     return ret;
@@ -981,7 +976,7 @@ int POSIXBucket::check_bucket_shards(const DoutPrefixProvider* dpp,
   return 0;
 }
 
-int POSIXBucket::chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y)
+int POSIXBucket::chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y)
 {
   /* TODO map user to UID/GID, and change it */
   return 0;
@@ -1204,7 +1199,7 @@ int POSIXBucket::get_shadow_bucket(const DoutPrefixProvider* dpp, optional_yield
 
   open(dpp);
 
-  bp = new POSIXBucket(driver, dir_fd, b, owner, ons);
+  bp = new POSIXBucket(driver, dir_fd, b, ons);
   ret = bp->load_bucket(dpp, y);
   if (ret == -ENOENT && create) {
     /* Create it if it doesn't exist */

src/rgw/driver/posix/rgw_sal_posix.h

@@ -52,10 +52,9 @@ class POSIXDriver : public FilterDriver {
 				std::string& user_str, optional_yield y,
 				std::unique_ptr<User>* user) override;
   virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
-  virtual std::unique_ptr<Bucket> get_bucket(User* u, const RGWBucketInfo& i)  override;
-  virtual int load_bucket(const DoutPrefixProvider* dpp, User* u, const
-			  rgw_bucket& b, std::unique_ptr<Bucket>* bucket,
-			  optional_yield y) override;
+  virtual std::unique_ptr<Bucket> get_bucket(const RGWBucketInfo& i)  override;
+  virtual int load_bucket(const DoutPrefixProvider* dpp, const rgw_bucket& b,
+                          std::unique_ptr<Bucket>* bucket, optional_yield y) override;
   virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
 
   virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
@@ -143,16 +142,16 @@ class POSIXBucket : public StoreBucket {
   std::optional<std::string> ns;
 
 public:
-  POSIXBucket(POSIXDriver *_dr, int _p_fd, const rgw_bucket& _b, User* _u, std::optional<std::string> _ns = std::nullopt)
-    : StoreBucket(_b, _u),
+  POSIXBucket(POSIXDriver *_dr, int _p_fd, const rgw_bucket& _b, std::optional<std::string> _ns = std::nullopt)
+    : StoreBucket(_b),
     driver(_dr),
     parent_fd(_p_fd),
     acls(),
     ns(_ns)
     { }
 
-  POSIXBucket(POSIXDriver *_dr, int _p_fd, const RGWBucketInfo& _i, User* _u)
-    : StoreBucket(_i, _u),
+  POSIXBucket(POSIXDriver *_dr, int _p_fd, const RGWBucketInfo& _i)
+    : StoreBucket(_i),
     driver(_dr),
     parent_fd(_p_fd),
     acls()
@@ -201,7 +200,7 @@ class POSIXBucket : public StoreBucket {
                               RGWBucketEnt* ent) override;
   virtual int check_bucket_shards(const DoutPrefixProvider* dpp,
                                   uint64_t num_objs, optional_yield y) override;
-  virtual int chown(const DoutPrefixProvider* dpp, User& new_user, optional_yield y) override;
+  virtual int chown(const DoutPrefixProvider* dpp, const rgw_user& new_owner, optional_yield y) override;
   virtual int put_info(const DoutPrefixProvider* dpp, bool exclusive,
 		       ceph::real_time mtime, optional_yield y) override;
   virtual int check_empty(const DoutPrefixProvider* dpp, optional_yield y) override;

src/rgw/driver/rados/rgw_bucket.cc

@@ -109,8 +109,7 @@ void check_bad_user_bucket_mapping(rgw::sal::Driver* driver, rgw::sal::User& use
 
     for (const auto& ent : listing.buckets) {
       std::unique_ptr<rgw::sal::Bucket> bucket;
-      int r = driver->load_bucket(dpp, &user,
-                                  rgw_bucket(user.get_tenant(), ent.bucket.name),
+      int r = driver->load_bucket(dpp, rgw_bucket(user.get_tenant(), ent.bucket.name),
                                   &bucket, y);
       if (r < 0) {
         ldpp_dout(dpp, 0) << "could not get bucket info for bucket=" << bucket << dendl;
@@ -122,7 +121,7 @@ void check_bad_user_bucket_mapping(rgw::sal::Driver* driver, rgw::sal::User& use
             << " got " << bucket << std::endl;
         if (fix) {
           cout << "fixing" << std::endl;
-	  r = bucket->chown(dpp, user, y);
+	  r = bucket->chown(dpp, user.get_id(), y);
           if (r < 0) {
             cerr << "failed to fix bucket: " << cpp_strerror(-r) << std::endl;
           }
@@ -183,7 +182,7 @@ int RGWBucket::init(rgw::sal::Driver* _driver, RGWBucketAdminOpState& op_state,
     bucket_name = bucket_name.substr(pos + 1);
   }
 
-  int r = driver->load_bucket(dpp, user.get(), rgw_bucket(tenant, bucket_name),
+  int r = driver->load_bucket(dpp, rgw_bucket(tenant, bucket_name),
                               &bucket, y);
   if (r < 0) {
       set_err_msg(err_msg, "failed to fetch bucket info for bucket=" + bucket_name);
@@ -246,11 +245,6 @@ bool rgw_find_bucket_by_id(const DoutPrefixProvider *dpp, CephContext *cct, rgw:
 int RGWBucket::chown(RGWBucketAdminOpState& op_state, const string& marker,
                      optional_yield y, const DoutPrefixProvider *dpp, std::string *err_msg)
 {
-  /* User passed in by rgw_admin is the new user; get the current user and set it in
-   * the bucket */
-  std::unique_ptr<rgw::sal::User> old_user = driver->get_user(bucket->get_info().owner);
-  bucket->set_owner(old_user.get());
-
   return rgw_chown_bucket_and_objects(driver, bucket.get(), user.get(), marker, err_msg, dpp, y);
 }
 
@@ -1243,11 +1237,9 @@ int RGWBucketAdminOp::remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpSt
                                     bool bypass_gc, bool keep_index_consistent)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  std::unique_ptr<rgw::sal::User> user = driver->get_user(op_state.get_user_id());
 
-  int ret = driver->load_bucket(dpp, user.get(),
-                                rgw_bucket(user->get_tenant(),
-                                           op_state.get_bucket_name()),
+  int ret = driver->load_bucket(dpp, rgw_bucket(op_state.get_tenant(),
+                                                op_state.get_bucket_name()),
                                 &bucket, y);
   if (ret < 0)
     return ret;
@@ -1289,8 +1281,7 @@ static int bucket_stats(rgw::sal::Driver* driver,
   std::unique_ptr<rgw::sal::Bucket> bucket;
   map<RGWObjCategory, RGWStorageStats> stats;
 
-  int ret = driver->load_bucket(dpp, nullptr,
-                                rgw_bucket(tenant_name, bucket_name),
+  int ret = driver->load_bucket(dpp, rgw_bucket(tenant_name, bucket_name),
                                 &bucket, y);
   if (ret < 0) {
     return ret;
@@ -1416,7 +1407,7 @@ int RGWBucketAdminOp::limit_check(rgw::sal::Driver* driver,
 	uint64_t num_objects = 0;
 
 	std::unique_ptr<rgw::sal::Bucket> bucket;
-	ret = driver->load_bucket(dpp, user.get(), ent.bucket, &bucket, y);
+	ret = driver->load_bucket(dpp, ent.bucket, &bucket, y);
 	if (ret < 0)
 	  continue;
 
@@ -1600,7 +1591,7 @@ void get_stale_instances(rgw::sal::Driver* driver, const std::string& bucket_nam
     std::unique_ptr<rgw::sal::Bucket> bucket;
     rgw_bucket rbucket;
     rgw_bucket_parse_bucket_key(driver->ctx(), bucket_instance, &rbucket, nullptr);
-    int r = driver->load_bucket(dpp, nullptr, rbucket, &bucket, y);
+    int r = driver->load_bucket(dpp, rbucket, &bucket, y);
     if (r < 0){
       // this can only happen if someone deletes us right when we're processing
       ldpp_dout(dpp, -1) << "Bucket instance is invalid: " << bucket_instance
@@ -1620,7 +1611,7 @@ void get_stale_instances(rgw::sal::Driver* driver, const std::string& bucket_nam
   auto [tenant, bname] = split_tenant(bucket_name);
   RGWBucketInfo cur_bucket_info;
   std::unique_ptr<rgw::sal::Bucket> cur_bucket;
-  int r = driver->load_bucket(dpp, nullptr, rgw_bucket(tenant, bname),
+  int r = driver->load_bucket(dpp, rgw_bucket(tenant, bname),
                               &cur_bucket, y);
   if (r < 0) {
     if (r == -ENOENT) {
@@ -1755,7 +1746,7 @@ int RGWBucketAdminOp::clear_stale_instances(rgw::sal::Driver* driver,
                       Formatter *formatter,
                       rgw::sal::Driver* driver){
                      for (const auto &binfo: lst) {
-		       auto bucket = driver->get_bucket(nullptr, binfo);
+		       auto bucket = driver->get_bucket(binfo);
 		       int ret = bucket->purge_instance(dpp, y);
                        if (ret == 0){
                          auto md_key = "bucket.instance:" + binfo.bucket.get_key();
@@ -1777,8 +1768,7 @@ static int fix_single_bucket_lc(rgw::sal::Driver* driver,
                                 const DoutPrefixProvider *dpp, optional_yield y)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int ret = driver->load_bucket(dpp, nullptr,
-                                rgw_bucket(tenant_name, bucket_name),
+  int ret = driver->load_bucket(dpp, rgw_bucket(tenant_name, bucket_name),
                                 &bucket, y);
   if (ret < 0) {
     // TODO: Should we handle the case where the bucket could've been removed between
@@ -1949,7 +1939,7 @@ int RGWBucketAdminOp::fix_obj_expiry(rgw::sal::Driver* driver,
     ldpp_dout(dpp, -1) << "failed to initialize bucket" << dendl;
     return ret;
   }
-  auto bucket = driver->get_bucket(nullptr, admin_bucket.get_bucket_info());
+  auto bucket = driver->get_bucket(admin_bucket.get_bucket_info());
 
   return fix_bucket_obj_expiry(dpp, driver, bucket.get(), flusher, dry_run, y);
 }
@@ -2630,7 +2620,7 @@ int RGWMetadataHandlerPut_BucketInstance::put_post(const DoutPrefixProvider *dpp
 
   /* update lifecyle policy */
   {
-    auto bucket = bihandler->driver->get_bucket(nullptr, bci.info);
+    auto bucket = bihandler->driver->get_bucket(bci.info);
 
     auto lc = bihandler->driver->get_rgwlc();
 

src/rgw/driver/rados/rgw_cr_rados.h

@@ -1350,7 +1350,7 @@ class RGWAsyncRemoveObj : public RGWAsyncRadosRequest {
     if (_zones_trace) {
       zones_trace = *_zones_trace;
     }
-    bucket = store->get_bucket(nullptr, _bucket_info);
+    bucket = store->get_bucket(_bucket_info);
     obj = bucket->get_object(_key);
   }
 };

src/rgw/driver/rados/rgw_cr_tools.cc

@@ -100,8 +100,7 @@ int RGWGetUserInfoCR::Request::_send_request(const DoutPrefixProvider *dpp)
 template<>
 int RGWGetBucketInfoCR::Request::_send_request(const DoutPrefixProvider *dpp)
 {
-  return store->load_bucket(dpp, nullptr,
-                            rgw_bucket(params.tenant, params.bucket_name),
+  return store->load_bucket(dpp, rgw_bucket(params.tenant, params.bucket_name),
                             &result->bucket, null_yield);
 }
 

src/rgw/driver/rados/rgw_notify.cc

@@ -873,8 +873,7 @@ static inline void populate_event(reservation_t& res,
   event.x_amz_id_2 = res.store->getRados()->host_id; // RGW on which the change was made
   // configurationId is filled from notification configuration
   event.bucket_name = res.bucket->get_name();
-  event.bucket_ownerIdentity = res.bucket->get_owner() ?
-    res.bucket->get_owner()->get_id().id : res.bucket->get_info().owner.id;
+  event.bucket_ownerIdentity = res.bucket->get_owner().id;
   const auto region = res.store->get_zone()->get_zonegroup().get_api_name();
   rgw::ARN bucket_arn(res.bucket->get_key());
   bucket_arn.region = region; 

src/rgw/driver/rados/rgw_object_expirer_core.cc

@@ -201,7 +201,7 @@ int RGWObjectExpirer::garbage_single_object(const DoutPrefixProvider *dpp, objex
   RGWBucketInfo bucket_info;
   std::unique_ptr<rgw::sal::Bucket> bucket;
 
-  int ret = driver->load_bucket(dpp, nullptr, rgw_bucket(hint.tenant, hint.bucket_name, hint.bucket_id), &bucket, null_yield);
+  int ret = driver->load_bucket(dpp, rgw_bucket(hint.tenant, hint.bucket_name, hint.bucket_id), &bucket, null_yield);
   if (-ENOENT == ret) {
     ldpp_dout(dpp, 15) << "NOTICE: cannot find bucket = " \
         << hint.bucket_name << ". The object must be already removed" << dendl;

src/rgw/driver/rados/rgw_rest_bucket.cc

@@ -233,7 +233,7 @@ void RGWOp_Bucket_Remove::execute(optional_yield y)
     return;
   }
 
-  op_ret = driver->load_bucket(s, nullptr, rgw_bucket("", bucket_name),
+  op_ret = driver->load_bucket(s, rgw_bucket("", bucket_name),
                                &bucket, y);
   if (op_ret < 0) {
     ldpp_dout(this, 0) << "get_bucket returned ret=" << op_ret << dendl;
@@ -301,7 +301,7 @@ void RGWOp_Set_Bucket_Quota::execute(optional_yield y)
   }
   if (use_http_params) {
     std::unique_ptr<rgw::sal::Bucket> bucket;
-    op_ret = driver->load_bucket(s, nullptr, rgw_bucket(uid.tenant, bucket_name),
+    op_ret = driver->load_bucket(s, rgw_bucket(uid.tenant, bucket_name),
                                  &bucket, s->yield);
     if (op_ret < 0) {
       return;