}
if (opt_cmd == OPT_METADATA_GET) {
- int ret = store->ctl.meta.mgr->get(metadata_key, formatter);
+ int ret = store->ctl.meta.mgr->get(metadata_key, formatter, null_yield);
if (ret < 0) {
cerr << "ERROR: can't get key: " << cpp_strerror(-ret) << std::endl;
return -ret;
cerr << "ERROR: failed to read input: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
- ret = store->ctl.meta.mgr->put(metadata_key, bl, RGWMDLogSyncType::APPLY_ALWAYS);
+ ret = store->ctl.meta.mgr->put(metadata_key, bl, null_yield, RGWMDLogSyncType::APPLY_ALWAYS);
if (ret < 0) {
cerr << "ERROR: can't put key: " << cpp_strerror(-ret) << std::endl;
return -ret;
}
if (opt_cmd == OPT_METADATA_RM) {
- int ret = store->ctl.meta.mgr->remove(metadata_key);
+ int ret = store->ctl.meta.mgr->remove(metadata_key, null_yield);
if (ret < 0) {
cerr << "ERROR: can't remove key: " << cpp_strerror(-ret) << std::endl;
return -ret;
int ret = store->ctl.meta.mgr->mutate(RGWSI_MetaBackend_OTP::get_meta_key(user_id),
mtime, &objv_tracker,
+ null_yield,
MDLOG_STATUS_WRITE,
[&] {
return store->svc.cls->mfa.create_mfa(user_id, config, &objv_tracker, mtime, null_yield);
int ret = store->ctl.meta.mgr->mutate(RGWSI_MetaBackend_OTP::get_meta_key(user_id),
mtime, &objv_tracker,
+ null_yield,
MDLOG_STATUS_WRITE,
[&] {
return store->svc.cls->mfa.remove_mfa(user_id, totp_serial, &objv_tracker, mtime, null_yield);
ret = store->ctl.meta.mgr->mutate(RGWSI_MetaBackend_OTP::get_meta_key(user_id),
mtime, &objv_tracker,
+ null_yield,
MDLOG_STATUS_WRITE,
[&] {
return store->svc.cls->mfa.create_mfa(user_id, config, &objv_tracker, mtime, null_yield);
auto ex = get_associated_executor(init.completion_handler);
auto& ref = r.obj.get_ref();
- librados::async_operate(context, ref.ioctx, ref.obj.oid, &op, 0,
+ librados::async_operate(context, ref.pool.ioctx(), ref.obj.oid, &op, 0,
bind_executor(ex, Handler{aio, r}));
};
}
if (fix) {
cout << "fixing" << std::endl;
r = store->ctl.bucket->link_bucket(user_id, actual_bucket,
- bucket_info.creation_time);
+ bucket_info.creation_time,
+ null_yield);
if (r < 0) {
cerr << "failed to fix bucket: " << cpp_strerror(-r) << std::endl;
}
return ret;
}
- ret = store->ctl.bucket->unlink_bucket(info.owner, bucket, false);
+ ret = store->ctl.bucket->unlink_bucket(info.owner, bucket, null_yield, false);
if (ret < 0) {
lderr(store->ctx()) << "ERROR: unable to remove user bucket information" << dendl;
}
return ret;
}
- ret = store->ctl.bucket->unlink_bucket(info.owner, bucket, false);
+ ret = store->ctl.bucket->unlink_bucket(info.owner, bucket, null_yield, false);
if (ret < 0) {
lderr(store->ctx()) << "ERROR: unable to remove user bucket information" << dendl;
}
return 0;
}
-int RGWBucket::link(RGWBucketAdminOpState& op_state, std::string *err_msg)
+int RGWBucket::link(RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg)
{
if (!op_state.is_user_op()) {
set_err_msg(err_msg, "empty user id");
auto bucket_ctl = store->ctl.bucket;
- int r = bucket_ctl->read_bucket_instance_info(bucket, &bucket_info, null_yield, RGWBucketCtl::BucketInstance::GetParams()
+ int r = bucket_ctl->read_bucket_instance_info(bucket, &bucket_info, y, RGWBucketCtl::BucketInstance::GetParams()
.set_attrs(&attrs)
- .set_objv_tracker(&objv_tracker),
+ .set_objv_tracker(&objv_tracker)
.set_bectx_params(&obj_ctx));
if (r < 0) {
return r;
return -EIO;
}
- r = store->ctl.bucket->unlink_bucket(owner.get_id(), bucket, false);
+ r = store->ctl.bucket->unlink_bucket(owner.get_id(), bucket, y, false);
if (r < 0) {
set_err_msg(err_msg, "could not unlink policy from user " + owner.get_id().to_str());
return r;
// ...and encode the acl
policy.encode(attrs[RGW_ATTR_ACL]);
- r = bucket_ctl->store_bucket_instance_info(bucket, bucket_info, RGWBucketCtl::BucketInstance::PutParams()
- .set_attrs(&attrs)
- .set_objv_tracker(&objv_tracker));
+ r = bucket_ctl->store_bucket_instance_info(bucket, bucket_info, y,
+ RGWBucketCtl::BucketInstance::PutParams()
+ .set_attrs(&attrs)
+ .set_objv_tracker(&objv_tracker));
if (r < 0) {
return r;
}
RGWBucketEntryPoint be;
map<string, bufferlist> be_attrs;
RGWObjVersionTracker be_ot;
- r = bucket_ctl->read_bucket_entrypoint_info(bucket, &be, null_yield, RGWBucketCtl::Bucket::GetParams()
+ r = bucket_ctl->read_bucket_entrypoint_info(bucket, &be, y, RGWBucketCtl::Bucket::GetParams()
.set_objv_tracker(&be_ot)
.set_attrs(&be_attrs));
if (r < 0) {
be.owner = bucket_info.owner;
be_attrs[RGW_ATTR_ACL] = attrs[RGW_ATTR_ACL];
- r = bucket_ctl->store_bucket_entrypoint_info(bucket, be, null_yield, RGWBucketCtl::Bucket::PutParams()
+ r = bucket_ctl->store_bucket_entrypoint_info(bucket, be, y, RGWBucketCtl::Bucket::PutParams()
.set_objv_tracker(&be_ot)
.set_attrs(&be_attrs));
if (r < 0) {
/* link to user */
r = store->ctl.bucket->link_bucket(user_info.user_id,
bucket_info.bucket,
- ceph::real_time());
+ ceph::real_time(),
+ y);
if (r < 0) {
return r;
}
return 0;
}
-int RGWBucket::unlink(RGWBucketAdminOpState& op_state, std::string *err_msg)
+int RGWBucket::unlink(RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg)
{
rgw_bucket bucket = op_state.get_bucket();
return -EINVAL;
}
- int r = store->ctl.bucket->unlink_bucket(user_info.user_id, bucket);
+ int r = store->ctl.bucket->unlink_bucket(user_info.user_id, bucket, y);
if (r < 0) {
set_err_msg(err_msg, "error unlinking bucket" + cpp_strerror(-r));
}
if (ret < 0)
return ret;
- return bucket.unlink(op_state);
+ return bucket.unlink(op_state, null_yield);
}
int RGWBucketAdminOp::link(RGWRados *store, RGWBucketAdminOpState& op_state, string *err)
if (ret < 0)
return ret;
- return bucket.link(op_state, err);
+ return bucket.link(op_state, null_yield, err);
}
int ret = purge_bucket_instance(store, binfo);
if (ret == 0){
auto md_key = "bucket.instance:" + binfo.bucket.get_key();
- ret = store->ctl.meta.mgr->remove(md_key);
+ ret = store->ctl.meta.mgr->remove(md_key, null_yield);
}
formatter->open_object_section("delete_status");
formatter->dump_string("bucket_instance", binfo.bucket.get_key());
process_single_lc_entry(store, formatter, user_id.tenant, bucket_name);
formatter->flush(cout);
} else {
- int ret = store->meta_mgr->list_keys_init("bucket", marker, &handle);
+ int ret = store->ctl.meta.mgr->list_keys_init("bucket", marker, &handle);
if (ret < 0) {
std::cerr << "ERROR: can't get key: " << cpp_strerror(-ret) << std::endl;
return ret;
{
formatter->open_array_section("lc_fix_status");
auto sg = make_scope_guard([&store, &handle, &formatter](){
- store->meta_mgr->list_keys_complete(handle);
+ store->ctl.meta.mgr->list_keys_complete(handle);
formatter->close_section(); // lc_fix_status
formatter->flush(cout);
});
do {
list<std::string> keys;
- ret = store->meta_mgr->list_keys_next(handle, default_max_keys, keys, &truncated);
+ ret = store->ctl.meta.mgr->list_keys_next(handle, default_max_keys, keys, &truncated);
if (ret < 0 && ret != -ENOENT) {
std::cerr << "ERROR: lists_keys_next(): " << cpp_strerror(-ret) << std::endl;
return ret;
* it immediately and don't want to invalidate our cached objv_version or the bucket obj removal
* will incorrectly fail.
*/
- ret = ctl.bucket->unlink_bucket(be.owner, be.bucket, false);
+ ret = ctl.bucket->unlink_bucket(be.owner, be.bucket, y, false);
if (ret < 0) {
lderr(svc.bucket->ctx()) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
}
- ret = svc.bucket->remove_bucket_entrypoint_info(ctx, entry, &objv_tracker);
+ ret = svc.bucket->remove_bucket_entrypoint_info(ctx, entry, &objv_tracker, y);
if (ret < 0) {
lderr(svc.bucket->ctx()) << "could not delete bucket=" << entry << dendl;
}
RGWMetadataHandlerPut_Bucket(RGWBucketMetadataHandler *_handler,
RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
- RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, op, entry, obj, objv_tracker, type),
+ optional_yield y,
+ RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, op, entry, obj, objv_tracker, y, type),
bhandler(_handler) {
obj = static_cast<RGWBucketEntryMetadataObject *>(_obj);
}
int RGWBucketMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker,
+ optional_yield y,
RGWMDLogSyncType type)
{
- RGWMetadataHandlerPut_Bucket put_op(this, op, entry, obj, objv_tracker, type);
+ RGWMetadataHandlerPut_Bucket put_op(this, op, entry, obj, objv_tracker, y, type);
return do_put_operate(&put_op);
}
false,
mtime,
pattrs,
- &objv_tracker);
+ &objv_tracker,
+ y);
}
int RGWMetadataHandlerPut_Bucket::put_post()
/* link bucket */
if (be.linked) {
- ret = bhandler->ctl.bucket->link_bucket(be.owner, be.bucket, be.creation_time, false);
+ ret = bhandler->ctl.bucket->link_bucket(be.owner, be.bucket, be.creation_time, y, false);
} else {
- ret = bhandler->ctl.bucket->unlink_bucket(be.owner, be.bucket, false);
+ ret = bhandler->ctl.bucket->unlink_bucket(be.owner, be.bucket, y, false);
}
return ret;
/* link new bucket */
- ret = ctl.bucket->link_bucket(new_be.owner, new_be.bucket, new_be.creation_time, false, y);
+ ret = ctl.bucket->link_bucket(new_be.owner, new_be.bucket, new_be.creation_time, y, false);
if (ret < 0) {
ldout(cct, 0) << "ERROR: failed to link new bucket for bucket=" << new_be.bucket << " ret=" << ret << dendl;
return ret;
/* clean up old stuff */
- ret = ctl.bucket->unlink_bucket(be.owner, entry_bucket, false, y);
+ ret = ctl.bucket->unlink_bucket(be.owner, entry_bucket, y, false);
if (ret < 0) {
lderr(cct) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
}
if (entry.find("-deleted-") != string::npos) {
RGWObjVersionTracker ot;
RGWMetadataObject *robj;
- int ret = do_get(op, entry, &robj);
+ int ret = do_get(op, entry, &robj, y);
if (ret != -ENOENT) {
if (ret < 0) {
return ret;
int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
+ optional_yield y,
RGWMDLogSyncType sync_type) override;
int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
if (ret < 0 && ret != -ENOENT)
return ret;
- return svc.bucket->remove_bucket_instance_info(ctx, entry, &bci.info.objv_tracker);
+ return svc.bucket->remove_bucket_instance_info(ctx, entry, &bci.info.objv_tracker, y);
}
int call(std::function<int(RGWSI_Bucket_BI_Ctx& ctx)> f) {
RGWBucketInstanceMetadataHandler *_handler,
RGWSI_MetaBackend_Handler::Op *_op, string& entry,
RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
- RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, _op, entry, obj, objv_tracker, type),
+ optional_yield y,
+ RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, _op, entry, obj, objv_tracker, y, type),
bihandler(_handler) {
obj = static_cast<RGWBucketInstanceMetadataObject *>(_obj);
orig_info,
false,
mtime,
- pattrs);
+ pattrs,
+ y);
}
int RGWMetadataHandlerPut_BucketInstance::put_post()
public:
RGWArchiveBucketInstanceMetadataHandler() {}
- int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) override {
+ int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y) override {
ldout(cct, 0) << "SKIP: bucket instance removal is not allowed on archive zone: bucket.instance:" << entry << dendl;
return 0;
}
params.objv_tracker,
params.mtime,
params.attrs,
+ y,
params.cache_info,
- params.refresh_version,
- y);
+ params.refresh_version);
});
}
return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) {
return svc.bucket->remove_bucket_entrypoint_info(ctx,
RGWSI_Bucket::get_entrypoint_meta_key(bucket),
- params.objv_tracker);
+ params.objv_tracker,
+ y);
});
}
info,
params.mtime,
params.attrs,
+ y,
params.cache_info,
- params.refresh_version,
- y);
+ params.refresh_version);
});
if (ret < 0) {
if (b->bucket_id.empty()) {
ep.emplace();
- int r = read_bucket_entrypoint_info(*b, &(*ep), RGWBucketCtl::Bucket::GetParams()
+ int r = read_bucket_entrypoint_info(*b, &(*ep), y, RGWBucketCtl::Bucket::GetParams()
.set_bectx_params(params.bectx_params)
.set_objv_tracker(ep_objv_tracker));
if (r < 0) {
info,
params.mtime,
params.attrs,
+ y,
params.cache_info,
- params.refresh_version,
- y);
+ params.refresh_version);
});
if (ret < 0) {
ceph::optional_ref_default<RGWBucketCtl::BucketInstance::PutParams> _params)
{
return bmi_handler->call([&](RGWSI_Bucket_BI_Ctx& ctx) {
- return do_store_bucket_instance_info(ctx, bucket, info, _params, y);
+ return do_store_bucket_instance_info(ctx, bucket, info, y, _params);
});
}
bool exclusive, real_time mtime,
obj_version *pep_objv,
map<string, bufferlist> *pattrs,
- bool create_entry_point)
+ bool create_entry_point,
+ optional_yield y)
{
bool create_head = !info.has_instance_obj || create_entry_point;
info,
orig_info,
exclusive,
- mtime, pattrs);
+ mtime, pattrs,
+ y);
if (ret < 0) {
return ret;
}
exclusive,
mtime,
pattrs,
- &ot);
+ &ot,
+ y);
if (ret < 0)
return ret;
int RGWBucketCtl::link_bucket(const rgw_user& user_id,
const rgw_bucket& bucket,
ceph::real_time creation_time,
+ optional_yield y,
bool update_entrypoint)
{
return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) {
- return do_link_bucket(ctx, user_id, bucket, creation_time, update_entrypoint);
+ return do_link_bucket(ctx, user_id, bucket, creation_time, y, update_entrypoint);
});
}
const rgw_user& user_id,
const rgw_bucket& bucket,
ceph::real_time creation_time,
+ optional_yield y,
bool update_entrypoint)
{
int ret;
ret = svc.bucket->read_bucket_entrypoint_info(ctx,
meta_key,
&ep, &ot,
- nullptr, &attrs);
+ nullptr, &attrs,
+ y);
if (ret < 0 && ret != -ENOENT) {
ldout(cct, 0) << "ERROR: store->get_bucket_entrypoint_info() returned: "
<< cpp_strerror(-ret) << dendl;
ep.linked = true;
ep.owner = user_id;
ep.bucket = bucket;
- ret = svc.bucket->store_bucket_entrypoint_info(ctx, meta_key, ep, false, real_time(), &attrs, &ot);
+ ret = svc.bucket->store_bucket_entrypoint_info(ctx, meta_key, ep, false, real_time(), &attrs, &ot, y);
if (ret < 0)
goto done_err;
return 0;
done_err:
- int r = do_unlink_bucket(ctx, user_id, bucket, true);
+ int r = do_unlink_bucket(ctx, user_id, bucket, y, true);
if (r < 0) {
ldout(cct, 0) << "ERROR: failed unlinking bucket on error cleanup: "
<< cpp_strerror(-r) << dendl;
return ret;
}
-int RGWBucketCtl::unlink_bucket(const rgw_user& user_id, const rgw_bucket& bucket, bool update_entrypoint)
+int RGWBucketCtl::unlink_bucket(const rgw_user& user_id, const rgw_bucket& bucket, optional_yield y, bool update_entrypoint)
{
return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) {
- return do_unlink_bucket(ctx, user_id, bucket, update_entrypoint);
+ return do_unlink_bucket(ctx, user_id, bucket, y, update_entrypoint);
});
}
int RGWBucketCtl::do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx,
const rgw_user& user_id,
const rgw_bucket& bucket,
+ optional_yield y,
bool update_entrypoint)
{
int ret = ctl.user->remove_bucket(user_id, bucket);
RGWObjVersionTracker ot;
map<string, bufferlist> attrs;
string meta_key = RGWSI_Bucket::get_entrypoint_meta_key(bucket);
- ret = svc.bucket->read_bucket_entrypoint_info(ctx, meta_key, &ep, &ot, nullptr, &attrs);
+ ret = svc.bucket->read_bucket_entrypoint_info(ctx, meta_key, &ep, &ot, nullptr, &attrs, y);
if (ret == -ENOENT)
return 0;
if (ret < 0)
}
ep.linked = false;
- return svc.bucket->store_bucket_entrypoint_info(ctx, meta_key, ep, false, real_time(), &attrs, &ot);
+ return svc.bucket->store_bucket_entrypoint_info(ctx, meta_key, ep, false, real_time(), &attrs, &ot, y);
}
int RGWBucketCtl::read_bucket_stats(const rgw_bucket& bucket,
int RGWBucketCtl::sync_user_stats(const rgw_user& user_id, const RGWBucketInfo& bucket_info)
{
RGWBucketEnt ent;
- int r = svc.bi->read_stats(bucket_info, &ent);
+ int r = svc.bi->read_stats(bucket_info, &ent, null_yield);
if (r < 0) {
ldout(cct, 20) << __func__ << "(): failed to read bucket stats (r=" << r << ")" << dendl;
return r;
std::string *err_msg = NULL);
int remove(RGWBucketAdminOpState& op_state, optional_yield y, bool bypass_gc = false, bool keep_index_consistent = true, std::string *err_msg = NULL);
- int link(RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
- int unlink(RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
+ int link(RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg = NULL);
+ int unlink(RGWBucketAdminOpState& op_state, optional_yield y, std::string *err_msg = NULL);
int set_quota(RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
int remove_object(RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
optional_yield y,
ceph::optional_ref_default<RGWBucketCtl::BucketInstance::PutParams> params = std::nullopt);
int remove_bucket_instance_info(const rgw_bucket& bucket,
- optional_yield y,
RGWBucketInfo& info,
+ optional_yield y,
ceph::optional_ref_default<RGWBucketCtl::BucketInstance::RemoveParams> params = std::nullopt);
/*
int read_bucket_info(const rgw_bucket& bucket,
RGWBucketInfo *info,
optional_yield y,
- ceph::optional_ref_default<RGWBucketCtl::BucketInstance::GetParams> _params = std::nullopt);
+ ceph::optional_ref_default<RGWBucketCtl::BucketInstance::GetParams> _params = std::nullopt,
+ RGWObjVersionTracker *ep_objv_tracker = nullptr);
int set_bucket_instance_attrs(RGWBucketInfo& bucket_info,
int link_bucket(const rgw_user& user_id,
const rgw_bucket& bucket,
ceph::real_time creation_time,
+ optional_yield y,
bool update_entrypoint = true);
int unlink_bucket(const rgw_user& user_id,
const rgw_bucket& bucket,
+ optional_yield y,
bool update_entrypoint = true);
int read_buckets_stats(map<string, RGWBucketEnt>& m,
bool exclusive, real_time mtime,
obj_version *pep_objv,
map<string, bufferlist> *pattrs,
- bool create_entry_point);
+ bool create_entry_point,
+ optional_yield);
int do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx,
const rgw_user& user,
const rgw_bucket& bucket,
ceph::real_time creation_time,
+ optional_yield y,
bool update_entrypoint);
int do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx,
const rgw_user& user_id,
const rgw_bucket& bucket,
+ optional_yield y,
bool update_entrypoint);
};
bucket = info.bucket;
}
- ret = store->ctl.bucket->link_bucket(user, bucket, info.creation_time, false);
+ ret = store->ctl.bucket->link_bucket(user, bucket, info.creation_time, null_yield, false);
if (ret && !existed && ret != -EEXIST) {
/* if it exists (or previously existed), don't remove it! */
- int r = store->ctl.bucket->unlink_bucket(user, bucket);
+ int r = store->ctl.bucket->unlink_bucket(user, bucket, null_yield);
if (r < 0) {
ldout(cct, 0) << "WARNING: failed to unlink bucket: ret=" << r << dendl;
}
char buf[16];
snprintf(buf, sizeof(buf), ":%d", i);
s = key + buf;
- yield entries_index->append(s, store->svc.data_log_rados->get_log_shard_id(meta_info.data.get_bucket_info().bucket, i));
+ yield entries_index->append(s, store->svc.datalog_rados->get_log_shard_id(meta_info.data.get_bucket_info().bucket, i));
}
} else {
- yield entries_index->append(key, store->svc.data_log_rados->get_log_shard_id(meta_info.data.get_bucket_info().bucket, -1));
+ yield entries_index->append(key, store->svc.datalog_rados->get_log_shard_id(meta_info.data.get_bucket_info().bucket, -1));
}
}
truncated = result.truncated;
#include "fmt/format.h"
#include "services/svc_sys_obj.h"
+#include "services/svc_zone.h"
#include "services/svc_tier_rados.h"
#define dout_context g_ceph_context
attrs[RGW_ATTR_LC] = std::move(lc_bl);
int ret = store->ctl.bucket->set_bucket_instance_attrs(bucket_info, attrs,
- &bucket_info.objv_tracker);
+ &bucket_info.objv_tracker,
+ null_yield);
if (ret < 0)
return ret;
map<string, bufferlist> attrs = bucket_attrs;
attrs.erase(RGW_ATTR_LC);
int ret = store->ctl.bucket->set_bucket_instance_attrs(bucket_info, attrs,
- &bucket_info.objv_tracker);
+ &bucket_info.objv_tracker,
+ null_yield);
rgw_bucket& bucket = bucket_info.bucket;
return -ENOTSUP;
}
- int remove(string& entry, RGWObjVersionTracker& objv_tracker optional_yield y, override {
- return -ENOTSUP;
- }
-
- int mutate(const string& entry,
- const ceph::real_time& mtime,
- RGWObjVersionTracker *objv_tracker,
- RGWMDLogStatus op_type,
- std::function<int()> f) {
+ int remove(string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y) override {
return -ENOTSUP;
}
int mutate(const string& entry,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
RGWMDLogStatus op_type,
std::function<int()> f) {
return -ENOTSUP;
RGWMetadataHandlerPut_SObj::RGWMetadataHandlerPut_SObj(RGWMetadataHandler_GenericMetaBE *handler, RGWSI_MetaBackend_Handler::Op *op,
string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
- RGWMDLogSyncType type) : Put(handler, op, entry, obj, objv_tracker, type) {
+ optional_yield y,
+ RGWMDLogSyncType type) : Put(handler, op, entry, obj, objv_tracker, y, type) {
}
RGWMetadataHandlerPut_SObj::~RGWMetadataHandlerPut_SObj() {
return 0;
}
-int RGWMetadataHandler_GenericMetaBE::get(string& entry, RGWMetadataObject **obj)
+int RGWMetadataHandler_GenericMetaBE::get(string& entry, RGWMetadataObject **obj, optional_yield y)
{
return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
return do_get(op, entry, obj, y);
});
}
-int RGWMetadataHandler_GenericMetaBE::put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, RGWMDLogSyncType type)
+int RGWMetadataHandler_GenericMetaBE::put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, optional_yield y, RGWMDLogSyncType type)
{
return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
return do_put(op, entry, obj, objv_tracker, y, type);
});
}
-int RGWMetadataHandler_GenericMetaBE::remove(string& entry, RGWObjVersionTracker& objv_tracker)
+int RGWMetadataHandler_GenericMetaBE::remove(string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y)
{
return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
return do_remove(op, entry, objv_tracker, y);
int RGWMetadataHandler_GenericMetaBE::mutate(const string& entry,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
RGWMDLogStatus op_type,
std::function<int()> f)
{
return op->mutate(entry,
params,
objv_tracker,
- f);
- });
-}
-
-int RGWMetadataHandler_GenericMetaBE::mutate(const string& entry,
- const ceph::real_time& mtime,
- RGWObjVersionTracker *objv_tracker,
- RGWMDLogStatus op_type,
- std::function<int()> f)
-{
- return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
- RGWSI_MetaBackend::MutateParams params(mtime, op_type);
- return op->mutate(entry,
- params,
- objv_tracker,
+ y,
f);
});
}
}
-int RGWMetadataManager::get(string& metadata_key, Formatter *f)
+int RGWMetadataManager::get(string& metadata_key, Formatter *f, optional_yield y)
{
RGWMetadataHandler *handler;
string entry;
RGWMetadataObject *obj;
- ret = handler->get(entry, &obj);
+ ret = handler->get(entry, &obj, y);
if (ret < 0) {
return ret;
}
}
int RGWMetadataManager::put(string& metadata_key, bufferlist& bl,
+ optional_yield y,
RGWMDLogSyncType sync_type,
obj_version *existing_version)
{
return -EINVAL;
}
- ret = handler->put(entry, obj, objv_tracker, sync_type);
+ ret = handler->put(entry, obj, objv_tracker, y, sync_type);
if (existing_version) {
*existing_version = objv_tracker.read_version;
}
return ret;
}
-int RGWMetadataManager::remove(string& metadata_key)
+int RGWMetadataManager::remove(string& metadata_key, optional_yield y)
{
RGWMetadataHandler *handler;
string entry;
}
RGWMetadataObject *obj;
- ret = handler->get(entry, &obj);
+ ret = handler->get(entry, &obj, y);
if (ret < 0) {
return ret;
}
objv_tracker.read_version = obj->get_version();
delete obj;
- return handler->remove(entry, objv_tracker);
+ return handler->remove(entry, objv_tracker, y);
}
int RGWMetadataManager::mutate(const string& metadata_key,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
RGWMDLogStatus op_type,
std::function<int()> f)
{
return ret;
}
- return handler->mutate(entry, mtime, objv_tracker, op_type, f);
+ return handler->mutate(entry, mtime, objv_tracker, y, op_type, f);
}
int RGWMetadataManager::get_shard_id(const string& section, const string& entry, int *shard_id)
virtual RGWMetadataObject *get_meta_obj(JSONObj *jo, const obj_version& objv, const ceph::real_time& mtime) = 0;
- virtual int get(string& entry, RGWMetadataObject **obj) = 0;
- virtual int put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, RGWMDLogSyncType type) = 0;
- virtual int remove(string& entry, RGWObjVersionTracker& objv_tracker) = 0;
+ virtual int get(string& entry, RGWMetadataObject **obj, optional_yield) = 0;
+ virtual int put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, optional_yield, RGWMDLogSyncType type) = 0;
+ virtual int remove(string& entry, RGWObjVersionTracker& objv_tracker, optional_yield) = 0;
virtual int mutate(const string& entry,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
RGWMDLogStatus op_type,
std::function<int()> f) = 0;
protected:
RGWSI_MetaBackend_Handler *be_handler;
- virtual int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj) = 0;
+ virtual int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj, optional_yield y) = 0;
virtual int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject *obj,
- RGWObjVersionTracker& objv_tracker, RGWMDLogSyncType type) = 0;
+ RGWObjVersionTracker& objv_tracker, optional_yield y, RGWMDLogSyncType type) = 0;
virtual int do_put_operate(Put *put_op);
- virtual int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) = 0;
+ virtual int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y) = 0;
public:
RGWMetadataHandler_GenericMetaBE() {}
}
};
- int get(string& entry, RGWMetadataObject **obj) override;
- int put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, RGWMDLogSyncType type) override;
- int remove(string& entry, RGWObjVersionTracker& objv_tracker) override;
+ int get(string& entry, RGWMetadataObject **obj, optional_yield) override;
+ int put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, optional_yield, RGWMDLogSyncType type) override;
+ int remove(string& entry, RGWObjVersionTracker& objv_tracker, optional_yield) override;
int mutate(const string& entry,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
RGWMDLogStatus op_type,
std::function<int()> f) override;
int mutate(const string& metadata_key,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
- RGWMDLogStatus op_type,
- std::function<int()> f);
-
- int mutate(const string& metadata_key,
- const ceph::real_time& mtime,
- RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
RGWMDLogStatus op_type,
std::function<int()> f);
public:
RGWMetadataHandlerPut_SObj(RGWMetadataHandler_GenericMetaBE *handler, RGWSI_MetaBackend_Handler::Op *op,
string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
+ optional_yield y,
RGWMDLogSyncType type);
~RGWMetadataHandlerPut_SObj();
/* handle user ACL only for those APIs which support it */
if (s->user_acl) {
map<string, bufferlist> uattrs;
- ret = store->ctl.user->get_attrs_by_uid(acct_acl_user.uid, &uattrs);
+ ret = store->ctl.user->get_attrs_by_uid(acct_acl_user.uid, &uattrs, s->yield);
if (!ret) {
ret = get_user_policy_from_attr(s->cct, store, uattrs, *s->user_acl);
}
if (! s->user->user_id.empty() && s->auth.identity->get_identity_type() != TYPE_ROLE) {
try {
map<string, bufferlist> uattrs;
- if (ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &uattrs); ! ret) {
+ if (ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &uattrs, s->yield); ! ret) {
if (s->iam_user_policies.empty()) {
s->iam_user_policies = get_iam_user_policy_from_attr(s->cct, store, uattrs, s->user->user_id.tenant);
} else {
op_ret = retry_raced_bucket_write(store, s, [this] {
map<string, bufferlist> attrs = s->bucket_attrs;
attrs[RGW_ATTR_TAGS] = tags_bl;
- return rgw_bucket_set_attrs(store, s->bucket_info, attrs, &s->bucket_info.objv_tracker);
+ return store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs, &s->bucket_info.objv_tracker, s->yield);
});
}
op_ret = retry_raced_bucket_write(store, s, [this] {
map<string, bufferlist> attrs = s->bucket_attrs;
attrs.erase(RGW_ATTR_TAGS);
- op_ret = rgw_bucket_set_attrs(store, s->bucket_info, attrs, &s->bucket_info.objv_tracker);
+ op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs, &s->bucket_info.objv_tracker, s->yield);
if (op_ret < 0) {
ldpp_dout(this, 0) << "RGWDeleteBucketTags() failed to remove RGW_ATTR_TAGS on bucket="
<< s->bucket.name
}
if (supports_account_metadata()) {
- op_ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &attrs);
+ op_ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &attrs, s->yield);
if (op_ret < 0) {
goto send_end;
}
}
op_ret = store->ctl.bucket->link_bucket(s->user->user_id, s->bucket,
- info.creation_time, false);
+ info.creation_time, s->yield, false);
if (op_ret && !existed && op_ret != -EEXIST) {
/* if it exists (or previously existed), don't remove it! */
- op_ret = store->ctl.bucket->unlink_bucket(s->user->user_id, s->bucket);
+ op_ret = store->ctl.bucket->unlink_bucket(s->user->user_id, s->bucket, s->yield);
if (op_ret < 0) {
ldpp_dout(this, 0) << "WARNING: failed to unlink bucket: ret=" << op_ret
<< dendl;
/* This will also set the quota on the bucket. */
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
} while (op_ret == -ECANCELED && tries++ < 20);
/* Restore the proper return code. */
if (op_ret == 0) {
op_ret = store->ctl.bucket->unlink_bucket(s->bucket_info.owner,
- s->bucket, false);
+ s->bucket, s->yield, false);
if (op_ret < 0) {
ldpp_dout(this, 0) << "WARNING: failed to unlink bucket: ret=" << op_ret
<< dendl;
}
op_ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &orig_attrs,
+ s->yield,
&acct_op_tracker);
if (op_ret < 0) {
return op_ret;
* to this fact, the new quota settings can be serialized with
* the same call. */
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
return op_ret;
});
}
attrs = s->bucket_attrs;
attrs[RGW_ATTR_ACL] = bl;
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
}
if (op_ret == -ECANCELED) {
op_ret = 0; /* lost a race, but it's ok because acls are immutable */
map<string, bufferlist> attrs = s->bucket_attrs;
attrs.erase(RGW_ATTR_LC);
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
if (op_ret < 0) {
ldpp_dout(this, 0) << "RGWLC::RGWDeleteLC() failed to set attrs on bucket="
<< s->bucket.name << " returned err=" << op_ret << dendl;
map<string, bufferlist> attrs = s->bucket_attrs;
attrs[RGW_ATTR_CORS] = cors_bl;
return store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
});
}
map<string, bufferlist> attrs = s->bucket_attrs;
attrs.erase(RGW_ATTR_CORS);
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
if (op_ret < 0) {
ldpp_dout(this, 0) << "RGWLC::RGWDeleteCORS() failed to set attrs on bucket=" << s->bucket.name
<< " returned err=" << op_ret << dendl;
} else {
ret = store->delete_bucket(binfo, ot, s->yield);
if (0 == ret) {
- ret = store->ctl.bucket->unlink_bucket(binfo.owner, binfo.bucket, false);
+ ret = store->ctl.bucket->unlink_bucket(binfo.owner, binfo.bucket, s->yield, false);
if (ret < 0) {
ldpp_dout(s, 0) << "WARNING: failed to unlink bucket: ret=" << ret << dendl;
}
}
op_ret = store->ctl.bucket->link_bucket(s->user->user_id, bucket,
- out_info.creation_time, false);
+ out_info.creation_time,
+ s->yield, false);
if (op_ret && !existed && op_ret != -EEXIST) {
/* if it exists (or previously existed), don't remove it! */
- op_ret = store->ctl.bucket->unlink_bucket(s->user->user_id, bucket);
+ op_ret = store->ctl.bucket->unlink_bucket(s->user->user_id, bucket, s->yield);
if (op_ret < 0) {
ldpp_dout(this, 0) << "WARNING: failed to unlink bucket: ret=" << op_ret << dendl;
}
s->bucket_attrs[iter.first] = std::move(iter.second);
}
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
}
}
attrs[RGW_ATTR_IAM_POLICY].clear();
attrs[RGW_ATTR_IAM_POLICY].append(p.text);
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
return op_ret;
});
} catch (rgw::IAM::PolicyParseException& e) {
auto attrs = s->bucket_attrs;
attrs.erase(RGW_ATTR_IAM_POLICY);
op_ret = store->ctl.bucket->set_bucket_instance_attrs(s->bucket_info, attrs,
- &s->bucket_info.objv_tracker);
+ &s->bucket_info.objv_tracker,
+ s->yield);
return op_ret;
});
}
return new RGWOTPMetadataObject(std::move(devices), objv, mtime);
}
- int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj) override {
+ int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj, optional_yield y) override {
RGWObjVersionTracker objv_tracker;
std::unique_ptr<RGWOTPMetadataObject> mdo(new RGWOTPMetadataObject);
entry,
&mdo->get_devs(),
&mdo->get_mtime(),
- &objv_tracker);
+ &objv_tracker,
+ y);
if (ret < 0) {
return ret;
}
int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
+ optional_yield y,
RGWMDLogSyncType type) override {
RGWOTPMetadataObject *obj = static_cast<RGWOTPMetadataObject *>(_obj);
entry,
obj->devices,
obj->mtime,
- &objv_tracker);
+ &objv_tracker,
+ y);
if (ret < 0) {
return ret;
}
return STATUS_APPLIED;
}
- int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) override {
+ int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
+ optional_yield y) override {
RGWSI_MBOTP_RemoveParams params;
RGWSI_OTP_BE_Ctx be_ctx(op->ctx());
return svc.otp->remove_all(be_ctx,
entry,
- &objv_tracker);
+ &objv_tracker,
+ y);
}
public:
int RGWOTPCtl::read_all(const rgw_user& uid,
RGWOTPInfo *info,
+ optional_yield y,
ceph::optional_ref_default<RGWOTPCtl::GetParams> _params)
{
auto& params = *_params;
info->uid = uid;
return meta_handler->call([&](RGWSI_OTP_BE_Ctx& ctx) {
- return svc.otp->read_all(ctx, uid, &info->devices, params.mtime, params.objv_tracker);
+ return svc.otp->read_all(ctx, uid, &info->devices, params.mtime, params.objv_tracker, y);
});
}
int RGWOTPCtl::store_all(const RGWOTPInfo& info,
+ optional_yield y,
ceph::optional_ref_default<RGWOTPCtl::PutParams> _params)
{
auto& params = *_params;
return meta_handler->call([&](RGWSI_OTP_BE_Ctx& ctx) {
- return svc.otp->store_all(ctx, info.uid, info.devices, params.mtime, params.objv_tracker);
+ return svc.otp->store_all(ctx, info.uid, info.devices, params.mtime, params.objv_tracker, y);
});
}
int RGWOTPCtl::remove_all(const rgw_user& uid,
- ceph::optional_ref_default<RGWOTPCtl::RemoveParams> _params)
+ optional_yield y,
+ ceph::optional_ref_default<RGWOTPCtl::RemoveParams> _params)
{
auto& params = *_params;
return meta_handler->call([&](RGWSI_OTP_BE_Ctx& ctx) {
- return svc.otp->remove_all(ctx, uid, params.objv_tracker);
+ return svc.otp->remove_all(ctx, uid, params.objv_tracker, y);
});
}
}
};
- int read_all(const rgw_user& uid, RGWOTPInfo *info, ceph::optional_ref_default<GetParams> params);
- int store_all(const RGWOTPInfo& info, ceph::optional_ref_default<PutParams> params);
- int remove_all(const rgw_user& user, ceph::optional_ref_default<RemoveParams> params);
+ int read_all(const rgw_user& uid, RGWOTPInfo *info, optional_yield y, ceph::optional_ref_default<GetParams> params);
+ int store_all(const RGWOTPInfo& info,
optional_yield y, ceph::optional_ref_default<PutParams> params);
+ int remove_all(const rgw_user& user, optional_yield y, ceph::optional_ref_default<RemoveParams> params);
};
#endif
size_t pos = s.find("-");
cur_etag = s.substr(0, pos);
}
- cur_manifest = &astate->manifest;
+ cur_manifest = &(*astate->manifest);
manifest.set_prefix(cur_manifest->get_prefix());
}
manifest.set_multipart_part_rule(store->ctx()->_conf->rgw_obj_stripe_size, cur_part_num);
ref->pool = svc.rados->pool(pool);
- int r = ref->pool.open(RGWSI_RADOS::Pool::OpenParams()
- .set_mostly_omap(false);
+ int r = ref->pool.open(RGWSI_RADOS::OpenParams()
+ .set_mostly_omap(false));
if (r < 0) {
ldout(cct, 0) << "ERROR: failed opening data pool (pool=" << pool << "); r=" << r << dendl;
return r;
ref->obj.pool = svc.zone->get_zone_params().domain_root;
}
ref->pool = svc.rados->pool(obj.pool);
- int r = ref->pool.open(RGWSI_RADOS::Pool::OpenParams()
- .set_mostly_omap(false);
+ int r = ref->pool.open(RGWSI_RADOS::OpenParams()
+ .set_mostly_omap(false));
if (r < 0) {
ldout(cct, 0) << "ERROR: failed opening pool (pool=" << obj.pool << "); r=" << r << dendl;
return r;
RGWBucketEntryPoint ep;
r = ctl.bucket->read_bucket_entrypoint_info(bucket_info.bucket,
&ep,
+ null_yield,
RGWBucketCtl::Bucket::GetParams()
.set_objv_tracker(&objv_tracker));
if (r < 0 ||
}
if (remove_ep) {
- r = ctl.bucket->remove_bucket_entrypoint_info(bucket_info.bucket,
+ r = ctl.bucket->remove_bucket_entrypoint_info(bucket_info.bucket, null_yield,
RGWBucketCtl::Bucket::RemoveParams()
.set_objv_tracker(&objv_tracker));
if (r < 0)
/* if the bucket is not synced we can remove the meta file */
if (!svc.zone->is_syncing_bucket_meta(bucket)) {
RGWObjVersionTracker objv_tracker;
- r = ctl.bucket->remove_bucket_instance_info(bucket, bucket_info);
+ r = ctl.bucket->remove_bucket_instance_info(bucket, bucket_info, null_yield);
if (r < 0) {
return r;
}
pg_ver(state.pg_ver) {}
};
-struct tombstone_entry {
- ceph::real_time mtime;
- uint32_t zone_short_id;
- uint64_t pg_ver;
-
- tombstone_entry() = default;
- explicit tombstone_entry(const RGWObjState& state)
- : mtime(state.mtime), zone_short_id(state.zone_short_id),
- pg_ver(state.pg_ver) {}
-};
-
/**
* Delete an object.
* bucket: name of the bucket storing the object
if (need_follow_olh) {
return get_olh_target_state(*rctx, bucket_info, obj, s, state, y);
- } else if (obj.key.have_null_instance() && !s->has_manifest) {
+ } else if (obj.key.have_null_instance() && !s->manifest) {
// read null version, and the head object only have olh info
s->exists = false;
return -ENOENT;
return r;
// ensure null version object exist
- if (src_obj.key.instance == "null" && !state->has_manifest) {
+ if (src_obj.key.instance == "null" && !state->manifest) {
return -ENOENT;
}
{
RGWSI_MetaBackend_CtxParams bectx_params = RGWSI_MetaBackend_CtxParams_SObj(&obj_ctx);
return ctl.bucket->read_bucket_instance_info(bucket, &info,
+ y,
RGWBucketCtl::BucketInstance::GetParams()
.set_mtime(pmtime)
.set_attrs(pattrs)
- .set_bectx_params(bectx_params),
- .set_yield(y));
+ .set_bectx_params(bectx_params));
}
int RGWRados::get_bucket_info(RGWSysObjectCtx& obj_ctx,
auto rv = info.objv_tracker.read_version;
- return ctl.bucket->read_bucket_info(bucket, &info,
+ return ctl.bucket->read_bucket_info(bucket, &info, null_yield,
RGWBucketCtl::BucketInstance::GetParams()
.set_mtime(pmtime)
.set_attrs(pattrs)
int RGWRados::put_bucket_instance_info(RGWBucketInfo& info, bool exclusive,
real_time mtime, map<string, bufferlist> *pattrs)
{
- return ctl.bucket->store_bucket_instance_info(info.bucket, info,
+ return ctl.bucket->store_bucket_instance_info(info.bucket, info, null_yield,
RGWBucketCtl::BucketInstance::PutParams()
.set_exclusive(exclusive)
.set_mtime(mtime)
*pep_objv = ot.write_version;
}
}
- ret = ctl.bucket->store_bucket_entrypoint_info(info.bucket, entry_point, RGWBucketCtl::Bucket::PutParams()
+ ret = ctl.bucket->store_bucket_entrypoint_info(info.bucket, entry_point, null_yield, RGWBucketCtl::Bucket::PutParams()
.set_exclusive(exclusive)
.set_objv_tracker(&ot)
.set_mtime(mtime));
};
-class RGWRadosThread {
- class Worker : public Thread {
- CephContext *cct;
- RGWRadosThread *processor;
- Mutex lock;
- Cond cond;
-
- void wait() {
- Mutex::Locker l(lock);
- cond.Wait(lock);
- };
-
- void wait_interval(const utime_t& wait_time) {
- Mutex::Locker l(lock);
- cond.WaitInterval(lock, wait_time);
- }
-
- public:
- Worker(CephContext *_cct, RGWRadosThread *_p) : cct(_cct), processor(_p), lock("RGWRadosThread::Worker") {}
- void *entry() override;
- void signal() {
- Mutex::Locker l(lock);
- cond.Signal();
- }
- };
-
- Worker *worker;
-
-protected:
- CephContext *cct;
- RGWRados *store;
-
- std::atomic<bool> down_flag = { false };
-
- string thread_name;
-
- virtual uint64_t interval_msec() = 0;
- virtual void stop_process() {}
-public:
- RGWRadosThread(RGWRados *_store, const string& thread_name = "radosgw")
- : worker(NULL), cct(_store->ctx()), store(_store), thread_name(thread_name) {}
- virtual ~RGWRadosThread() {
- stop();
- }
-
- virtual int init() { return 0; }
- virtual int process() = 0;
-
- bool going_down() { return down_flag; }
-
- void start();
- void stop();
-
- void signal() {
- if (worker) {
- worker->signal();
- }
- }
-};
-
#endif
return -EIO;
}
- ret = store->ctl.bucket->link_bucket(new_bucket_info.owner, new_bucket_info.bucket, bucket_info.creation_time);
+ ret = store->ctl.bucket->link_bucket(new_bucket_info.owner, new_bucket_info.bucket, bucket_info.creation_time, null_yield);
if (ret < 0) {
lderr(store->ctx()) << "failed to link new bucket instance (bucket_id=" << new_bucket_info.bucket.bucket_id << ": " << cpp_strerror(-ret) << ")" << dendl;
return ret;
}
ret = store->ctl.bucket->remove_bucket_instance_info(bucket_info.bucket,
- bucket_info);
+ bucket_info, null_yield);
if (ret < 0) {
lderr(store->ctx()) << "Error: " << __func__ <<
" failed to clean old bucket info object \"" <<
ret2 = store->ctl.bucket->remove_bucket_instance_info(new_bucket_info.bucket,
new_bucket_info,
+ null_yield,
std::nullopt);
if (ret2 < 0) {
lderr(store->ctx()) << "Error: " << __func__ <<
if (! s->user->user_id.empty() && s->auth.identity->get_identity_type() != TYPE_ROLE) {
try {
map<string, bufferlist> uattrs;
- if (auto ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &uattrs); ! ret) {
+ if (auto ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &uattrs, null_yield); ! ret) {
if (s->iam_user_policies.empty()) {
s->iam_user_policies = get_iam_user_policy_from_attr(s->cct, store, uattrs, s->user->user_id.tenant);
} else {
auto meta_mgr = store->ctl.meta.mgr;
/* Get keys */
- http_ret = meta_mgr->get(metadata_key, s->formatter);
+ http_ret = meta_mgr->get(metadata_key, s->formatter, s->yield);
if (http_ret < 0) {
dout(5) << "ERROR: can't get key: " << cpp_strerror(http_ret) << dendl;
return;
}
}
- http_ret = store->ctl.meta.mgr->put(metadata_key, bl, sync_type,
+ http_ret = store->ctl.meta.mgr->put(metadata_key, bl, s->yield, sync_type,
&ondisk_version);
if (http_ret < 0) {
dout(5) << "ERROR: can't put key: " << cpp_strerror(http_ret) << dendl;
string metadata_key;
frame_metadata_key(s, metadata_key);
- http_ret = store->ctl.meta.mgr->remove(metadata_key);
+ http_ret = store->ctl.meta.mgr->remove(metadata_key, s->yield);
if (http_ret < 0) {
dout(5) << "ERROR: can't remove key: " << cpp_strerror(http_ret) << dendl;
return;
void RGWStatAccount_ObjStore_SWIFT::execute()
{
RGWStatAccount_ObjStore::execute();
- op_ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &attrs);
+ op_ret = store->ctl.user->get_attrs_by_uid(s->user->user_id, &attrs, s->yield);
}
void RGWStatAccount_ObjStore_SWIFT::send_response()
}
map<string, bufferlist> uattrs;
- op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs);
+ op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs, s->yield);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
rgw_user user_id(user_name);
map<string, bufferlist> uattrs;
- op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs);
+ op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs, s->yield);
if (op_ret == -ENOENT) {
ldout(s->cct, 0) << "ERROR: attrs not found for user" << user_name << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
rgw_user user_id(user_name);
map<string, bufferlist> uattrs;
- op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs);
+ op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs, s->yield);
if (op_ret == -ENOENT) {
ldout(s->cct, 0) << "ERROR: attrs not found for user" << user_name << dendl;
op_ret = -ERR_NO_SUCH_ENTITY;
}
map<string, bufferlist> uattrs;
- op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs);
+ op_ret = store->ctl.user->get_attrs_by_uid(user_id, &uattrs, s->yield);
if (op_ret == -ENOENT) {
op_ret = -ERR_NO_SUCH_ENTITY;
return;
bufferlist bl;
protected:
int _send_request() override {
- int ret = store->ctl.meta.mgr->put(raw_key, bl, RGWMDLogSyncType::APPLY_ALWAYS);
+ int ret = store->ctl.meta.mgr->put(raw_key, bl, null_yield, RGWMDLogSyncType::APPLY_ALWAYS);
if (ret < 0) {
ldout(store->ctx(), 0) << "ERROR: can't store key: " << raw_key << " ret=" << ret << dendl;
return ret;
string raw_key;
protected:
int _send_request() override {
- int ret = store->ctl.meta.mgr->remove(raw_key);
+ int ret = store->ctl.meta.mgr->remove(raw_key, null_yield);
if (ret < 0) {
ldout(store->ctx(), 0) << "ERROR: can't remove key: " << raw_key << " ret=" << ret << dendl;
return ret;
}
int rgw_put_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
- RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs)
+ RGWObjVersionTracker *objv_tracker, real_time set_mtime, optional_yield y, map<string, bufferlist> *pattrs)
{
map<string,bufferlist> no_attrs;
if (!pattrs) {
.set_exclusive(exclusive)
.set_mtime(set_mtime)
.set_attrs(*pattrs)
- .write(data, null_yield);
+ .write(data, y);
return ret;
}
+int rgw_put_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs)
+{
+ return rgw_put_system_obj(obj_ctx, pool, oid, data, exclusive,
+ objv_tracker, set_mtime, null_yield, pattrs);
+}
+
int rgw_get_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& key, bufferlist& bl,
RGWObjVersionTracker *objv_tracker, real_time *pmtime, optional_yield y, map<string, bufferlist> *pattrs,
+ rgw_cache_entry_info *cache_info,
+ boost::optional<obj_version> refresh_version)
{
bufferlist::iterator iter;
int request_len = READ_CHUNK_LEN;
int rgw_put_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs = NULL);
+int rgw_put_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, real_time set_mtime, optional_yield y, map<string, bufferlist> *pattrs = NULL);
int rgw_get_system_obj(RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& key, bufferlist& bl,
RGWObjVersionTracker *objv_tracker, real_time *pmtime, optional_yield y, map<string, bufferlist> *pattrs = NULL,
rgw_cache_entry_info *cache_info = NULL,
#include "rgw_zone.h"
#include "rgw_bucket.h"
+#include "services/svc_zone.h"
+#include "services/svc_datalog_rados.h"
+
#include <boost/asio/yield.hpp>
#define dout_subsys ceph_subsys_rgw
RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
optional_yield y,
- RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, op, entry, obj, objv_tracker, type),
+ RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(_handler, op, entry, obj, objv_tracker, y, type),
uhandler(_handler) {
uobj = static_cast<RGWUserMetadataObject *>(obj);
}
return *this;
}
- RemoveParams& set_yield(optional_yield _y) {
+ GetParams& set_yield(optional_yield _y) {
y = _y;
return *this;
}
return *this;
}
- RemoveParams& set_yield(optional_yield _y) {
+ PutParams& set_yield(optional_yield _y) {
y = _y;
return *this;
}
virtual int clean_index(RGWBucketInfo& bucket_info) = 0;
virtual int read_stats(const RGWBucketInfo& bucket_info,
- RGWBucketEnt *stats) = 0;
+ RGWBucketEnt *stats,
+ optional_yield y) = 0;
virtual int handle_overwrite(const RGWBucketInfo& info,
const RGWBucketInfo& orig_info) = 0;
int ret = open_bucket_index_base(bucket_info, index_pool, &bucket_oid_base);
if (ret < 0) {
ldout(cct, 20) << __func__ << ": open_bucket_index_pool() returned "
- << r << dendl;
+ << ret << dendl;
return ret;
}
int ret = open_bucket_index_base(bucket_info, &pool, &bucket_oid_base);
if (ret < 0) {
ldout(cct, 20) << __func__ << ": open_bucket_index_pool() returned "
- << r << dendl;
+ << ret << dendl;
return ret;
}
int ret = open_bucket_index_base(bucket_info, &index_pool, &bucket_oid_base);
if (ret < 0) {
ldout(cct, 20) << __func__ << ": open_bucket_index_pool() returned "
- << r << dendl;
+ << ret << dendl;
return ret;
}
int RGWSI_BucketIndex_RADOS::cls_bucket_head(const RGWBucketInfo& bucket_info,
int shard_id,
vector<rgw_bucket_dir_header> *headers,
- map<int, string> *bucket_instance_ids)
+ map<int, string> *bucket_instance_ids,
+ optional_yield y)
{
RGWSI_RADOS::Pool index_pool;
map<int, string> oids;
}
int RGWSI_BucketIndex_RADOS::read_stats(const RGWBucketInfo& bucket_info,
- RGWBucketEnt *result)
+ RGWBucketEnt *result,
+ optional_yield y)
{
vector<rgw_bucket_dir_header> headers;
result->bucket = bucket_info.bucket;
- int r = cls_bucket_head(bucket_info, RGW_NO_SHARD, &headers, nullptr);
+ int r = cls_bucket_head(bucket_info, RGW_NO_SHARD, &headers, nullptr, y);
if (r < 0) {
return r;
}
int cls_bucket_head(const RGWBucketInfo& bucket_info,
int shard_id,
vector<rgw_bucket_dir_header> *headers,
- map<int, string> *bucket_instance_ids);
+ map<int, string> *bucket_instance_ids,
+ optional_yield y);
public:
/* RADOS specific */
int read_stats(const RGWBucketInfo& bucket_info,
- RGWBucketEnt *stats) override;
+ RGWBucketEnt *stats,
+ optional_yield y) override;
int get_reshard_status(const RGWBucketInfo& bucket_info,
std::list<cls_rgw_bucket_instance_entry> *status);
{
vector<rgw_bucket_dir_header> headers;
map<int, string> bucket_instance_ids;
- int r = svc.bi->cls_bucket_head(bucket_info, shard_id, &headers, &bucket_instance_ids);
+ int r = svc.bi->cls_bucket_head(bucket_info, shard_id, &headers, &bucket_instance_ids, null_yield);
if (r < 0)
return r;
virtual int remove_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
const string& key,
- RGWObjVersionTracker *objv_tracker) = 0;
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y) = 0;
virtual int read_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
const string& key,
auto params = RGWSI_MBSObj_GetParams(&bl, pattrs, pmtime).set_cache_info(cache_info)
.set_refresh_version(refresh_version);
- int ret = svc.meta_be->get_entry(ctx.get(), key, params, objv_tracker);
+ int ret = svc.meta_be->get_entry(ctx.get(), key, params, objv_tracker, y);
if (ret < 0) {
return ret;
}
RGWSI_MBSObj_PutParams params(bl, pattrs, mtime, exclusive);
- int ret = svc.meta_be->put(ctx.get(), key, params, objv_tracker);
+ int ret = svc.meta_be->put(ctx.get(), key, params, objv_tracker, y);
if (ret == -EEXIST) {
/* well, if it's exclusive we shouldn't overwrite it, because we might race with another
* bucket operation on this specific bucket (e.g., being synced from the master), but
return read_bucket_instance_info(ctx.bi, get_bi_meta_key(bucket),
info,
pmtime, pattrs,
+ y,
&cache_info, refresh_version);
}
rgw_cache_entry_info entry_cache_info;
int ret = read_bucket_entrypoint_info(ctx.ep, bucket_entry,
&entry_point, &ot, &ep_mtime, pattrs,
- &entry_cache_info, refresh_version,
- y);
+ y,
+ &entry_cache_info, refresh_version);
if (ret < 0) {
/* only init these fields */
info->bucket = bucket;
ret = read_bucket_instance_info(ctx.bi, get_bi_meta_key(entry_point.bucket),
&e.info, &e.mtime, &e.attrs,
- &cache_info, refresh_version, y);
+ y,
+ &cache_info, refresh_version);
*info = e.info;
if (ret < 0) {
lderr(cct) << "ERROR: read_bucket_instance_from_oid failed: " << ret << dendl;
*pattrs = e.attrs;
/* chain to both bucket entry point and bucket instance */
- if (!binfo_cache->put(svc.cache, cache_key, &e, {&entry_cache_info, &cache_info}, y)) {
+ if (!binfo_cache->put(svc.cache, cache_key, &e, {&entry_cache_info, &cache_info})) {
ldout(cct, 20) << "couldn't put binfo cache entry, might have raced with data changes" << dendl;
}
key,
&_orig_info,
nullptr, nullptr,
+ y,
nullptr, boost::none);
if (r < 0) {
if (r != -ENOENT) {
real_time *pmtime,
map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info,
- boost::optional<obj_version> refresh_version);
+ boost::optional<obj_version> refresh_version,
+ optional_yield y);
int read_bucket_stats(const RGWBucketInfo& bucket_info,
RGWBucketEnt *ent,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
RGWMDLogStatus op_type,
+ optional_yield y,
std::function<int()> f,
- bool generic_prepare,
- optional_yield y)
+ bool generic_prepare)
{
int ret;
return do_mutate(ctx, key, params.mtime, objv_tracker,
MDLOG_STATUS_WRITE,
+ y,
f,
- false,
- y);
+ false);
}
int RGWSI_MetaBackend::remove(Context *ctx,
return do_mutate(ctx, key, params.mtime, objv_tracker,
MDLOG_STATUS_REMOVE,
+ y,
f,
- false,
- y);
+ false);
}
int RGWSI_MetaBackend::mutate(Context *ctx,
const std::string& key,
MutateParams& params,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
std::function<int()> f)
{
return do_mutate(ctx, key, params.mtime, objv_tracker,
- params.op_type,
+ params.op_type, y,
f,
false);
}
const std::string& key,
const ceph::real_time& mtime, RGWObjVersionTracker *objv_tracker,
RGWMDLogStatus op_type,
+ optional_yield y,
std::function<int()> f,
- bool generic_prepare,
- optional_yield y);
+ bool generic_prepare);
virtual int pre_modify(Context *ctx,
const std::string& key,
const std::string& key,
MutateParams& params,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
std::function<int()> f);
};
int get(const std::string& key,
RGWSI_MetaBackend::GetParams ¶ms,
- RGWObjVersionTracker *objv_tracker) {
- return be->get(be_ctx, key, params, objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y) {
+ return be->get(be_ctx, key, params, objv_tracker, y);
}
int put(const std::string& key,
RGWSI_MetaBackend::PutParams& params,
- RGWObjVersionTracker *objv_tracker) {
- return be->put(be_ctx, key, params, objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y) {
+ return be->put(be_ctx, key, params, objv_tracker, y);
}
int remove(const std::string& key,
RGWSI_MetaBackend::RemoveParams& params,
- RGWObjVersionTracker *objv_tracker) {
- return be->remove(be_ctx, key, params, objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y) {
+ return be->remove(be_ctx, key, params, objv_tracker, y);
}
int mutate(const std::string& key,
RGWSI_MetaBackend::MutateParams& params,
RGWObjVersionTracker *objv_tracker,
+ optional_yield y,
std::function<int()> f) {
- return be->mutate(be_ctx, key, params, objv_tracker, f);
+ return be->mutate(be_ctx, key, params, objv_tracker, y, f);
}
int list_init(const string& marker) {
const string& key,
otp_devices_list_t *devices,
real_time *pmtime,
- RGWObjVersionTracker *objv_tracker)
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y)
{
RGWSI_MBOTP_GetParams params;
params.pdevices = devices;
params.pmtime = pmtime;
- int ret = svc.meta_be->get_entry(ctx.get(), key, params, objv_tracker);
+ int ret = svc.meta_be->get_entry(ctx.get(), key, params, objv_tracker, y);
if (ret < 0) {
return ret;
}
const rgw_user& uid,
otp_devices_list_t *devices,
real_time *pmtime,
- RGWObjVersionTracker *objv_tracker)
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y)
{
return read_all(ctx,
uid.to_str(),
devices,
pmtime,
- objv_tracker);
+ objv_tracker,
+ y);
}
int RGWSI_OTP::store_all(RGWSI_OTP_BE_Ctx& ctx,
const string& key,
const otp_devices_list_t& devices,
real_time mtime,
- RGWObjVersionTracker *objv_tracker)
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y)
{
RGWSI_MBOTP_PutParams params;
params.mtime = mtime;
params.devices = devices;
- int ret = svc.meta_be->put_entry(ctx.get(), key, params, objv_tracker);
+ int ret = svc.meta_be->put_entry(ctx.get(), key, params, objv_tracker, y);
if (ret < 0) {
return ret;
}
const rgw_user& uid,
const otp_devices_list_t& devices,
real_time mtime,
- RGWObjVersionTracker *objv_tracker)
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y)
{
return store_all(ctx,
uid.to_str(),
devices,
mtime,
- objv_tracker);
+ objv_tracker,
+ y);
}
int RGWSI_OTP::remove_all(RGWSI_OTP_BE_Ctx& ctx,
const string& key,
- RGWObjVersionTracker *objv_tracker)
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y)
{
RGWSI_MBOTP_RemoveParams params;
- int ret = svc.meta_be->remove_entry(ctx.get(), key, params, objv_tracker);
+ int ret = svc.meta_be->remove_entry(ctx.get(), key, params, objv_tracker, y);
if (ret < 0) {
return ret;
}
int RGWSI_OTP::remove_all(RGWSI_OTP_BE_Ctx& ctx,
const rgw_user& uid,
- RGWObjVersionTracker *objv_tracker)
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y)
{
return remove_all(ctx,
uid.to_str(),
- objv_tracker);
+ objv_tracker,
+ y);
}
const string& key,
otp_devices_list_t *devices,
real_time *pmtime,
- RGWObjVersionTracker *objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y);
int read_all(RGWSI_OTP_BE_Ctx& ctx,
const rgw_user& uid,
otp_devices_list_t *devices,
real_time *pmtime,
- RGWObjVersionTracker *objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y);
int store_all(RGWSI_OTP_BE_Ctx& ctx,
const string& key,
const otp_devices_list_t& devices,
real_time mtime,
- RGWObjVersionTracker *objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y);
int store_all(RGWSI_OTP_BE_Ctx& ctx,
const rgw_user& uid,
const otp_devices_list_t& devices,
real_time mtime,
- RGWObjVersionTracker *objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y);
int remove_all(RGWSI_OTP_BE_Ctx& ctx,
const string& key,
- RGWObjVersionTracker *objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y);
int remove_all(RGWSI_OTP_BE_Ctx& ctx,
const rgw_user& uid,
- RGWObjVersionTracker *objv_tracker);
+ RGWObjVersionTracker *objv_tracker,
+ optional_yield y);
};
#define dout_subsys ceph_subsys_rgw
+RGWSI_RADOS::RGWSI_RADOS(CephContext *cct) : RGWServiceInstance(cct)
+{
+}
+
RGWSI_RADOS::~RGWSI_RADOS()
{
}
return objs.size();
}
-RGWSI_RADOS::Obj::Obj(Pool& pool, const string& oid) : rados_svc(pool.rados_svc), rados_handle(pool.rados_handle)
+RGWSI_RADOS::Obj::Obj(Pool& pool, const string& oid) : rados_svc(pool.rados_svc)
{
ref.pool = pool;
ref.obj = rgw_raw_obj(pool.get_pool(), oid);
void RGWSI_RADOS::Obj::init(const rgw_raw_obj& obj)
{
- ref.pool = RGWSI_RADOS::Pool(rados_svc, obj.pool, rados_handle);
+ ref.pool = RGWSI_RADOS::Pool(rados_svc, obj.pool);
ref.obj = obj;
}
bool *is_truncated);
public:
- RGWSI_RADOS(CephContext *cct) : RGWServiceInstance(cct) {}
+ RGWSI_RADOS(CephContext *cct);
~RGWSI_RADOS();
void init() {}
s.append(part);
return s;
}
- string& get_upload_id() const {
+ const string& get_upload_id() const {
return upload_id;
}
- string& get_key() const {
+ const string& get_key() const {
return oid;
}
bool from_meta(string& meta) {
* @return true if the name provided is in the form of a multipart meta
* object, false otherwise
*/
- bool filter(string& name, string& key) override;
+ bool filter(const string& name, string& key) override;
};
class RGWSI_Tier_RADOS : public RGWServiceInstance
return -EIO;
}
- uinfo_cache->put(svc.cache, cache_key, &e, { &cache_info }, y);
+ uinfo_cache->put(svc.cache, cache_key, &e, { &cache_info });
*info = e.info;
if (objv_tracker)
TYPE(rgw_bucket)
TYPE(RGWBucketInfo)
TYPE(RGWBucketEnt)
-TYPE(RGWUploadPartInfo)
TYPE(rgw_obj)
#include "rgw/rgw_log.h"
TYPE(rgw_meta_sync_marker)
TYPE(rgw_meta_sync_status)
+#include "rgw/rgw_multi.h"
+TYPE(RGWUploadPartInfo)
+
#include "rgw/rgw_data_sync.h"
TYPE(rgw_data_sync_info)
TYPE(rgw_data_sync_marker)
projects / ceph-ci.git / commitdiff