rgw: No null_yield in rgw_role

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index 5651019cfb3e710d10ace32e6544888f5b7312a1..a42cb6b44853599e5c9d15b1d9af392bc410b73a 100644 (file)
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -5783,7 +5783,7 @@ int main(int argc, const char **argv)
         return -EINVAL;
       }
       RGWRole role(g_ceph_context, store->getRados()->pctl, role_name, tenant);
-      ret = role.get();
+      ret = role.get(null_yield);
       if (ret < 0) {
         return -ret;
       }
@@ -5811,7 +5811,7 @@ int main(int argc, const char **argv)
       }
 
       RGWRole role(g_ceph_context, store->getRados()->pctl, role_name, tenant);
-      ret = role.get();
+      ret = role.get(null_yield);
       if (ret < 0) {
         return -ret;
       }
@@ -5826,7 +5826,7 @@ int main(int argc, const char **argv)
   case OPT::ROLE_LIST:
     {
       vector<RGWRole> result;
-      ret = RGWRole::get_roles_by_path_prefix(store->getRados(), g_ceph_context, path_prefix, tenant, result);
+      ret = RGWRole::get_roles_by_path_prefix(store->getRados(), g_ceph_context, path_prefix, tenant, result, null_yield);
       if (ret < 0) {
         return -ret;
       }
@@ -5859,7 +5859,7 @@ int main(int argc, const char **argv)
       }
 
       RGWRole role(g_ceph_context, store->getRados()->pctl, role_name, tenant);
-      ret = role.get();
+      ret = role.get(null_yield);
       if (ret < 0) {
         return -ret;
       }
@@ -5878,7 +5878,7 @@ int main(int argc, const char **argv)
         return -EINVAL;
       }
       RGWRole role(g_ceph_context, store->getRados()->pctl, role_name, tenant);
-      ret = role.get();
+      ret = role.get(null_yield);
       if (ret < 0) {
         return -ret;
       }
@@ -5898,7 +5898,7 @@ int main(int argc, const char **argv)
         return -EINVAL;
       }
       RGWRole role(g_ceph_context, store->getRados()->pctl, role_name, tenant);
-      int ret = role.get();
+      int ret = role.get(null_yield);
       if (ret < 0) {
         return -ret;
       }
@@ -5922,7 +5922,7 @@ int main(int argc, const char **argv)
         return -EINVAL;
       }
       RGWRole role(g_ceph_context, store->getRados()->pctl, role_name, tenant);
-      ret = role.get();
+      ret = role.get(null_yield);
       if (ret < 0) {
         return -ret;
       }

diff --git a/src/rgw/rgw_bucket.cc b/src/rgw/rgw_bucket.cc
index 34151df1fc7938507b28609b959f6ac5a7b55b71..9234a66630c656c8e9cea156a19ab6f5ef0a3410 100644 (file)
--- a/src/rgw/rgw_bucket.cc
+++ b/src/rgw/rgw_bucket.cc
@@ -1263,7 +1263,7 @@ int RGWBucketAdminOp::remove_bucket(rgw::sal::RGWRadosStore *store, RGWBucketAdm
   std::unique_ptr<rgw::sal::RGWUser> user = store->get_user(op_state.get_user_id());
 
   int ret = store->get_bucket(user.get(), user->get_tenant(), op_state.get_bucket_name(),
-                             &bucket);
+                             &bucket, y);
   if (ret < 0)
     return ret;
 

diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index 1c0d786dbc255eb19094907be72ba49975b0a8a0..33909d8fc20059416b305dc7ba8d8ab324a07cff 100644 (file)
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -540,7 +540,7 @@ int rgw_build_bucket_policies(rgw::sal::RGWRadosStore* store, struct req_state*
   /* check if copy source is within the current domain */
   if (!s->src_bucket_name.empty()) {
     std::unique_ptr<rgw::sal::RGWBucket> src_bucket;
-    ret = store->get_bucket(nullptr, s->src_tenant_name, s->src_bucket_name, &src_bucket);
+    ret = store->get_bucket(nullptr, s->src_tenant_name, s->src_bucket_name, &src_bucket, y);
     if (ret == 0) {
       ret = src_bucket->load_by_name(s->src_tenant_name, s->src_bucket_name,
                                     s->bucket_instance_id, &obj_ctx, s->yield);
@@ -562,7 +562,7 @@ int rgw_build_bucket_policies(rgw::sal::RGWRadosStore* store, struct req_state*
   if (!s->bucket_name.empty()) {
     s->bucket_exists = true;
 
-    ret = store->get_bucket(s->user.get(), rgw_bucket(rgw_bucket_key(s->bucket_tenant, s->bucket_name, s->bucket_instance_id)), &s->bucket);
+    ret = store->get_bucket(s->user.get(), rgw_bucket(rgw_bucket_key(s->bucket_tenant, s->bucket_name, s->bucket_instance_id)), &s->bucket, y);
     if (ret < 0) {
       if (ret != -ENOENT) {
        string bucket_log;
@@ -1813,7 +1813,7 @@ 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 = store->get_bucket(s->user.get(), s->user->get_tenant(), bucket_name, &ubucket);
+    r = store->get_bucket(s->user.get(), 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;
@@ -1942,7 +1942,7 @@ int RGWGetObj::handle_slo_manifest(bufferlist& bl, optional_yield y)
 
        std::unique_ptr<rgw::sal::RGWBucket> tmp_bucket;
         auto obj_ctx = store->svc()->sysobj->init_obj_ctx();
-       int r = store->get_bucket(s->user.get(), s->user->get_tenant(), bucket_name, &tmp_bucket);
+       int r = store->get_bucket(s->user.get(), 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;
@@ -2742,7 +2742,7 @@ void RGWStatBucket::execute(optional_yield y)
     return;
   }
 
-  op_ret = store->get_bucket(s->user.get(), s->bucket->get_key(), &bucket);
+  op_ret = store->get_bucket(s->user.get(), s->bucket->get_key(), &bucket, y);
   if (op_ret) {
     return;
   }
@@ -3103,7 +3103,7 @@ void RGWCreateBucket::execute(optional_yield y)
 
   /* we need to make sure we read bucket info, it's not read before for this
    * specific request */
-  op_ret = store->get_bucket(s->user.get(), s->bucket_tenant, s->bucket_name, &s->bucket);
+  op_ret = store->get_bucket(s->user.get(), s->bucket_tenant, s->bucket_name, &s->bucket, y);
   if (op_ret < 0 && op_ret != -ENOENT)
     return;
   s->bucket_exists = (op_ret != -ENOENT);
@@ -6627,7 +6627,7 @@ bool RGWBulkDelete::Deleter::delete_single(const acct_path_t& path, optional_yie
   ACLOwner bowner;
   RGWObjVersionTracker ot;
 
-  int ret = store->get_bucket(s->user.get(), s->user->get_tenant(), path.bucket_name, &bucket);
+  int ret = store->get_bucket(s->user.get(), s->user->get_tenant(), path.bucket_name, &bucket, y);
   if (ret < 0) {
     goto binfo_fail;
   }
@@ -7018,7 +7018,7 @@ int RGWBulkUploadOp::handle_file(const std::string_view path,
   std::unique_ptr<rgw::sal::RGWBucket> bucket;
   ACLOwner bowner;
 
-  op_ret = store->get_bucket(s->user.get(), rgw_bucket(rgw_bucket_key(s->user->get_tenant(), bucket_name)), &bucket);
+  op_ret = store->get_bucket(s->user.get(), rgw_bucket(rgw_bucket_key(s->user->get_tenant(), bucket_name)), &bucket, y);
   if (op_ret == -ENOENT) {
     ldpp_dout(this, 20) << "non existent directory=" << bucket_name << dendl;
   } else if (op_ret < 0) {

diff --git a/src/rgw/rgw_op.h b/src/rgw/rgw_op.h
index aba79892fe0f6d6f4afcacc98441c3c0a060efc9..cbe856172413b25fd3121ebc8db9cdf013ae75fa 100644 (file)
--- a/src/rgw/rgw_op.h
+++ b/src/rgw/rgw_op.h
@@ -101,7 +101,7 @@ public:
     return 0;
   }
 
-  virtual int retarget(RGWOp* op, RGWOp** new_op) {
+  virtual int retarget(RGWOp* op, RGWOp** new_op, optional_yield) {
     *new_op = op;
     return 0;
   }

diff --git a/src/rgw/rgw_process.cc b/src/rgw/rgw_process.cc
index d78053222f27704c18299a034e84107509d70600..b95ed15082cc059d8b13ba8bc2ef8b83cce870aa 100644 (file)
--- a/src/rgw/rgw_process.cc
+++ b/src/rgw/rgw_process.cc
@@ -106,7 +106,7 @@ int rgw_process_authenticated(RGWHandler_REST * const handler,
    */
   if (! skip_retarget) {
     ldpp_dout(op, 2) << "recalculating target" << dendl;
-    ret = handler->retarget(op, &op);
+    ret = handler->retarget(op, &op, y);
     if (ret < 0) {
       return ret;
     }

diff --git a/src/rgw/rgw_rest_bucket.cc b/src/rgw/rgw_rest_bucket.cc
index eb805b29890b9f077ce34432ebe60ff007095a9e..a007e3be8a6ff35e445293e0fb6f51674c2d767e 100644 (file)
--- a/src/rgw/rgw_rest_bucket.cc
+++ b/src/rgw/rgw_rest_bucket.cc
@@ -219,7 +219,7 @@ void RGWOp_Bucket_Remove::execute(optional_yield y)
   RESTArgs::get_string(s, "bucket", bucket_name, &bucket_name);
   RESTArgs::get_bool(s, "purge-objects", false, &delete_children);
 
-  op_ret = store->get_bucket(nullptr, string(), bucket_name, &bucket);
+  op_ret = store->get_bucket(nullptr, string(), bucket_name, &bucket, y);
   if (op_ret < 0) {
     ldpp_dout(this, 0) << "get_bucket returned ret=" << op_ret << dendl;
     return;

diff --git a/src/rgw/rgw_rest_role.cc b/src/rgw/rgw_rest_role.cc
index d64f44c28180188f2a77a44049a29e8e9f08e558..13e1c37e413bc2f5ec875ae25414eecdf4bc69d4 100644 (file)
--- a/src/rgw/rgw_rest_role.cc
+++ b/src/rgw/rgw_rest_role.cc
@@ -27,7 +27,7 @@ int RGWRestRole::verify_permission(optional_yield y)
 
   string role_name = s->info.args.get("RoleName");
   RGWRole role(s->cct, store->getRados()->pctl, role_name, s->user->get_tenant());
-  if (op_ret = role.get(); op_ret < 0) {
+  if (op_ret = role.get(y); op_ret < 0) {
     if (op_ret == -ENOENT) {
       op_ret = -ERR_NO_ROLE_FOUND;
     }
@@ -230,7 +230,7 @@ void RGWGetRole::execute(optional_yield y)
     return;
   }
   RGWRole role(s->cct, store->getRados()->pctl, role_name, s->user->get_tenant());
-  op_ret = role.get();
+  op_ret = role.get(y);
 
   if (op_ret == -ENOENT) {
     op_ret = -ERR_NO_ROLE_FOUND;
@@ -322,7 +322,7 @@ void RGWListRoles::execute(optional_yield y)
     return;
   }
   vector<RGWRole> result;
-  op_ret = RGWRole::get_roles_by_path_prefix(store->getRados(), s->cct, path_prefix, s->user->get_tenant(), result);
+  op_ret = RGWRole::get_roles_by_path_prefix(store->getRados(), s->cct, path_prefix, s->user->get_tenant(), result, y);
 
   if (op_ret == 0) {
     s->formatter->open_array_section("ListRolesResponse");

diff --git a/src/rgw/rgw_rest_s3.cc b/src/rgw/rgw_rest_s3.cc
index 4a6660a87e00addd3e3a4177656e5fd631ad97d4..e61327e34c1ef644957e370f8e7ce09a60c98005 100644 (file)
--- a/src/rgw/rgw_rest_s3.cc
+++ b/src/rgw/rgw_rest_s3.cc
@@ -4910,14 +4910,14 @@ int RGWHandler_REST_S3Website::init(rgw::sal::RGWRadosStore *store, req_state *s
   return RGWHandler_REST_S3::init(store, s, cio);
 }
 
-int RGWHandler_REST_S3Website::retarget(RGWOp* op, RGWOp** new_op) {
+int RGWHandler_REST_S3Website::retarget(RGWOp* op, RGWOp** new_op, optional_yield y) {
   *new_op = op;
   ldpp_dout(s, 10) << __func__ << " Starting retarget" << dendl;
 
   if (!(s->prot_flags & RGW_REST_WEBSITE))
     return 0;
 
-  int ret = store->get_bucket(nullptr, s->bucket_tenant, s->bucket_name, &s->bucket);
+  int ret = store->get_bucket(nullptr, s->bucket_tenant, s->bucket_name, &s->bucket, y);
   if (ret < 0) {
       // TODO-FUTURE: if the bucket does not exist, maybe expose it here?
       return -ERR_NO_SUCH_BUCKET;
@@ -5877,7 +5877,7 @@ rgw::auth::s3::STSEngine::authenticate(
   rgw::auth::RoleApplier::Role r;
   if (! token.roleId.empty()) {
     RGWRole role(s->cct, ctl, token.roleId);
-    if (role.get_by_id() < 0) {
+    if (role.get_by_id(y) < 0) {
       return result_t::deny(-EPERM);
     }
     r.id = token.roleId;

diff --git a/src/rgw/rgw_rest_s3website.h b/src/rgw/rgw_rest_s3website.h
index db302fb89c4d7b8855c16f0e38ae84c6ed86f367..c363eb563b95e54f8c2f1037a31a243fd10c5338 100644 (file)
--- a/src/rgw/rgw_rest_s3website.h
+++ b/src/rgw/rgw_rest_s3website.h
@@ -21,7 +21,7 @@ class RGWHandler_REST_S3Website : public RGWHandler_REST_S3 {
   std::string original_object_name; // object name before retarget()
   bool web_dir() const;
 protected:
-  int retarget(RGWOp *op, RGWOp **new_op) override;
+  int retarget(RGWOp *op, RGWOp **new_op, optional_yield y) override;
   // TODO: this should be virtual I think, and ensure that it's always
   // overridden, but that conflates that op_get/op_head are defined in this
   // class and call this; and don't need to be overridden later.

diff --git a/src/rgw/rgw_rest_sts.cc b/src/rgw/rgw_rest_sts.cc
index d980eab26148e3b76c41f177777c6ffe0f26ed64..75a808aa8c9b77152b69627f0374adbe51e92185 100644 (file)
--- a/src/rgw/rgw_rest_sts.cc
+++ b/src/rgw/rgw_rest_sts.cc
@@ -362,7 +362,7 @@ int RGWREST_STS::verify_permission(optional_yield y)
   sts = std::move(_sts);
 
   string rArn = s->info.args.get("RoleArn");
-  const auto& [ret, role] = sts.getRoleInfo(rArn);
+  const auto& [ret, role] = sts.getRoleInfo(rArn, y);
   if (ret < 0) {
     ldout(s->cct, 0) << "failed to get role info using role arn: " << rArn << dendl;
     return ret;

diff --git a/src/rgw/rgw_rest_swift.h b/src/rgw/rgw_rest_swift.h
index bc94375d983706c451aad45051c89ac04c199b03..01f25b101ad82a0f9189d01ddd8c08b9bfd7081e 100644 (file)
--- a/src/rgw/rgw_rest_swift.h
+++ b/src/rgw/rgw_rest_swift.h
@@ -439,7 +439,7 @@ public:
     return website_handler->error_handler(err_no, error_content, y);
   }
 
-  int retarget(RGWOp* op, RGWOp** new_op) override {
+  int retarget(RGWOp* op, RGWOp** new_op, optional_yield) override {
     return website_handler->retarget_bucket(op, new_op);
   }
 
@@ -478,7 +478,7 @@ public:
     return website_handler->error_handler(err_no, error_content, y);
   }
 
-  int retarget(RGWOp* op, RGWOp** new_op) override {
+  int retarget(RGWOp* op, RGWOp** new_op, optional_yield) override {
     return website_handler->retarget_object(op, new_op);
   }
 

diff --git a/src/rgw/rgw_role.cc b/src/rgw/rgw_role.cc
index 862b1d2b7eb39bcfe11dc231ca91fefa29ffe0c8..9ed173131d559cdfab837117e940fd4b44ac539f 100644 (file)
--- a/src/rgw/rgw_role.cc
+++ b/src/rgw/rgw_role.cc
@@ -84,7 +84,7 @@ int RGWRole::create(bool exclusive, optional_yield y)
   }
 
   /* check to see the name is not used */
-  ret = read_id(name, tenant, id);
+  ret = read_id(name, tenant, id, y);
   if (exclusive && ret == 0) {
     ldout(cct, 0) << "ERROR: name " << name << " already in use for role id "
                     << id << dendl;
@@ -171,12 +171,12 @@ int RGWRole::delete_obj(optional_yield y)
   auto svc = ctl->svc;
   auto& pool = svc->zone->get_zone_params().roles_pool;
 
-  int ret = read_name();
+  int ret = read_name(y);
   if (ret < 0) {
     return ret;
   }
 
-  ret = read_info();
+  ret = read_info(y);
   if (ret < 0) {
     return ret;
   }
@@ -211,14 +211,14 @@ int RGWRole::delete_obj(optional_yield y)
   return ret;
 }
 
-int RGWRole::get()
+int RGWRole::get(optional_yield y)
 {
-  int ret = read_name();
+  int ret = read_name(y);
   if (ret < 0) {
     return ret;
   }
 
-  ret = read_info();
+  ret = read_info(y);
   if (ret < 0) {
     return ret;
   }
@@ -226,9 +226,9 @@ int RGWRole::get()
   return 0;
 }
 
-int RGWRole::get_by_id()
+int RGWRole::get_by_id(optional_yield y)
 {
-  int ret = read_info();
+  int ret = read_info(y);
   if (ret < 0) {
     return ret;
   }
@@ -312,7 +312,7 @@ void RGWRole::decode_json(JSONObj *obj)
   JSONDecoder::decode_json("assume_role_policy_document", trust_policy, obj);
 }
 
-int RGWRole::read_id(const string& role_name, const string& tenant, string& role_id)
+int RGWRole::read_id(const string& role_name, const string& tenant, string& role_id, optional_yield y)
 {
   auto svc = ctl->svc;
   auto& pool = svc->zone->get_zone_params().roles_pool;
@@ -320,7 +320,7 @@ int RGWRole::read_id(const string& role_name, const string& tenant, string& role
   bufferlist bl;
   auto obj_ctx = svc->sysobj->init_obj_ctx();
 
-  int ret = rgw_get_system_obj(obj_ctx, pool, oid, bl, NULL, NULL, null_yield);
+  int ret = rgw_get_system_obj(obj_ctx, pool, oid, bl, NULL, NULL, y);
   if (ret < 0) {
     return ret;
   }
@@ -339,7 +339,7 @@ int RGWRole::read_id(const string& role_name, const string& tenant, string& role
   return 0;
 }
 
-int RGWRole::read_info()
+int RGWRole::read_info(optional_yield y)
 {
   auto svc = ctl->svc;
   auto& pool = svc->zone->get_zone_params().roles_pool;
@@ -347,7 +347,7 @@ int RGWRole::read_info()
   bufferlist bl;
   auto obj_ctx = svc->sysobj->init_obj_ctx();
 
-  int ret = rgw_get_system_obj(obj_ctx, pool, oid, bl, NULL, NULL, null_yield);
+  int ret = rgw_get_system_obj(obj_ctx, pool, oid, bl, NULL, NULL, y);
   if (ret < 0) {
     ldout(cct, 0) << "ERROR: failed reading role info from pool: " << pool.name <<
                   ": " << id << ": " << cpp_strerror(-ret) << dendl;
@@ -367,7 +367,7 @@ int RGWRole::read_info()
   return 0;
 }
 
-int RGWRole::read_name()
+int RGWRole::read_name(optional_yield y)
 {
   auto svc = ctl->svc;
   auto& pool = svc->zone->get_zone_params().roles_pool;
@@ -375,7 +375,7 @@ int RGWRole::read_name()
   bufferlist bl;
   auto obj_ctx = svc->sysobj->init_obj_ctx();
 
-  int ret = rgw_get_system_obj(obj_ctx, pool, oid, bl, NULL, NULL, null_yield);
+  int ret = rgw_get_system_obj(obj_ctx, pool, oid, bl, NULL, NULL, y);
   if (ret < 0) {
     ldout(cct, 0) << "ERROR: failed reading role name from pool: " << pool.name << ": "
                   << name << ": " << cpp_strerror(-ret) << dendl;
@@ -446,7 +446,8 @@ int RGWRole::get_roles_by_path_prefix(RGWRados *store,
                                       CephContext *cct,
                                       const string& path_prefix,
                                       const string& tenant,
-                                      vector<RGWRole>& roles)
+                                      vector<RGWRole>& roles,
+                                     optional_yield y)
 {
   auto pool = store->svc.zone->get_zone_params().roles_pool;
   string prefix;
@@ -492,7 +493,7 @@ int RGWRole::get_roles_by_path_prefix(RGWRados *store,
 
       RGWRole role(cct, store->pctl);
       role.set_id(id);
-      int ret = role.read_info();
+      int ret = role.read_info(y);
       if (ret < 0) {
         return ret;
       }

diff --git a/src/rgw/rgw_role.h b/src/rgw/rgw_role.h
index 02f4ec8374103404579b8b9b7aea0a4eaaf3611f..d72c5ecba470758ab9437457d4c5e9963ae0cbfb 100644 (file)
--- a/src/rgw/rgw_role.h
+++ b/src/rgw/rgw_role.h
@@ -13,7 +13,7 @@
 
 #include "rgw/rgw_rados.h"
 
-class RGWCtl;
+struct RGWCtl;
 
 class RGWRole
 {
@@ -42,9 +42,9 @@ class RGWRole
   int store_info(bool exclusive, optional_yield y);
   int store_name(bool exclusive, optional_yield y);
   int store_path(bool exclusive, optional_yield y);
-  int read_id(const string& role_name, const string& tenant, string& role_id);
-  int read_name();
-  int read_info();
+  int read_id(const string& role_name, const string& tenant, string& role_id, optional_yield y);
+  int read_name(optional_yield y);
+  int read_info(optional_yield y);
   bool validate_input();
   void extract_name_tenant(const std::string& str);
 
@@ -143,8 +143,8 @@ public:
 
   int create(bool exclusive, optional_yield y);
   int delete_obj(optional_yield y);
-  int get();
-  int get_by_id();
+  int get(optional_yield y);
+  int get_by_id(optional_yield y);
   int update(optional_yield y);
   void update_trust_policy(string& trust_policy);
   void set_perm_policy(const string& policy_name, const string& perm_policy);
@@ -161,7 +161,8 @@ public:
                                       CephContext *cct,
                                       const string& path_prefix,
                                       const string& tenant,
-                                      vector<RGWRole>& roles);
+                                      vector<RGWRole>& roles,
+                                     optional_yield y);
 };
 WRITE_CLASS_ENCODER(RGWRole)
 #endif /* CEPH_RGW_ROLE_H */

diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h
index 054f893354cb5e94ade42985ef6cf83d081d91c0..a7e10c79efa268dec19f6aef0180a56c372b3d1d 100644 (file)
--- a/src/rgw/rgw_sal.h
+++ b/src/rgw/rgw_sal.h
@@ -53,9 +53,9 @@ class RGWStore : public DoutPrefixProvider {
 
     virtual std::unique_ptr<RGWUser> get_user(const rgw_user& u) = 0;
     virtual std::unique_ptr<RGWObject> get_object(const rgw_obj_key& k) = 0;
-    virtual int get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket) = 0;
+    virtual int get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket, optional_yield y) = 0;
     virtual int get_bucket(RGWUser* u, const RGWBucketInfo& i, std::unique_ptr<RGWBucket>* bucket) = 0;
-    virtual int get_bucket(RGWUser* u, const std::string& tenant, const std::string&name, std::unique_ptr<RGWBucket>* bucket) = 0;
+    virtual int get_bucket(RGWUser* u, const std::string& tenant, const std::string&name, std::unique_ptr<RGWBucket>* bucket, optional_yield y) = 0;
     virtual int create_bucket(RGWUser& u, const rgw_bucket& b,
                             const std::string& zonegroup_id,
                             rgw_placement_rule& placement_rule,

diff --git a/src/rgw/rgw_sal_rados.cc b/src/rgw/rgw_sal_rados.cc
index 5d92ab6f3d954c12bff7866f107b0c673fca246d..a1757cf5fe1315dcd5f7a87bae3d10c36dc2e881 100644 (file)
--- a/src/rgw/rgw_sal_rados.cc
+++ b/src/rgw/rgw_sal_rados.cc
@@ -139,14 +139,14 @@ int RGWRadosBucket::remove_bucket(bool delete_children, std::string prefix, std:
 
   // if we deleted children above we will force delete, as any that
   // remain is detrius from a prior bug
-  ret = store->getRados()->delete_bucket(info, ot, null_yield, !delete_children);
+  ret = store->getRados()->delete_bucket(info, ot, y, !delete_children);
   if (ret < 0) {
     lderr(store->ctx()) << "ERROR: could not remove bucket " <<
       info.bucket.name << dendl;
     return ret;
   }
 
-  ret = store->ctl()->bucket->unlink_bucket(info.owner, info.bucket, null_yield, false);
+  ret = store->ctl()->bucket->unlink_bucket(info.owner, info.bucket, y, false);
   if (ret < 0) {
     lderr(store->ctx()) << "ERROR: unable to remove user bucket information" << dendl;
   }
@@ -331,7 +331,7 @@ int RGWRadosBucket::set_acl(RGWAccessControlPolicy &acl, optional_yield y)
   acls = acl;
   acl.encode(aclbl);
 
-  return store->ctl()->bucket->set_acl(acl.get_owner(), info.bucket, info, aclbl, null_yield);
+  return store->ctl()->bucket->set_acl(acl.get_owner(), info.bucket, info, aclbl, y);
 }
 
 std::unique_ptr<RGWObject> RGWRadosBucket::get_object(const rgw_obj_key& k)
@@ -694,13 +694,13 @@ int RGWRadosObject::RadosReadOp::iterate(int64_t ofs, int64_t end, RGWGetDataCB
   return parent_op.iterate(ofs, end, cb, y);
 }
 
-int RGWRadosStore::get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket)
+int RGWRadosStore::get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket, optional_yield y)
 {
   int ret;
   RGWBucket* bp;
 
   bp = new RGWRadosBucket(this, b, u);
-  ret = bp->get_bucket_info(null_yield);
+  ret = bp->get_bucket_info(y);
   if (ret < 0) {
     delete bp;
     return ret;
@@ -721,14 +721,14 @@ int RGWRadosStore::get_bucket(RGWUser* u, const RGWBucketInfo& i, std::unique_pt
   return 0;
 }
 
-int RGWRadosStore::get_bucket(RGWUser* u, const std::string& tenant, const std::string&name, std::unique_ptr<RGWBucket>* bucket)
+int RGWRadosStore::get_bucket(RGWUser* u, const std::string& tenant, const std::string&name, std::unique_ptr<RGWBucket>* bucket, optional_yield y)
 {
   rgw_bucket b;
 
   b.tenant = tenant;
   b.name = name;
 
-  return get_bucket(u, b, bucket);
+  return get_bucket(u, b, bucket, y);
 }
 
 static int decode_policy(CephContext *cct,
@@ -752,9 +752,10 @@ static int decode_policy(CephContext *cct,
 }
 
 static int rgw_op_get_bucket_policy_from_attr(RGWRadosStore *store,
-                                      RGWUser& user,
-                                      RGWAttrs& bucket_attrs,
-                                      RGWAccessControlPolicy *policy)
+                                             RGWUser& user,
+                                             RGWAttrs& bucket_attrs,
+                                             RGWAccessControlPolicy *policy,
+                                             optional_yield y)
 {
   auto aiter = bucket_attrs.find(RGW_ATTR_ACL);
 
@@ -765,7 +766,7 @@ static int rgw_op_get_bucket_policy_from_attr(RGWRadosStore *store,
   } else {
     ldout(store->ctx(), 0) << "WARNING: couldn't find acl header for bucket, generating default" << dendl;
     /* object exists, but policy is broken */
-    int r = user.load_by_id(null_yield);
+    int r = user.load_by_id(y);
     if (r < 0)
       return r;
 
@@ -852,7 +853,7 @@ int RGWRadosStore::create_bucket(RGWUser& u, const rgw_bucket& b,
   obj_version objv, *pobjv = NULL;
 
   /* If it exists, look it up; otherwise create it */
-  ret = get_bucket(&u, b, &bucket);
+  ret = get_bucket(&u, b, &bucket, y);
   if (ret < 0 && ret != -ENOENT)
     return ret;
 
@@ -866,7 +867,7 @@ int RGWRadosStore::create_bucket(RGWUser& u, const rgw_bucket& b,
 
     // don't allow changes to the acl policy
     int r = rgw_op_get_bucket_policy_from_attr(this, u, bucket->get_attrs(),
-                                              &old_policy);
+                                              &old_policy, y);
     if (r >= 0 && old_policy != policy) {
       bucket_out->swap(bucket);
       return -EEXIST;

diff --git a/src/rgw/rgw_sal_rados.h b/src/rgw/rgw_sal_rados.h
index 06fca75ccfe06b15cc841911074d23e313fe46b8..bd705e7b0fd0878944e1a80cf6837db377d3f6eb 100644 (file)
--- a/src/rgw/rgw_sal_rados.h
+++ b/src/rgw/rgw_sal_rados.h
@@ -232,9 +232,9 @@ class RGWRadosStore : public RGWStore {
 
     virtual std::unique_ptr<RGWUser> get_user(const rgw_user& u);
     virtual std::unique_ptr<RGWObject> get_object(const rgw_obj_key& k) override;
-    virtual int get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket) override;
+    virtual int get_bucket(RGWUser* u, const rgw_bucket& b, std::unique_ptr<RGWBucket>* bucket, optional_yield y) override;
     virtual int get_bucket(RGWUser* u, const RGWBucketInfo& i, std::unique_ptr<RGWBucket>* bucket) override;
-    virtual int get_bucket(RGWUser* u, const std::string& tenant, const std::string&name, std::unique_ptr<RGWBucket>* bucket) override;
+    virtual int get_bucket(RGWUser* u, const std::string& tenant, const std::string&name, std::unique_ptr<RGWBucket>* bucket, optional_yield y) override;
     virtual int create_bucket(RGWUser& u, const rgw_bucket& b,
                             const std::string& zonegroup_id,
                             rgw_placement_rule& placement_rule,

diff --git a/src/rgw/rgw_sts.cc b/src/rgw/rgw_sts.cc
index a6feb2b23c7fced2fcaa7989c89394d100224642..8149ba1cabd606c425578b551a20a3f1196deb11 100644 (file)
--- a/src/rgw/rgw_sts.cc
+++ b/src/rgw/rgw_sts.cc
@@ -276,13 +276,14 @@ int AssumeRoleRequest::validate_input() const
   return AssumeRoleRequestBase::validate_input();
 }
 
-std::tuple<int, RGWRole> STSService::getRoleInfo(const string& arn)
+std::tuple<int, RGWRole> STSService::getRoleInfo(const string& arn,
+                                                optional_yield y)
 {
   if (auto r_arn = rgw::ARN::parse(arn); r_arn) {
     auto pos = r_arn->resource.find_last_of('/');
     string roleName = r_arn->resource.substr(pos + 1);
     RGWRole role(cct, store->getRados()->pctl, roleName, r_arn->account);
-    if (int ret = role.get(); ret < 0) {
+    if (int ret = role.get(y); ret < 0) {
       if (ret == -ENOENT) {
         ldout(cct, 0) << "Role doesn't exist: " << roleName << dendl;
         ret = -ERR_NO_ROLE_FOUND;

diff --git a/src/rgw/rgw_sts.h b/src/rgw/rgw_sts.h
index a721bdc9873c1f74ff5646dcd0c141e797d0855f..a54ef3e1028f4270c9cdb305f188bbf170ae99fc 100644 (file)
--- a/src/rgw/rgw_sts.h
+++ b/src/rgw/rgw_sts.h
@@ -235,7 +235,7 @@ public:
   STSService(CephContext* cct, rgw::sal::RGWRadosStore *store, rgw_user user_id,
             rgw::auth::Identity* identity)
     : cct(cct), store(store), user_id(user_id), identity(identity) {}
-  std::tuple<int, RGWRole> getRoleInfo(const string& arn);
+  std::tuple<int, RGWRole> getRoleInfo(const string& arn, optional_yield y);
   AssumeRoleResponse assumeRole(AssumeRoleRequest& req, optional_yield y);
   GetSessionTokenResponse getSessionToken(GetSessionTokenRequest& req);
   AssumeRoleWithWebIdentityResponse assumeRoleWithWebIdentity(AssumeRoleWithWebIdentityRequest& req);