RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-02-24 11:37:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

src/rados: Changing null_yield to optional_yield

Browse Source 
Passing optional_yield at all places in rgw_bucket.cc

Signed-off-by: Kalpesh Pandya <kapandya@redhat.com>
This commit is contained in:
Kalpesh Pandya 2023-02-16 13:25:39 +05:30
parent dee8dfeedc
commit de766abe5b
5 changed files with 93 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
src/rgw/driver/rados/rgw_bucket.cc
View File

@ -142,7 +142,7 @@ bool rgw_bucket_object_check_filter(const std::string& oid)
return rgw_obj_key::oid_to_key_in_ns(oid, &key, empty_ns);
}
int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key)
int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key, optional_yield y)
{
if (key.instance.empty()) {
key.instance = "null";
@ -150,7 +150,7 @@ int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, r
std::unique_ptr<rgw::sal::Object> object = bucket->get_object(key);
return object->delete_object(dpp, null_yield);
return object->delete_object(dpp, y);
}
static void set_err_msg(std::string *sink, std::string msg)
@ -267,7 +267,7 @@ int RGWBucket::set_quota(RGWBucketAdminOpState& op_state, const DoutPrefixProvid
return r;
}
int RGWBucket::remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, std::string *err_msg)
int RGWBucket::remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg)
{
std::string object_name = op_state.get_object_name();
@ -275,7 +275,7 @@ int RGWBucket::remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpStat
bucket = op_state.get_bucket()->clone();
int ret = rgw_remove_object(dpp, driver, bucket.get(), key);
int ret = rgw_remove_object(dpp, driver, bucket.get(), key, y);
if (ret < 0) {
set_err_msg(err_msg, "unable to remove object" + cpp_strerror(-ret));
return ret;
@ -321,7 +321,7 @@ static void dump_index_check(map<RGWObjCategory, RGWStorageStats> existing_stats
int RGWBucket::check_bad_index_multipart(RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher,
const DoutPrefixProvider *dpp,
const DoutPrefixProvider *dpp, optional_yield y,
std::string *err_msg)
{
const bool fix_index = op_state.will_fix_index();
@ -337,7 +337,7 @@ int RGWBucket::check_bad_index_multipart(RGWBucketAdminOpState& op_state,
bool is_truncated;
do {
rgw::sal::Bucket::ListResults results;
int r = bucket->list(dpp, params, listing_max_entries, results, null_yield);
int r = bucket->list(dpp, params, listing_max_entries, results, y);
if (r < 0) {
set_err_msg(err_msg, "failed to list objects in bucket=" + bucket->get_name() +
" err=" + cpp_strerror(-r));
@ -572,15 +572,15 @@ int RGWBucket::get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolic
int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp)
RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp, optional_yield y)
{
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp);
int ret = bucket.init(driver, op_state, y, dpp);
if (ret < 0)
return ret;
ret = bucket.get_policy(op_state, policy, null_yield, dpp);
ret = bucket.get_policy(op_state, policy, y, dpp);
if (ret < 0)
return ret;
@ -591,11 +591,11 @@ int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState
int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp)
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y)
{
RGWAccessControlPolicy policy(driver->ctx());
int ret = get_policy(driver, op_state, policy, dpp);
int ret = get_policy(driver, op_state, policy, dpp, y);
if (ret < 0)
return ret;
@ -613,11 +613,11 @@ int RGWBucketAdminOp::get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState
}
int RGWBucketAdminOp::dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
ostream& os, const DoutPrefixProvider *dpp)
ostream& os, const DoutPrefixProvider *dpp, optional_yield y)
{
RGWAccessControlPolicy_S3 policy(driver->ctx());
int ret = get_policy(driver, op_state, policy, dpp);
int ret = get_policy(driver, op_state, policy, dpp, y);
if (ret < 0)
return ret;
@ -626,18 +626,18 @@ 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)
int RGWBucketAdminOp::unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y)
{
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp);
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, null_yield, dpp, true);
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);
}
int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, string *err)
int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, string *err)
{
if (!op_state.is_user_op()) {
set_err_msg(err, "empty user id");
@ -645,7 +645,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
}
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp, err);
int ret = bucket.init(driver, op_state, y, dpp, err);
if (ret < 0)
return ret;
@ -700,7 +700,7 @@ 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.get_id(), old_bucket->get_info().bucket, null_yield, dpp, false);
int r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->unlink_bucket(owner.get_id(), old_bucket->get_info().bucket, y, dpp, false);
if (r < 0) {
set_err_msg(err, "could not unlink policy from user " + owner.get_id().to_str());
return r;
@ -741,7 +741,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, null_yield, dpp, true, &ep_data);
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);
if (r < 0) {
set_err_msg(err, "failed to relink bucket");
return r;
@ -750,7 +750,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(
old_bucket->get_key(), null_yield, dpp,
old_bucket->get_key(), y, dpp,
RGWBucketCtl::Bucket::RemoveParams()
.set_objv_tracker(&ep_data.ep_objv));
if (r < 0) {
@ -759,7 +759,7 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
}
r = static_cast<rgw::sal::RadosStore*>(driver)->ctl()->bucket->remove_bucket_instance_info(
old_bucket->get_key(), old_bucket->get_info(),
null_yield, dpp,
y, dpp,
RGWBucketCtl::BucketInstance::RemoveParams()
.set_objv_tracker(&ep_data.ep_objv));
if (r < 0) {
@ -771,15 +771,15 @@ int RGWBucketAdminOp::link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_s
return 0;
}
int RGWBucketAdminOp::chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const string& marker, const DoutPrefixProvider *dpp, string *err)
int RGWBucketAdminOp::chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const string& marker, const DoutPrefixProvider *dpp, optional_yield y, string *err)
{
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp, err);
int ret = bucket.init(driver, op_state, y, dpp, err);
if (ret < 0)
return ret;
return bucket.chown(op_state, marker, null_yield, dpp, err);
return bucket.chown(op_state, marker, y, dpp, err);
}
@ -793,14 +793,14 @@ int RGWBucketAdminOp::check_index(rgw::sal::Driver* driver, RGWBucketAdminOpStat
RGWBucket bucket;
ret = bucket.init(driver, op_state, null_yield, dpp);
ret = bucket.init(driver, op_state, y, dpp);
if (ret < 0)
return ret;
Formatter *formatter = flusher.get_formatter();
flusher.start(0);
ret = bucket.check_bad_index_multipart(op_state, flusher, dpp);
ret = bucket.check_bad_index_multipart(op_state, flusher, dpp, y);
if (ret < 0)
return ret;
@ -839,21 +839,21 @@ int RGWBucketAdminOp::remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpSt
return ret;
}
int RGWBucketAdminOp::remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp)
int RGWBucketAdminOp::remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y)
{
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp);
int ret = bucket.init(driver, op_state, y, dpp);
if (ret < 0)
return ret;
return bucket.remove_object(dpp, op_state);
return bucket.remove_object(dpp, op_state, y);
}
int RGWBucketAdminOp::sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, string *err_msg)
int RGWBucketAdminOp::sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, string *err_msg)
{
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp, err_msg);
int ret = bucket.init(driver, op_state, y, dpp, err_msg);
if (ret < 0)
{
return ret;
@ -865,12 +865,12 @@ static int bucket_stats(rgw::sal::Driver* driver,
const std::string& tenant_name,
const std::string& bucket_name,
Formatter *formatter,
const DoutPrefixProvider *dpp)
const DoutPrefixProvider *dpp, optional_yield y)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
map<RGWObjCategory, RGWStorageStats> stats;
int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, null_yield);
int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, y);
if (ret < 0) {
return ret;
}
@ -1101,7 +1101,7 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
}
if (show_stats) {
bucket_stats(driver, user_id.tenant, obj_name, formatter, dpp);
bucket_stats(driver, user_id.tenant, obj_name, formatter, dpp, y);
} else {
formatter->dump_string("bucket", obj_name);
}
@ -1117,7 +1117,7 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
formatter->close_section();
} else if (!bucket_name.empty()) {
ret = bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp);
ret = bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp, y);
if (ret < 0) {
return ret;
}
@ -1134,7 +1134,7 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
&truncated);
for (auto& bucket_name : buckets) {
if (show_stats) {
bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp);
bucket_stats(driver, user_id.tenant, bucket_name, formatter, dpp, y);
} else {
formatter->dump_string("bucket", bucket_name);
}
@ -1150,11 +1150,11 @@ int RGWBucketAdminOp::info(rgw::sal::Driver* driver,
return 0;
}
int RGWBucketAdminOp::set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp)
int RGWBucketAdminOp::set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y)
{
RGWBucket bucket;
int ret = bucket.init(driver, op_state, null_yield, dpp);
int ret = bucket.init(driver, op_state, y, dpp);
if (ret < 0)
return ret;
return bucket.set_quota(op_state, dpp);
@ -1172,7 +1172,7 @@ using bucket_instance_ls = std::vector<RGWBucketInfo>;
void get_stale_instances(rgw::sal::Driver* driver, const std::string& bucket_name,
const vector<std::string>& lst,
bucket_instance_ls& stale_instances,
const DoutPrefixProvider *dpp)
const DoutPrefixProvider *dpp, optional_yield y)
{
bucket_instance_ls other_instances;
@ -1183,7 +1183,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->get_bucket(dpp, nullptr, rbucket, &bucket, null_yield);
int r = driver->get_bucket(dpp, nullptr, 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
@ -1203,7 +1203,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->get_bucket(dpp, nullptr, tenant, bname, &cur_bucket, null_yield);
int r = driver->get_bucket(dpp, nullptr, tenant, bname, &cur_bucket, y);
if (r < 0) {
if (r == -ENOENT) {
// bucket doesn't exist, everything is stale then
@ -1264,7 +1264,7 @@ static int process_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpSta
const DoutPrefixProvider *dpp,
std::function<void(const bucket_instance_ls&,
Formatter *,
rgw::sal::Driver*)> process_f)
rgw::sal::Driver*)> process_f, optional_yield y)
{
std::string marker;
void *handle;
@ -1304,7 +1304,7 @@ static int process_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpSta
}
for (const auto& kv: bucket_instance_map) {
bucket_instance_ls stale_lst;
get_stale_instances(driver, kv.first, kv.second, stale_lst, dpp);
get_stale_instances(driver, kv.first, kv.second, stale_lst, dpp, y);
process_f(stale_lst, formatter, driver);
}
}
@ -1316,7 +1316,7 @@ static int process_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpSta
int RGWBucketAdminOp::list_stale_instances(rgw::sal::Driver* driver,
RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher,
const DoutPrefixProvider *dpp)
const DoutPrefixProvider *dpp, optional_yield y)
{
auto process_f = [](const bucket_instance_ls& lst,
Formatter *formatter,
@ -1324,14 +1324,14 @@ int RGWBucketAdminOp::list_stale_instances(rgw::sal::Driver* driver,
for (const auto& binfo: lst)
formatter->dump_string("key", binfo.bucket.get_key());
};
return process_stale_instances(driver, op_state, flusher, dpp, process_f);
return process_stale_instances(driver, op_state, flusher, dpp, process_f, y);
}
int RGWBucketAdminOp::clear_stale_instances(rgw::sal::Driver* driver,
RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher,
const DoutPrefixProvider *dpp)
const DoutPrefixProvider *dpp, optional_yield y)
{
auto process_f = [dpp](const bucket_instance_ls& lst,
Formatter *formatter,
@ -1351,16 +1351,16 @@ int RGWBucketAdminOp::clear_stale_instances(rgw::sal::Driver* driver,
}
};
return process_stale_instances(driver, op_state, flusher, dpp, process_f);
return process_stale_instances(driver, op_state, flusher, dpp, process_f, y);
}
static int fix_single_bucket_lc(rgw::sal::Driver* driver,
const std::string& tenant_name,
const std::string& bucket_name,
const DoutPrefixProvider *dpp)
const DoutPrefixProvider *dpp, optional_yield y)
{
std::unique_ptr<rgw::sal::Bucket> bucket;
int ret = driver->get_bucket(dpp, nullptr, tenant_name, bucket_name, &bucket, null_yield);
int ret = driver->get_bucket(dpp, nullptr, 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?
@ -1388,7 +1388,7 @@ static void process_single_lc_entry(rgw::sal::Driver* driver,
const std::string& bucket_name,
const DoutPrefixProvider *dpp)
{
int ret = fix_single_bucket_lc(driver, tenant_name, bucket_name, dpp);
int ret = fix_single_bucket_lc(driver, tenant_name, bucket_name, dpp, null_yield);
format_lc_status(formatter, tenant_name, bucket_name, -ret);
}
@ -1446,12 +1446,12 @@ int RGWBucketAdminOp::fix_lc_shards(rgw::sal::Driver* driver,
static bool has_object_expired(const DoutPrefixProvider *dpp,
rgw::sal::Driver* driver,
rgw::sal::Bucket* bucket,
const rgw_obj_key& key, utime_t& delete_at)
const rgw_obj_key& key, utime_t& delete_at, optional_yield y)
{
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
bufferlist delete_at_bl;
int ret = rgw_object_get_attr(dpp, driver, obj.get(), RGW_ATTR_DELETE_AT, delete_at_bl, null_yield);
int ret = rgw_object_get_attr(dpp, driver, obj.get(), RGW_ATTR_DELETE_AT, delete_at_bl, y);
if (ret < 0) {
return false; // no delete at attr, proceed
}
@ -1471,7 +1471,7 @@ static bool has_object_expired(const DoutPrefixProvider *dpp,
static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
rgw::sal::Driver* driver,
rgw::sal::Bucket* bucket,
RGWFormatterFlusher& flusher, bool dry_run)
RGWFormatterFlusher& flusher, bool dry_run, optional_yield y)
{
if (bucket->get_key().bucket_id == bucket->get_key().marker) {
ldpp_dout(dpp, -1) << "Not a resharded bucket skipping" << dendl;
@ -1492,7 +1492,7 @@ static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
params.allow_unordered = true;
do {
int ret = bucket->list(dpp, params, listing_max_entries, results, null_yield);
int ret = bucket->list(dpp, params, listing_max_entries, results, y);
if (ret < 0) {
ldpp_dout(dpp, -1) << "ERROR failed to list objects in the bucket" << dendl;
return ret;
@ -1500,13 +1500,13 @@ static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
for (const auto& obj : results.objs) {
rgw_obj_key key(obj.key);
utime_t delete_at;
if (has_object_expired(dpp, driver, bucket, key, delete_at)) {
if (has_object_expired(dpp, driver, bucket, key, delete_at, y)) {
formatter->open_object_section("object_status");
formatter->dump_string("object", key.name);
formatter->dump_stream("delete_at") << delete_at;
if (!dry_run) {
ret = rgw_remove_object(dpp, driver, bucket, key);
ret = rgw_remove_object(dpp, driver, bucket, key, y);
formatter->dump_int("status", ret);
}
@ -1522,10 +1522,10 @@ static int fix_bucket_obj_expiry(const DoutPrefixProvider *dpp,
int RGWBucketAdminOp::fix_obj_expiry(rgw::sal::Driver* driver,
RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher,
const DoutPrefixProvider *dpp, bool dry_run)
const DoutPrefixProvider *dpp, optional_yield y, bool dry_run)
{
RGWBucket admin_bucket;
int ret = admin_bucket.init(driver, op_state, null_yield, dpp);
int ret = admin_bucket.init(driver, op_state, y, dpp);
if (ret < 0) {
ldpp_dout(dpp, -1) << "failed to initialize bucket" << dendl;
return ret;
@ -1536,7 +1536,7 @@ int RGWBucketAdminOp::fix_obj_expiry(rgw::sal::Driver* driver,
return ret;
}
return fix_bucket_obj_expiry(dpp, driver, bucket.get(), flusher, dry_run);
return fix_bucket_obj_expiry(dpp, driver, bucket.get(), flusher, dry_run, y);
}
void RGWBucketCompleteInfo::dump(Formatter *f) const {

30
src/rgw/driver/rados/rgw_bucket.h
View File

@ -207,7 +207,7 @@ public:
static RGWBucketInstanceMetadataHandlerBase *alloc(rgw::sal::Driver* driver);
};
extern int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key);
extern int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key, optional_yield y);
extern int rgw_object_get_attr(rgw::sal::Driver* driver, rgw::sal::Object* obj,
const char* attr_name, bufferlist& out_bl,
@ -325,7 +325,7 @@ public:
int check_bad_index_multipart(RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher,
const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL);
int check_object_index(const DoutPrefixProvider *dpp,
RGWBucketAdminOpState& op_state,
@ -343,7 +343,7 @@ public:
optional_yield y, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
int set_quota(RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
int remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
int remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg = NULL);
int policy_bl_to_stream(bufferlist& bl, std::ostream& o);
int get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolicy& policy, optional_yield y, const DoutPrefixProvider *dpp);
int sync(RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
@ -356,41 +356,41 @@ public:
class RGWBucketAdminOp {
public:
static int get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y);
static int get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp);
RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp, optional_yield y);
static int dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
std::ostream& os, const DoutPrefixProvider *dpp);
std::ostream& os, const DoutPrefixProvider *dpp, optional_yield y);
static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
static int link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
static int chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const std::string& marker, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y);
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);
static int check_index(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, optional_yield y, const DoutPrefixProvider *dpp);
static int remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, optional_yield y,
const DoutPrefixProvider *dpp, bool bypass_gc = false, bool keep_index_consistent = true);
static int remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
static int remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y);
static int info(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher, optional_yield y, const DoutPrefixProvider *dpp);
static int limit_check(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
const std::list<std::string>& user_ids,
RGWFormatterFlusher& flusher, optional_yield y,
const DoutPrefixProvider *dpp,
bool warnings_only = false);
static int set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
static int set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y);
static int list_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y);
static int clear_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y);
static int fix_lc_shards(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
static int fix_obj_expiry(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, bool dry_run = false);
RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, optional_yield y, bool dry_run = false);
static int sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
static int sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, optional_yield y, std::string *err_msg = NULL);
};
struct rgw_ep_info {

12
src/rgw/driver/rados/rgw_rest_bucket.cc
View File

@ -79,7 +79,7 @@ void RGWOp_Get_Policy::execute(optional_yield y)
op_state.set_bucket_name(bucket);
op_state.set_object(object);
op_ret = RGWBucketAdminOp::get_policy(driver, op_state, flusher, this);
op_ret = RGWBucketAdminOp::get_policy(driver, op_state, flusher, this, y);
}
class RGWOp_Check_Bucket_Index : public RGWRESTOp {
@ -156,7 +156,7 @@ void RGWOp_Bucket_Link::execute(optional_yield y)
ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
return;
}
op_ret = RGWBucketAdminOp::link(driver, op_state, s);
op_ret = RGWBucketAdminOp::link(driver, op_state, s, y);
}
class RGWOp_Bucket_Unlink : public RGWRESTOp {
@ -194,7 +194,7 @@ void RGWOp_Bucket_Unlink::execute(optional_yield y)
ldpp_dout(this, 0) << "forward_request_to_master returned ret=" << op_ret << dendl;
return;
}
op_ret = RGWBucketAdminOp::unlink(driver, op_state, s);
op_ret = RGWBucketAdminOp::unlink(driver, op_state, s, y);
}
class RGWOp_Bucket_Remove : public RGWRESTOp {
@ -310,7 +310,7 @@ void RGWOp_Set_Bucket_Quota::execute(optional_yield y)
op_state.set_bucket_name(bucket_name);
op_state.set_quota(quota);
op_ret = RGWBucketAdminOp::set_quota(driver, op_state, s);
op_ret = RGWBucketAdminOp::set_quota(driver, op_state, s, y);
}
class RGWOp_Sync_Bucket : public RGWRESTOp {
@ -342,7 +342,7 @@ void RGWOp_Sync_Bucket::execute(optional_yield y)
op_state.set_tenant(tenant);
op_state.set_sync_bucket(sync_bucket);
op_ret = RGWBucketAdminOp::sync_bucket(driver, op_state, s);
op_ret = RGWBucketAdminOp::sync_bucket(driver, op_state, s, y);
}
class RGWOp_Object_Remove: public RGWRESTOp {
@ -372,7 +372,7 @@ void RGWOp_Object_Remove::execute(optional_yield y)
op_state.set_bucket_name(bucket);
op_state.set_object(object);
op_ret = RGWBucketAdminOp::remove_object(driver, op_state, s);
op_ret = RGWBucketAdminOp::remove_object(driver, op_state, s, y);
}

2
src/rgw/driver/rados/rgw_sal_rados.cc
View File

@ -438,7 +438,7 @@ int RadosBucket::remove_bucket(const DoutPrefixProvider* dpp,
for (const auto& obj : results.objs) {
rgw_obj_key key(obj.key);
/* xxx dang */
ret = rgw_remove_object(dpp, store, this, key);
ret = rgw_remove_object(dpp, store, this, key, y);
if (ret < 0 && ret != -ENOENT) {
return ret;
}

22
src/rgw/rgw_admin.cc
View File

@ -6900,13 +6900,13 @@ int main(int argc, const char **argv)
if (opt_cmd == OPT::POLICY) {
if (format == "xml") {
int ret = RGWBucketAdminOp::dump_s3_policy(driver, bucket_op, cout, dpp());
int ret = RGWBucketAdminOp::dump_s3_policy(driver, bucket_op, cout, dpp(), null_yield);
if (ret < 0) {
cerr << "ERROR: failed to get policy: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
} else {
int ret = RGWBucketAdminOp::get_policy(driver, bucket_op, stream_flusher, dpp());
int ret = RGWBucketAdminOp::get_policy(driver, bucket_op, stream_flusher, dpp(), null_yield);
if (ret < 0) {
cerr << "ERROR: failed to get policy: " << cpp_strerror(-ret) << std::endl;
return -ret;
@ -7096,7 +7096,7 @@ int main(int argc, const char **argv)
bucket_op.set_bucket_id(bucket_id);
bucket_op.set_new_bucket_name(new_bucket_name);
string err;
int r = RGWBucketAdminOp::link(driver, bucket_op, dpp(), &err);
int r = RGWBucketAdminOp::link(driver, bucket_op, dpp(), null_yield, &err);
if (r < 0) {
cerr << "failure: " << cpp_strerror(-r) << ": " << err << std::endl;
return -r;
@ -7104,7 +7104,7 @@ int main(int argc, const char **argv)
}
if (opt_cmd == OPT::BUCKET_UNLINK) {
int r = RGWBucketAdminOp::unlink(driver, bucket_op, dpp());
int r = RGWBucketAdminOp::unlink(driver, bucket_op, dpp(), null_yield);
if (r < 0) {
cerr << "failure: " << cpp_strerror(-r) << std::endl;
return -r;
@ -7179,7 +7179,7 @@ int main(int argc, const char **argv)
bucket_op.set_new_bucket_name(new_bucket_name);
string err;
int r = RGWBucketAdminOp::chown(driver, bucket_op, marker, dpp(), &err);
int r = RGWBucketAdminOp::chown(driver, bucket_op, marker, dpp(), null_yield, &err);
if (r < 0) {
cerr << "failure: " << cpp_strerror(-r) << ": " << err << std::endl;
return -r;
@ -7736,7 +7736,7 @@ next:
return -ret;
}
rgw_obj_key key(object, object_version);
ret = rgw_remove_object(dpp(), driver, bucket.get(), key);
ret = rgw_remove_object(dpp(), driver, bucket.get(), key, null_yield);
if (ret < 0) {
cerr << "ERROR: object remove returned: " << cpp_strerror(-ret) << std::endl;
@ -7863,7 +7863,7 @@ next:
}
if (opt_cmd == OPT::OBJECTS_EXPIRE_STALE_LIST) {
ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), true);
ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), null_yield, true);
if (ret < 0) {
cerr << "ERROR: listing returned " << cpp_strerror(-ret) << std::endl;
return -ret;
@ -7871,7 +7871,7 @@ next:
}
if (opt_cmd == OPT::OBJECTS_EXPIRE_STALE_RM) {
ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), false);
ret = RGWBucketAdminOp::fix_obj_expiry(driver, bucket_op, stream_flusher, dpp(), null_yield, false);
if (ret < 0) {
cerr << "ERROR: removing returned " << cpp_strerror(-ret) << std::endl;
return -ret;
@ -9211,7 +9211,7 @@ next:
}
bucket_op.set_tenant(tenant);
string err_msg;
ret = RGWBucketAdminOp::sync_bucket(driver, bucket_op, dpp(), &err_msg);
ret = RGWBucketAdminOp::sync_bucket(driver, bucket_op, dpp(), null_yield, &err_msg);
if (ret < 0) {
cerr << err_msg << std::endl;
return -ret;
@ -10397,7 +10397,7 @@ next:
return EINVAL;
}
ret = RGWBucketAdminOp::list_stale_instances(driver, bucket_op, stream_flusher, dpp());
ret = RGWBucketAdminOp::list_stale_instances(driver, bucket_op, stream_flusher, dpp(), null_yield);
if (ret < 0) {
cerr << "ERROR: listing stale instances" << cpp_strerror(-ret) << std::endl;
}
@ -10409,7 +10409,7 @@ next:
return EINVAL;
}
ret = RGWBucketAdminOp::clear_stale_instances(driver, bucket_op, stream_flusher, dpp());
ret = RGWBucketAdminOp::clear_stale_instances(driver, bucket_op, stream_flusher, dpp(), null_yield);
if (ret < 0) {
cerr << "ERROR: deleting stale instances" << cpp_strerror(-ret) << std::endl;
}