rgw: use load_bucket()'s rgw_bucket overload

Signed-off-by: Casey Bodley <cbodley@redhat.com>

diff --git a/src/rgw/driver/posix/rgw_sal_posix.cc b/src/rgw/driver/posix/rgw_sal_posix.cc
index 065d6d2d95dbc914a405d65a0fb88ee2dbc8e671..5204017274a90ff9dc610522bdccae66d2955a97 100644 (file)
--- a/src/rgw/driver/posix/rgw_sal_posix.cc
+++ b/src/rgw/driver/posix/rgw_sal_posix.cc
@@ -705,7 +705,8 @@ int POSIXDriver::mint_listing_entry(const std::string &bname,
     POSIXObject *pobj;
     int ret;
 
-    ret = load_bucket(nullptr, nullptr, std::string(), bname, &b, null_yield);
+    ret = load_bucket(nullptr, nullptr, rgw_bucket(std::string(), bname),
+                      &b, null_yield);
     if (ret < 0)
       return ret;
 

diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc
index 1c4341f438f3730e93b431c02fc1af84aa7db586..d0bdc025b7a64675cc8069f072d853cdbd197f64 100644 (file)
--- a/src/rgw/driver/rados/rgw_bucket.cc
+++ b/src/rgw/driver/rados/rgw_bucket.cc
@@ -109,7 +109,9 @@ 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, user.get_tenant(), ent.bucket.name, &bucket, y);
+      int r = driver->load_bucket(dpp, &user,
+                                  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;
         continue;
@@ -181,7 +183,8 @@ 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(), tenant, bucket_name, &bucket, y);
+  int r = driver->load_bucket(dpp, user.get(), rgw_bucket(tenant, bucket_name),
+                              &bucket, y);
   if (r < 0) {
       set_err_msg(err_msg, "failed to fetch bucket info for bucket=" + bucket_name);
       return r;
@@ -1242,8 +1245,10 @@ int RGWBucketAdminOp::remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpSt
   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(), user->get_tenant(),
-                                op_state.get_bucket_name(), &bucket, y);
+  int ret = driver->load_bucket(dpp, user.get(),
+                                rgw_bucket(user->get_tenant(),
+                                           op_state.get_bucket_name()),
+                                &bucket, y);
   if (ret < 0)
     return ret;
 
@@ -1284,7 +1289,9 @@ 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, tenant_name, bucket_name, &bucket, y);
+  int ret = driver->load_bucket(dpp, nullptr,
+                                rgw_bucket(tenant_name, bucket_name),
+                                &bucket, y);
   if (ret < 0) {
     return ret;
   }
@@ -1611,7 +1618,8 @@ 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, tenant, bname, &cur_bucket, y);
+  int r = driver->load_bucket(dpp, nullptr, rgw_bucket(tenant, bname),
+                              &cur_bucket, y);
   if (r < 0) {
     if (r == -ENOENT) {
       // bucket doesn't exist, everything is stale then
@@ -1767,7 +1775,9 @@ 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, tenant_name, bucket_name, &bucket, y);
+  int ret = driver->load_bucket(dpp, nullptr,
+                                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
     // listing and fetching?

diff --git a/src/rgw/driver/rados/rgw_cr_tools.cc b/src/rgw/driver/rados/rgw_cr_tools.cc
index 10d17a49b3807284c1df858d611d7bb6602547e0..928cc9c0c988ecc2dbe46c582617155c8b1c0962 100644 (file)
--- a/src/rgw/driver/rados/rgw_cr_tools.cc
+++ b/src/rgw/driver/rados/rgw_cr_tools.cc
@@ -100,7 +100,9 @@ int RGWGetUserInfoCR::Request::_send_request(const DoutPrefixProvider *dpp)
 template<>
 int RGWGetBucketInfoCR::Request::_send_request(const DoutPrefixProvider *dpp)
 {
-  return store->load_bucket(dpp, nullptr, params.tenant, params.bucket_name, &result->bucket, null_yield);
+  return store->load_bucket(dpp, nullptr,
+                            rgw_bucket(params.tenant, params.bucket_name),
+                            &result->bucket, null_yield);
 }
 
 template<>

diff --git a/src/rgw/driver/rados/rgw_rest_bucket.cc b/src/rgw/driver/rados/rgw_rest_bucket.cc
index 66aceabee96fe58c377907635b3af2420380fa2d..6853173be4ff4eff4b32551999b3a8cfb142cbab 100644 (file)
--- a/src/rgw/driver/rados/rgw_rest_bucket.cc
+++ b/src/rgw/driver/rados/rgw_rest_bucket.cc
@@ -232,7 +232,8 @@ void RGWOp_Bucket_Remove::execute(optional_yield y)
     return;
   }
 
-  op_ret = driver->load_bucket(s, nullptr, string(), bucket_name, &bucket, y);
+  op_ret = driver->load_bucket(s, nullptr, rgw_bucket("", bucket_name),
+                               &bucket, y);
   if (op_ret < 0) {
     ldpp_dout(this, 0) << "get_bucket returned ret=" << op_ret << dendl;
     if (op_ret == -ENOENT) {
@@ -299,7 +300,8 @@ 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, uid.tenant, bucket_name, &bucket, s->yield);
+    op_ret = driver->load_bucket(s, nullptr, rgw_bucket(uid.tenant, bucket_name),
+                                 &bucket, s->yield);
     if (op_ret < 0) {
       return;
     }

diff --git a/src/rgw/driver/rados/rgw_tools.cc b/src/rgw/driver/rados/rgw_tools.cc
index a3877c0b4678d48bd1cf37d82e4476110ac53177..72a7da1c31de191e555aa4d1cc982a1d5cb31446 100644 (file)
--- a/src/rgw/driver/rados/rgw_tools.cc
+++ b/src/rgw/driver/rados/rgw_tools.cc
@@ -285,7 +285,7 @@ int RGWDataAccess::Bucket::finish_init()
 int RGWDataAccess::Bucket::init(const DoutPrefixProvider *dpp, optional_yield y)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int ret = sd->driver->load_bucket(dpp, nullptr, tenant, name, &bucket, y);
+  int ret = sd->driver->load_bucket(dpp, nullptr, rgw_bucket(tenant, name), &bucket, y);
   if (ret < 0) {
     return ret;
   }

diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index 061464f0c2cc9312e66e5ddf885afb0cbe97e678..6ec1e0c6a384161a48176e7a0e4f99861e3338be 100644 (file)
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -1407,7 +1407,9 @@ int set_bucket_quota(rgw::sal::Driver* driver, OPT opt_cmd,
                      bool have_max_size, bool have_max_objects)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int r = driver->load_bucket(dpp(), nullptr, tenant_name, bucket_name, &bucket, null_yield);
+  int r = driver->load_bucket(dpp(), nullptr,
+                              rgw_bucket(tenant_name, bucket_name),
+                              &bucket, null_yield);
   if (r < 0) {
     cerr << "could not get bucket info for bucket=" << bucket_name << ": " << cpp_strerror(-r) << std::endl;
     return -r;
@@ -1431,7 +1433,9 @@ int set_bucket_ratelimit(rgw::sal::Driver* driver, OPT opt_cmd,
                      bool have_max_read_bytes, bool have_max_write_bytes)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int r = driver->load_bucket(dpp(), nullptr, tenant_name, bucket_name, &bucket, null_yield);
+  int r = driver->load_bucket(dpp(), nullptr,
+                              rgw_bucket(tenant_name, bucket_name),
+                              &bucket, null_yield);
   if (r < 0) {
     cerr << "could not get bucket info for bucket=" << bucket_name << ": " << cpp_strerror(-r) << std::endl;
     return -r;
@@ -1534,7 +1538,9 @@ int show_bucket_ratelimit(rgw::sal::Driver* driver, const string& tenant_name,
                           const string& bucket_name, Formatter *formatter)
 {
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int r = driver->load_bucket(dpp(), nullptr, tenant_name, bucket_name, &bucket, null_yield);
+  int r = driver->load_bucket(dpp(), nullptr,
+                              rgw_bucket(tenant_name, bucket_name),
+                              &bucket, null_yield);
   if (r < 0) {
     cerr << "could not get bucket info for bucket=" << bucket_name << ": " << cpp_strerror(-r) << std::endl;
     return -r;

diff --git a/src/rgw/rgw_lc.cc b/src/rgw/rgw_lc.cc
index 862a2d0191c96ff5f012ce839c46e85186c792d6..c2234912e84fd5e5d1d9b132517a23833f32773c 100644 (file)
--- a/src/rgw/rgw_lc.cc
+++ b/src/rgw/rgw_lc.cc
@@ -1615,7 +1615,9 @@ int RGWLC::bucket_lc_process(string& shard_id, LCWorker* worker,
     return 0;
   }
 
-  int ret = driver->load_bucket(this, nullptr, bucket_tenant, bucket_name, &bucket, null_yield);
+  int ret = driver->load_bucket(this, nullptr,
+                                rgw_bucket(bucket_tenant, bucket_name),
+                                &bucket, null_yield);
   if (ret < 0) {
     ldpp_dout(this, 0) << "LC:get_bucket for " << bucket_name
                       << " failed" << dendl;

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 607633534f10bd2839976174875425b62ccc8ff1..067a939d7535eec8d7f6823a485d1400572ad5fd 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -491,8 +491,7 @@ int rgw_build_bucket_policies(const DoutPrefixProvider *dpp, rgw::sal::Driver* d
   if (!s->src_bucket_name.empty()) {
     std::unique_ptr<rgw::sal::Bucket> src_bucket;
     ret = driver->load_bucket(dpp, nullptr,
-                              rgw_bucket_key(s->src_tenant_name,
-                                             s->src_bucket_name),
+                              rgw_bucket(s->src_tenant_name, s->src_bucket_name),
                               &src_bucket, y);
     if (ret == 0) {
       string& zonegroup = src_bucket->get_info().zonegroup;
@@ -1939,8 +1938,9 @@ int RGWGetObj::handle_user_manifest(const char *prefix, optional_yield y)
 
   if (bucket_name.compare(s->bucket->get_name()) != 0) {
     map<string, bufferlist> bucket_attrs;
-    r = driver->load_bucket(this, s->user.get(), s->user->get_tenant(),
-                            bucket_name, &ubucket, y);
+    r = driver->load_bucket(this, s->user.get(),
+                            rgw_bucket(s->user->get_tenant(), bucket_name),
+                            &ubucket, y);
     if (r < 0) {
       ldpp_dout(this, 0) << "could not get bucket info for bucket="
                       << bucket_name << dendl;
@@ -2070,8 +2070,9 @@ int RGWGetObj::handle_slo_manifest(bufferlist& bl, optional_yield y)
        RGWAccessControlPolicy& _bucket_acl = allocated_acls.back();
 
        std::unique_ptr<rgw::sal::Bucket> tmp_bucket;
-       int r = driver->load_bucket(this, s->user.get(), s->user->get_tenant(),
-                                    bucket_name, &tmp_bucket, y);
+       int r = driver->load_bucket(this, s->user.get(),
+                                    rgw_bucket(s->user->get_tenant(), bucket_name),
+                                    &tmp_bucket, y);
         if (r < 0) {
           ldpp_dout(this, 0) << "could not get bucket info for bucket="
                           << bucket_name << dendl;
@@ -3373,8 +3374,9 @@ void RGWCreateBucket::execute(optional_yield y)
    * specific request */
   {
     std::unique_ptr<rgw::sal::Bucket> tmp_bucket;
-    op_ret = driver->load_bucket(this, s->user.get(), s->bucket_tenant,
-                                 s->bucket_name, &tmp_bucket, y);
+    op_ret = driver->load_bucket(this, s->user.get(),
+                                 rgw_bucket(s->bucket_tenant, s->bucket_name),
+                                 &tmp_bucket, y);
     if (op_ret < 0 && op_ret != -ENOENT)
       return;
     s->bucket_exists = (op_ret != -ENOENT);
@@ -3673,8 +3675,10 @@ int RGWPutObj::init_processing(optional_yield y) {
       }
     }
     std::unique_ptr<rgw::sal::Bucket> bucket;
-    ret = driver->load_bucket(this, s->user.get(), copy_source_tenant_name,
-                              copy_source_bucket_name, &bucket, y);
+    ret = driver->load_bucket(this, s->user.get(),
+                              rgw_bucket(copy_source_tenant_name,
+                                         copy_source_bucket_name),
+                              &bucket, y);
     if (ret < 0) {
       ldpp_dout(this, 5) << __func__ << "(): get_bucket() returned ret=" << ret << dendl;
       if (ret == -ENOENT) {
@@ -5357,8 +5361,8 @@ int RGWCopyObj::init_processing(optional_yield y)
   }
 
   op_ret = driver->load_bucket(this, s->user.get(),
-                               rgw_bucket_key(s->src_tenant_name,
-                                              s->src_bucket_name),
+                               rgw_bucket(s->src_tenant_name,
+                                          s->src_bucket_name),
                                &src_bucket, y);
   if (op_ret < 0) {
     if (op_ret == -ENOENT) {
@@ -7315,8 +7319,10 @@ bool RGWBulkDelete::Deleter::delete_single(const acct_path_t& path, optional_yie
   ACLOwner bowner;
   RGWObjVersionTracker ot;
 
-  int ret = driver->load_bucket(dpp, s->user.get(), s->user->get_tenant(),
-                                path.bucket_name, &bucket, y);
+  int ret = driver->load_bucket(dpp, s->user.get(),
+                                rgw_bucket(s->user->get_tenant(),
+                                           path.bucket_name),
+                                &bucket, y);
   if (ret < 0) {
     goto binfo_fail;
   }
@@ -7689,8 +7695,9 @@ int RGWBulkUploadOp::handle_file(const std::string_view path,
   std::unique_ptr<rgw::sal::Bucket> bucket;
   ACLOwner bowner;
 
-  op_ret = driver->load_bucket(this, s->user.get(), s->user->get_tenant(),
-                               bucket_name, &bucket, y);
+  op_ret = driver->load_bucket(this, s->user.get(),
+                               rgw_bucket(s->user->get_tenant(), bucket_name),
+                               &bucket, y);
   if (op_ret < 0) {
     if (op_ret == -ENOENT) {
       ldpp_dout(this, 20) << "non existent directory=" << bucket_name << dendl;

diff --git a/src/rgw/rgw_orphan.cc b/src/rgw/rgw_orphan.cc
index 491b25dacb639d5d42c7ba68a81c397d70f18667..8b9125f29067fc73f945f6076ae6275b89bff96a 100644 (file)
--- a/src/rgw/rgw_orphan.cc
+++ b/src/rgw/rgw_orphan.cc
@@ -1388,7 +1388,8 @@ int RGWRadosList::run(const DoutPrefixProvider *dpp,
     bucket_process_map.erase(front);
 
     std::unique_ptr<rgw::sal::Bucket> bucket;
-    ret = store->load_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, null_yield);
+    ret = store->load_bucket(dpp, nullptr, rgw_bucket(tenant_name, bucket_name),
+                             &bucket, null_yield);
     if (ret == -ENOENT) {
       std::cerr << "WARNING: bucket " << bucket_name <<
        " does not exist; could it have been deleted very recently?" <<
@@ -1459,7 +1460,9 @@ int RGWRadosList::run(const DoutPrefixProvider *dpp,
   // initial bucket
 
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  ret = store->load_bucket(dpp, nullptr, tenant_name, start_bucket_name, &bucket, null_yield);
+  ret = store->load_bucket(dpp, nullptr,
+                           rgw_bucket(tenant_name, start_bucket_name),
+                           &bucket, null_yield);
   if (ret == -ENOENT) {
     // bucket deletion race?
     return 0;

diff --git a/src/rgw/rgw_rest_pubsub.cc b/src/rgw/rgw_rest_pubsub.cc
index c3214123fb88a72316e485dc0f443131bf6f8bb9..d2a1c72f3aa755baa4c7d0ce9bcc2dffdc158ab0 100644 (file)
--- a/src/rgw/rgw_rest_pubsub.cc
+++ b/src/rgw/rgw_rest_pubsub.cc
@@ -962,7 +962,9 @@ void RGWPSCreateNotifOp::execute(optional_yield y) {
 
   std::unique_ptr<rgw::sal::User> user = driver->get_user(s->owner.get_id());
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  op_ret = driver->load_bucket(this, user.get(), s->bucket_tenant, s->bucket_name, &bucket, y);
+  op_ret = driver->load_bucket(this, user.get(),
+                               rgw_bucket(s->bucket_tenant, s->bucket_name),
+                               &bucket, y);
   if (op_ret < 0) {
     ldpp_dout(this, 1) << "failed to get bucket '" << 
       (s->bucket_tenant.empty() ? s->bucket_name : s->bucket_tenant + ":" + s->bucket_name) << 
@@ -1110,7 +1112,9 @@ void RGWPSDeleteNotifOp::execute(optional_yield y) {
 
   std::unique_ptr<rgw::sal::User> user = driver->get_user(s->owner.get_id());
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  op_ret = driver->load_bucket(this, user.get(), s->bucket_tenant, s->bucket_name, &bucket, y);
+  op_ret = driver->load_bucket(this, user.get(),
+                               rgw_bucket(s->bucket_tenant, s->bucket_name),
+                               &bucket, y);
   if (op_ret < 0) {
     ldpp_dout(this, 1) << "failed to get bucket '" << 
       (s->bucket_tenant.empty() ? s->bucket_name : s->bucket_tenant + ":" + s->bucket_name) << 
@@ -1207,7 +1211,9 @@ void RGWPSListNotifsOp::execute(optional_yield y) {
 
   std::unique_ptr<rgw::sal::User> user = driver->get_user(s->owner.get_id());
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  op_ret = driver->load_bucket(this, user.get(), s->bucket_tenant, s->bucket_name, &bucket, y);
+  op_ret = driver->load_bucket(this, user.get(),
+                               rgw_bucket(s->bucket_tenant, s->bucket_name),
+                               &bucket, y);
   if (op_ret < 0) {
     ldpp_dout(this, 1) << "failed to get bucket '" << 
       (s->bucket_tenant.empty() ? s->bucket_name : s->bucket_tenant + ":" + s->bucket_name) << 

diff --git a/src/rgw/rgw_rest_ratelimit.cc b/src/rgw/rgw_rest_ratelimit.cc
index 5e37ad2c74c5ab010d88ad3d97e488a094f73705..e5d1aabb1503dcb1be35bc9cbbaf2bb546e1b13d 100644 (file)
--- a/src/rgw/rgw_rest_ratelimit.cc
+++ b/src/rgw/rgw_rest_ratelimit.cc
@@ -36,7 +36,9 @@ void RGWOp_Ratelimit_Info::execute(optional_yield y)
 
   if (ratelimit_scope == "bucket" && !bucket_name.empty() && !global) {
     std::unique_ptr<rgw::sal::Bucket> bucket;
-    int r = driver->load_bucket(s, nullptr, tenant_name, bucket_name, &bucket, y);
+    int r = driver->load_bucket(s, nullptr,
+                                rgw_bucket(tenant_name, bucket_name),
+                                &bucket, y);
     if (r != 0) {
       op_ret = r;
       ldpp_dout(this, 0) << "Error on getting bucket info" << dendl;
@@ -273,7 +275,9 @@ void RGWOp_Ratelimit_Set::execute(optional_yield y)
   if (ratelimit_scope == "bucket" && !bucket_name.empty() && !global) {
     ldpp_dout(this, 0) << "getting bucket info" << dendl;
     std::unique_ptr<rgw::sal::Bucket> bucket;
-    op_ret = driver->load_bucket(this, nullptr, tenant_name, bucket_name, &bucket, y);
+    op_ret = driver->load_bucket(this, nullptr,
+                                 rgw_bucket(tenant_name, bucket_name),
+                                 &bucket, y);
     if (op_ret) {
       ldpp_dout(this, 0) << "Error on getting bucket info" << dendl;
       return;

diff --git a/src/rgw/rgw_rest_swift.cc b/src/rgw/rgw_rest_swift.cc
index 082bccf7fb2a468bb8ae3f191da6397980582f76..7ef73285583baa2f0e08b8a3fecb1cf1b8625d85 100644 (file)
--- a/src/rgw/rgw_rest_swift.cc
+++ b/src/rgw/rgw_rest_swift.cc
@@ -857,7 +857,9 @@ int RGWPutObj_ObjStore_SWIFT::update_slo_segment_size(rgw_slo_entry& entry) {
   std::unique_ptr<rgw::sal::Bucket> bucket;
 
   if (bucket_name.compare(s->bucket->get_name()) != 0) {
-    r = driver->load_bucket(s, s->user.get(), s->user->get_id().tenant, bucket_name, &bucket, s->yield);
+    r = driver->load_bucket(s, s->user.get(),
+                            rgw_bucket(s->user->get_id().tenant, bucket_name),
+                            &bucket, s->yield);
     if (r < 0) {
       ldpp_dout(this, 0) << "could not get bucket info for bucket="
                         << bucket_name << dendl;
@@ -2120,7 +2122,9 @@ void RGWFormPost::get_owner_info(const req_state* const s,
 
   /* Need to get user info of bucket owner. */
   std::unique_ptr<rgw::sal::Bucket> bucket;
-  int ret = driver->load_bucket(s, user.get(), bucket_tenant, bucket_name, &bucket, s->yield);
+  int ret = driver->load_bucket(s, user.get(),
+                                rgw_bucket(bucket_tenant, bucket_name),
+                                &bucket, s->yield);
   if (ret < 0) {
     throw ret;
   }

diff --git a/src/rgw/rgw_rest_usage.cc b/src/rgw/rgw_rest_usage.cc
index 5f9d5c8a52983c17f21c2d20bc7f8ca35a03e671..65b035c00727bc9b2273f74affe53b8114cb653b 100644 (file)
--- a/src/rgw/rgw_rest_usage.cc
+++ b/src/rgw/rgw_rest_usage.cc
@@ -40,7 +40,9 @@ void RGWOp_Usage_Get::execute(optional_yield y) {
   std::unique_ptr<rgw::sal::Bucket> bucket;
 
   if (!bucket_name.empty()) {
-    op_ret = driver->load_bucket(nullptr, user.get(), std::string(), bucket_name, &bucket, null_yield);
+    op_ret = driver->load_bucket(nullptr, user.get(),
+                                 rgw_bucket(std::string(), bucket_name),
+                                 &bucket, null_yield);
     if (op_ret < 0) {
       return;
     }
@@ -90,7 +92,9 @@ void RGWOp_Usage_Delete::execute(optional_yield y) {
   std::unique_ptr<rgw::sal::Bucket> bucket;
 
   if (!bucket_name.empty()) {
-    op_ret = driver->load_bucket(nullptr, user.get(), std::string(), bucket_name, &bucket, null_yield);
+    op_ret = driver->load_bucket(nullptr, user.get(),
+                                 rgw_bucket(std::string(), bucket_name),
+                                 &bucket, null_yield);
     if (op_ret < 0) {
       return;
     }