real_time mtime;
map<string, bufferlist> attrs;
- RGWSI_Bucket_EP_Ctx ctx(op->ctx());
-
- int ret = svc.bucket->read_bucket_entrypoint_info(ctx, entry, &be, &ot, &mtime, &attrs, y, dpp);
+ int ret = svc.bucket->read_bucket_entrypoint_info(entry, &be, &ot, &mtime, &attrs, y, dpp);
if (ret < 0)
return ret;
real_time orig_mtime;
- RGWSI_Bucket_EP_Ctx ctx(op->ctx());
-
- int ret = svc.bucket->read_bucket_entrypoint_info(ctx, entry, &be, &objv_tracker, &orig_mtime, nullptr, y, dpp);
+ int ret = svc.bucket->read_bucket_entrypoint_info(entry, &be, &objv_tracker, &orig_mtime, nullptr, y, dpp);
if (ret < 0)
return ret;
ldpp_dout(dpp, -1) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
}
- ret = svc.bucket->remove_bucket_entrypoint_info(ctx, entry, &objv_tracker, y, dpp);
+ ret = svc.bucket->remove_bucket_entrypoint_info(entry, &objv_tracker, y, dpp);
if (ret < 0) {
ldpp_dout(dpp, -1) << "could not delete bucket=" << entry << dendl;
}
RGWSI_Bucket_EP_Ctx ctx(op->ctx());
- return bhandler->svc.bucket->store_bucket_entrypoint_info(ctx, entry,
+ return bhandler->svc.bucket->store_bucket_entrypoint_info(entry,
be,
false,
mtime,
optional_yield y, const DoutPrefixProvider *dpp) override {
auto cct = svc.bucket->ctx();
- RGWSI_Bucket_EP_Ctx ctx(op->ctx());
-
ldpp_dout(dpp, 5) << "SKIP: bucket removal is not allowed on archive zone: bucket:" << entry << " ... proceeding to rename" << dendl;
string tenant_name, bucket_name;
RGWBucketEntryPoint be;
map<string, bufferlist> attrs;
- int ret = svc.bucket->read_bucket_entrypoint_info(ctx, entry, &be, &objv_tracker, &mtime, &attrs, y, dpp);
+ int ret = svc.bucket->read_bucket_entrypoint_info(entry, &be, &objv_tracker, &mtime, &attrs, y, dpp);
if (ret < 0) {
return ret;
}
RGWObjVersionTracker ot;
ot.generate_new_write_ver(cct);
- ret = svc.bucket->store_bucket_entrypoint_info(ctx, RGWSI_Bucket::get_entrypoint_meta_key(new_be.bucket),
+ ret = svc.bucket->store_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(new_be.bucket),
new_be, true, mtime, &attrs, nullptr, y, dpp);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to put new bucket entrypoint for bucket=" << new_be.bucket << " ret=" << ret << dendl;
// whether it was a newly created bucket entrypoint ... in which case we
// should ignore the error and move forward, or whether it is a higher version
// of the same bucket instance ... in which we should retry
- ret = svc.bucket->remove_bucket_entrypoint_info(ctx,
- RGWSI_Bucket::get_entrypoint_meta_key(be.bucket),
+ ret = svc.bucket->remove_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(be.bucket),
&objv_tracker,
y,
dpp);
};
class RGWBucketInstanceMetadataHandler : public RGWBucketInstanceMetadataHandlerBase {
- int read_bucket_instance_entry(RGWSI_Bucket_BI_Ctx& ctx,
- const string& entry,
- RGWBucketCompleteInfo *bi,
- ceph::real_time *pmtime,
- optional_yield y,
- const DoutPrefixProvider *dpp) {
- return svc.bucket->read_bucket_instance_info(ctx,
- entry,
- &bi->info,
- pmtime, &bi->attrs,
- y,
- dpp);
- }
-
public:
struct Svc {
RGWSI_Zone *zone{nullptr};
RGWBucketCompleteInfo bci;
real_time mtime;
- RGWSI_Bucket_BI_Ctx ctx(op->ctx());
-
- int ret = svc.bucket->read_bucket_instance_info(ctx, entry, &bci.info, &mtime, &bci.attrs, y, dpp);
+ int ret = svc.bucket->read_bucket_instance_info(entry, &bci.info, &mtime, &bci.attrs, y, dpp);
if (ret < 0)
return ret;
optional_yield y, const DoutPrefixProvider *dpp) override {
RGWBucketCompleteInfo bci;
- RGWSI_Bucket_BI_Ctx ctx(op->ctx());
-
- int ret = read_bucket_instance_entry(ctx, entry, &bci, nullptr, y, dpp);
+ int ret = svc.bucket->read_bucket_instance_info(entry, &bci.info, nullptr,
+ &bci.attrs, y, dpp);
if (ret < 0 && ret != -ENOENT)
return ret;
ret = svc.bucket->remove_bucket_instance_info(
- ctx, entry, bci.info, &bci.info.objv_tracker, y, dpp);
+ entry, bci.info, &bci.info.objv_tracker, y, dpp);
if (ret < 0)
return ret;
ret = update_bucket_topic_mappings(dpp, &bci, /*current_bci=*/nullptr,
// update_bucket_topic_mapping error is swallowed.
return 0;
}
-
- int call(std::function<int(RGWSI_Bucket_BI_Ctx& ctx)> f) {
- return call(nullopt, f);
- }
-
- int call(std::optional<RGWSI_MetaBackend_CtxParams> bectx_params,
- std::function<int(RGWSI_Bucket_BI_Ctx& ctx)> f) {
- return be_handler->call(bectx_params, [&](RGWSI_MetaBackend_Handler::Op *op) {
- RGWSI_Bucket_BI_Ctx ctx(op->ctx());
- return f(ctx);
- });
- }
};
class RGWMetadataHandlerPut_BucketInstance : public RGWMetadataHandlerPut_SObj
auto mtime = obj->get_mtime();
auto pattrs = obj->get_pattrs();
- RGWSI_Bucket_BI_Ctx ctx(op->ctx());
-
- return bihandler->svc.bucket->store_bucket_instance_info(ctx,
- entry,
+ return bihandler->svc.bucket->store_bucket_instance_info(entry,
info,
orig_info,
false,
});
}
-int RGWBucketCtl::call(std::function<int(RGWSI_Bucket_X_Ctx& ctx)> f) {
- return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ep_ctx) {
- return bmi_handler->call([&](RGWSI_Bucket_BI_Ctx& bi_ctx) {
- RGWSI_Bucket_X_Ctx ctx{ep_ctx, bi_ctx};
- return f(ctx);
- });
- });
-}
-
int RGWBucketCtl::read_bucket_entrypoint_info(const rgw_bucket& bucket,
RGWBucketEntryPoint *info,
optional_yield y, const DoutPrefixProvider *dpp,
const Bucket::GetParams& params)
{
- return bm_handler->call(params.bectx_params, [&](RGWSI_Bucket_EP_Ctx& ctx) {
- return svc.bucket->read_bucket_entrypoint_info(ctx,
- RGWSI_Bucket::get_entrypoint_meta_key(bucket),
- info,
- params.objv_tracker,
- params.mtime,
- params.attrs,
- y,
- dpp,
- params.cache_info,
- params.refresh_version);
- });
+ return svc.bucket->read_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(bucket),
+ info,
+ params.objv_tracker,
+ params.mtime,
+ params.attrs,
+ y,
+ dpp,
+ params.cache_info,
+ params.refresh_version);
}
int RGWBucketCtl::store_bucket_entrypoint_info(const rgw_bucket& bucket,
const DoutPrefixProvider *dpp,
const Bucket::PutParams& params)
{
- return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) {
- return svc.bucket->store_bucket_entrypoint_info(ctx,
- RGWSI_Bucket::get_entrypoint_meta_key(bucket),
- info,
- params.exclusive,
- params.mtime,
- params.attrs,
- params.objv_tracker,
- y,
- dpp);
- });
+ return svc.bucket->store_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(bucket),
+ info,
+ params.exclusive,
+ params.mtime,
+ params.attrs,
+ params.objv_tracker,
+ y,
+ dpp);
}
int RGWBucketCtl::remove_bucket_entrypoint_info(const rgw_bucket& bucket,
const DoutPrefixProvider *dpp,
const Bucket::RemoveParams& params)
{
- 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,
- y,
- dpp);
- });
+ return svc.bucket->remove_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(bucket),
+ params.objv_tracker,
+ y,
+ dpp);
}
int RGWBucketCtl::read_bucket_instance_info(const rgw_bucket& bucket,
const DoutPrefixProvider *dpp,
const BucketInstance::GetParams& params)
{
- int ret = bmi_handler->call(params.bectx_params, [&](RGWSI_Bucket_BI_Ctx& ctx) {
- return svc.bucket->read_bucket_instance_info(ctx,
- RGWSI_Bucket::get_bi_meta_key(bucket),
- info,
- params.mtime,
- params.attrs,
- y,
- dpp,
- params.cache_info,
- params.refresh_version);
- });
-
+ int ret = svc.bucket->read_bucket_instance_info(RGWSI_Bucket::get_bi_meta_key(bucket),
+ info,
+ params.mtime,
+ params.attrs,
+ y,
+ dpp,
+ params.cache_info,
+ params.refresh_version);
if (ret < 0) {
return ret;
}
b = &ep->bucket;
}
- int ret = bmi_handler->call(params.bectx_params, [&](RGWSI_Bucket_BI_Ctx& ctx) {
- return svc.bucket->read_bucket_instance_info(ctx,
- RGWSI_Bucket::get_bi_meta_key(*b),
- info,
- params.mtime,
- params.attrs,
- y, dpp,
- params.cache_info,
- params.refresh_version);
- });
-
+ int ret = svc.bucket->read_bucket_instance_info(RGWSI_Bucket::get_bi_meta_key(*b),
+ info,
+ params.mtime,
+ params.attrs,
+ y, dpp,
+ params.cache_info,
+ params.refresh_version);
if (ret < 0) {
return ret;
}
return 0;
}
-int RGWBucketCtl::do_store_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const rgw_bucket& bucket,
- RGWBucketInfo& info,
- optional_yield y,
- const DoutPrefixProvider *dpp,
- const BucketInstance::PutParams& params)
+int RGWBucketCtl::store_bucket_instance_info(const rgw_bucket& bucket,
+ RGWBucketInfo& info,
+ optional_yield y,
+ const DoutPrefixProvider *dpp,
+ const BucketInstance::PutParams& params)
{
if (params.objv_tracker) {
info.objv_tracker = *params.objv_tracker;
}
- return svc.bucket->store_bucket_instance_info(ctx,
- RGWSI_Bucket::get_bi_meta_key(bucket),
+ return svc.bucket->store_bucket_instance_info(RGWSI_Bucket::get_bi_meta_key(bucket),
info,
params.orig_info,
params.exclusive,
dpp);
}
-int RGWBucketCtl::store_bucket_instance_info(const rgw_bucket& bucket,
- RGWBucketInfo& info,
- optional_yield y,
- const DoutPrefixProvider *dpp,
- const BucketInstance::PutParams& params)
-{
- return bmi_handler->call([&](RGWSI_Bucket_BI_Ctx& ctx) {
- return do_store_bucket_instance_info(ctx, bucket, info, y, dpp, params);
- });
-}
-
int RGWBucketCtl::remove_bucket_instance_info(const rgw_bucket& bucket,
RGWBucketInfo& info,
optional_yield y,
info.objv_tracker = *params.objv_tracker;
}
- return bmi_handler->call([&](RGWSI_Bucket_BI_Ctx& ctx) {
- return svc.bucket->remove_bucket_instance_info(ctx,
- RGWSI_Bucket::get_bi_meta_key(bucket),
- info,
- &info.objv_tracker,
- y,
- dpp);
- });
+ return svc.bucket->remove_bucket_instance_info(RGWSI_Bucket::get_bi_meta_key(bucket),
+ info,
+ &info.objv_tracker,
+ y,
+ dpp);
}
-int RGWBucketCtl::do_store_linked_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
- RGWBucketInfo& info,
+int RGWBucketCtl::do_store_linked_bucket_info(RGWBucketInfo& info,
RGWBucketInfo *orig_info,
bool exclusive, real_time mtime,
obj_version *pep_objv,
{
bool create_head = !info.has_instance_obj || create_entry_point;
- int ret = svc.bucket->store_bucket_instance_info(ctx.bi,
- RGWSI_Bucket::get_bi_meta_key(info.bucket),
+ int ret = svc.bucket->store_bucket_instance_info(RGWSI_Bucket::get_bi_meta_key(info.bucket),
info,
orig_info,
exclusive,
*pep_objv = ot.write_version;
}
}
- ret = svc.bucket->store_bucket_entrypoint_info(ctx.ep,
- RGWSI_Bucket::get_entrypoint_meta_key(info.bucket),
- entry_point,
- exclusive,
- mtime,
- pattrs,
- &ot,
- y,
- dpp);
- if (ret < 0)
- return ret;
-
- return 0;
+ return svc.bucket->store_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(info.bucket),
+ entry_point,
+ exclusive,
+ mtime,
+ pattrs,
+ &ot,
+ y,
+ dpp);
}
-int RGWBucketCtl::convert_old_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
- const rgw_bucket& bucket,
+
+int RGWBucketCtl::convert_old_bucket_info(const rgw_bucket& bucket,
optional_yield y,
const DoutPrefixProvider *dpp)
{
ldpp_dout(dpp, 10) << "RGWRados::convert_old_bucket_info(): bucket=" << bucket << dendl;
- int ret = svc.bucket->read_bucket_entrypoint_info(ctx.ep,
- RGWSI_Bucket::get_entrypoint_meta_key(bucket),
+ int ret = svc.bucket->read_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(bucket),
&entry_point, &ot, &ep_mtime, &attrs, y, dpp);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: get_bucket_entrypoint_info() returned " << ret << " bucket=" << bucket << dendl;
ot.generate_new_write_ver(cct);
- ret = do_store_linked_bucket_info(ctx, info, nullptr, false, ep_mtime, &ot.write_version, &attrs, true, y, dpp);
+ ret = do_store_linked_bucket_info(info, nullptr, false, ep_mtime, &ot.write_version, &attrs, true, y, dpp);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to put_linked_bucket_info(): " << ret << dendl;
return ret;
optional_yield y,
const DoutPrefixProvider *dpp)
{
- return call([&](RGWSI_Bucket_X_Ctx& ctx) {
- rgw_bucket& bucket = bucket_info.bucket;
-
- if (!bucket_info.has_instance_obj) {
- /* an old bucket object, need to convert it */
- int ret = convert_old_bucket_info(ctx, bucket, y, dpp);
- if (ret < 0) {
- ldpp_dout(dpp, 0) << "ERROR: failed converting old bucket info: " << ret << dendl;
- return ret;
- }
- }
-
- return do_store_bucket_instance_info(ctx.bi,
- bucket,
- bucket_info,
- y,
- dpp,
- BucketInstance::PutParams().set_attrs(&attrs)
- .set_objv_tracker(objv_tracker)
- .set_orig_info(&bucket_info));
- });
-}
+ rgw_bucket& bucket = bucket_info.bucket;
+ if (!bucket_info.has_instance_obj) {
+ /* an old bucket object, need to convert it */
+ int ret = convert_old_bucket_info(bucket, y, dpp);
+ if (ret < 0) {
+ ldpp_dout(dpp, 0) << "ERROR: failed converting old bucket info: " << ret << dendl;
+ return ret;
+ }
+ }
-int RGWBucketCtl::link_bucket(librados::Rados& rados,
- const rgw_owner& owner,
- const rgw_bucket& bucket,
- ceph::real_time creation_time,
- optional_yield y,
- const DoutPrefixProvider *dpp,
- bool update_entrypoint,
- rgw_ep_info *pinfo)
-{
- return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) {
- return do_link_bucket(ctx, rados, owner, bucket, creation_time,
- update_entrypoint, pinfo, y, dpp);
- });
+ return store_bucket_instance_info(bucket,
+ bucket_info,
+ y,
+ dpp,
+ BucketInstance::PutParams().set_attrs(&attrs)
+ .set_objv_tracker(objv_tracker)
+ .set_orig_info(&bucket_info));
}
static rgw_raw_obj get_owner_buckets_obj(RGWSI_User* svc_user,
}), owner);
}
-int RGWBucketCtl::do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx,
- librados::Rados& rados,
- const rgw_owner& owner,
- const rgw_bucket& bucket,
- ceph::real_time creation_time,
- bool update_entrypoint,
- rgw_ep_info *pinfo,
- optional_yield y,
- const DoutPrefixProvider *dpp)
+int RGWBucketCtl::link_bucket(librados::Rados& rados,
+ const rgw_owner& owner,
+ const rgw_bucket& bucket,
+ ceph::real_time creation_time,
+ optional_yield y,
+ const DoutPrefixProvider *dpp,
+ bool update_entrypoint,
+ rgw_ep_info *pinfo)
{
int ret;
ep = pinfo->ep;
pattrs = &pinfo->attrs;
} else {
- ret = svc.bucket->read_bucket_entrypoint_info(ctx,
- meta_key,
+ ret = svc.bucket->read_bucket_entrypoint_info(meta_key,
&ep, &rot,
nullptr, &attrs,
y, dpp);
ep.owner = owner;
ep.bucket = bucket;
ret = svc.bucket->store_bucket_entrypoint_info(
- ctx, meta_key, ep, false, real_time(), pattrs, &rot, y, dpp);
+ meta_key, ep, false, real_time(), pattrs, &rot, y, dpp);
if (ret < 0)
goto done_err;
return 0;
done_err:
- int r = do_unlink_bucket(ctx, rados, owner, bucket, true, y, dpp);
+ int r = unlink_bucket(rados, owner, bucket, y, dpp, true);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed unlinking bucket on error cleanup: "
<< cpp_strerror(-r) << dendl;
int RGWBucketCtl::unlink_bucket(librados::Rados& rados, const rgw_owner& owner,
const rgw_bucket& bucket, optional_yield y,
const DoutPrefixProvider *dpp, bool update_entrypoint)
-{
- return bm_handler->call([&](RGWSI_Bucket_EP_Ctx& ctx) {
- return do_unlink_bucket(ctx, rados, owner, bucket, update_entrypoint, y, dpp);
- });
-}
-
-int RGWBucketCtl::do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx,
- librados::Rados& rados,
- const rgw_owner& owner,
- const rgw_bucket& bucket,
- bool update_entrypoint,
- optional_yield y,
- const DoutPrefixProvider *dpp)
{
const auto& buckets_obj = get_owner_buckets_obj(svc.user, svc.zone, owner);
int ret = rgwrados::buckets::remove(dpp, y, rados, buckets_obj, 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, y, dpp);
+ ret = svc.bucket->read_bucket_entrypoint_info(meta_key, &ep, &ot, nullptr, &attrs, y, dpp);
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, y, dpp);
+ return svc.bucket->store_bucket_entrypoint_info(meta_key, ep, false, real_time(), &attrs, &ot, y, dpp);
}
int RGWBucketCtl::read_bucket_stats(const rgw_bucket& bucket,
optional_yield y,
const DoutPrefixProvider *dpp)
{
- return call([&](RGWSI_Bucket_X_Ctx& ctx) {
- return svc.bucket->read_bucket_stats(ctx, bucket, result, y, dpp);
- });
+ return svc.bucket->read_bucket_stats(bucket, result, y, dpp);
}
int RGWBucketCtl::read_buckets_stats(std::vector<RGWBucketEnt>& buckets,
optional_yield y, const DoutPrefixProvider *dpp)
{
- return call([&](RGWSI_Bucket_X_Ctx& ctx) {
- return svc.bucket->read_buckets_stats(ctx, buckets, y, dpp);
- });
+ return svc.bucket->read_buckets_stats(buckets, y, dpp);
}
int RGWBucketCtl::sync_owner_stats(const DoutPrefixProvider *dpp,
optional_yield y,
const DoutPrefixProvider *dpp)
{
- int r = call([&](RGWSI_Bucket_X_Ctx& ctx) {
- return svc.bucket_sync->get_policy_handler(ctx, zone, bucket, phandler, y, dpp);
- });
+ int r = svc.bucket_sync->get_policy_handler(zone, bucket, phandler, y, dpp);
if (r < 0) {
ldpp_dout(dpp, 20) << __func__ << "(): failed to get policy handler for bucket=" << bucket << " (r=" << r << ")" << dendl;
return r;
RGWSI_Bucket_BE_Handler bucket_be_handler; /* bucket backend handler */
RGWSI_BucketInstance_BE_Handler bi_be_handler; /* bucket instance backend handler */
- int call(std::function<int(RGWSI_Bucket_X_Ctx& ctx)> f);
-
public:
RGWBucketCtl(RGWSI_Zone *zone_svc,
RGWSI_Bucket *bucket_svc,
const DoutPrefixProvider *dpp);
private:
- int convert_old_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
- const rgw_bucket& bucket,
+ int convert_old_bucket_info(const rgw_bucket& bucket,
optional_yield y,
const DoutPrefixProvider *dpp);
- int do_store_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const rgw_bucket& bucket,
- RGWBucketInfo& info,
- optional_yield y,
- const DoutPrefixProvider *dpp,
- const BucketInstance::PutParams& params);
-
- int do_store_linked_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
- RGWBucketInfo& info,
+ int do_store_linked_bucket_info(RGWBucketInfo& info,
RGWBucketInfo *orig_info,
bool exclusive, real_time mtime,
obj_version *pep_objv,
bool create_entry_point,
optional_yield,
const DoutPrefixProvider *dpp);
-
- int do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx,
- librados::Rados& rados,
- const rgw_owner& owner,
- const rgw_bucket& bucket,
- ceph::real_time creation_time,
- bool update_entrypoint,
- rgw_ep_info *pinfo,
- optional_yield y,
- const DoutPrefixProvider *dpp);
-
- int do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx,
- librados::Rados& rados,
- const rgw_owner& owner,
- const rgw_bucket& bucket,
- bool update_entrypoint,
- optional_yield y,
- const DoutPrefixProvider *dpp);
-
};
bool rgw_find_bucket_by_id(const DoutPrefixProvider *dpp, CephContext *cct, rgw::sal::Driver* driver, const std::string& marker,
virtual RGWSI_Bucket_BE_Handler& get_ep_be_handler() = 0;
virtual RGWSI_BucketInstance_BE_Handler& get_bi_be_handler() = 0;
- virtual int read_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const std::string& key,
+ virtual int read_bucket_entrypoint_info(const std::string& key,
RGWBucketEntryPoint *entry_point,
RGWObjVersionTracker *objv_tracker,
real_time *pmtime,
rgw_cache_entry_info *cache_info = nullptr,
boost::optional<obj_version> refresh_version = boost::none) = 0;
- virtual int store_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const std::string& key,
+ virtual int store_bucket_entrypoint_info(const std::string& key,
RGWBucketEntryPoint& info,
bool exclusive,
real_time mtime,
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
- virtual int remove_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const std::string& key,
+ virtual int remove_bucket_entrypoint_info(const std::string& key,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
- virtual int read_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ virtual int read_bucket_instance_info(const std::string& key,
RGWBucketInfo *info,
real_time *pmtime,
std::map<std::string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info = nullptr,
boost::optional<obj_version> refresh_version = boost::none) = 0;
- virtual int read_bucket_info(RGWSI_Bucket_X_Ctx& ep_ctx,
- const rgw_bucket& bucket,
+ virtual int read_bucket_info(const rgw_bucket& bucket,
RGWBucketInfo *info,
real_time *pmtime,
std::map<std::string, bufferlist> *pattrs,
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
- virtual int store_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ virtual int store_bucket_instance_info(const std::string& key,
RGWBucketInfo& info,
std::optional<RGWBucketInfo *> orig_info, /* nullopt: orig_info was not fetched,
nullptr: orig_info was not found (new bucket instance */
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
- virtual int remove_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ virtual int remove_bucket_instance_info(const std::string& key,
const RGWBucketInfo& bucket_info,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
- virtual int read_bucket_stats(RGWSI_Bucket_X_Ctx& ctx,
- const rgw_bucket& bucket,
+ virtual int read_bucket_stats(const rgw_bucket& bucket,
RGWBucketEnt *ent,
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
- virtual int read_buckets_stats(RGWSI_Bucket_X_Ctx& ctx,
- std::vector<RGWBucketEnt>& buckets,
+ virtual int read_buckets_stats(std::vector<RGWBucketEnt>& buckets,
optional_yield y,
const DoutPrefixProvider *dpp) = 0;
};
return 0;
}
-int RGWSI_Bucket_SObj::read_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::read_bucket_entrypoint_info(const string& key,
RGWBucketEntryPoint *entry_point,
RGWObjVersionTracker *objv_tracker,
real_time *pmtime,
return 0;
}
-int RGWSI_Bucket_SObj::store_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::store_bucket_entrypoint_info(const string& key,
RGWBucketEntryPoint& info,
bool exclusive,
real_time mtime,
objv_tracker, mtime, y, pattrs);
}
-int RGWSI_Bucket_SObj::remove_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::remove_bucket_entrypoint_info(const string& key,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp)
return rgw_delete_system_obj(dpp, svc.sysobj, pool, key, objv_tracker, y);
}
-int RGWSI_Bucket_SObj::read_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::read_bucket_instance_info(const string& key,
RGWBucketInfo *info,
real_time *pmtime, map<string, bufferlist> *pattrs,
optional_yield y,
bucket_info_cache_entry e;
rgw_cache_entry_info ci;
- int ret = do_read_bucket_instance_info(ctx, key,
- &e.info, &e.mtime, &e.attrs,
- &ci, refresh_version, y, dpp);
+ int ret = do_read_bucket_instance_info(key, &e.info, &e.mtime, &e.attrs,
+ &ci, refresh_version, y, dpp);
*info = e.info;
if (ret < 0) {
return 0;
}
-int RGWSI_Bucket_SObj::do_read_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::do_read_bucket_instance_info(const string& key,
RGWBucketInfo *info,
real_time *pmtime, map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info,
return 0;
}
-int RGWSI_Bucket_SObj::read_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
- const rgw_bucket& bucket,
+int RGWSI_Bucket_SObj::read_bucket_info(const rgw_bucket& bucket,
RGWBucketInfo *info,
real_time *pmtime,
map<string, bufferlist> *pattrs,
rgw_cache_entry_info cache_info;
if (!bucket.bucket_id.empty()) {
- return read_bucket_instance_info(ctx.bi, get_bi_meta_key(bucket),
- info,
- pmtime, pattrs,
- y,
- dpp,
+ return read_bucket_instance_info(get_bi_meta_key(bucket), info,
+ pmtime, pattrs, y, dpp,
&cache_info, refresh_version);
}
real_time ep_mtime;
RGWObjVersionTracker ot;
rgw_cache_entry_info entry_cache_info;
- int ret = read_bucket_entrypoint_info(ctx.ep, bucket_entry,
- &entry_point, &ot, &ep_mtime, pattrs,
- y,
- dpp,
+ int ret = read_bucket_entrypoint_info(bucket_entry, &entry_point, &ot,
+ &ep_mtime, pattrs, y, dpp,
&entry_cache_info, refresh_version);
if (ret < 0) {
/* only init these fields */
bucket_info_cache_entry e;
- ret = read_bucket_instance_info(ctx.bi, get_bi_meta_key(entry_point.bucket),
- &e.info, &e.mtime, &e.attrs,
- y,
- dpp,
+ ret = read_bucket_instance_info(get_bi_meta_key(entry_point.bucket),
+ &e.info, &e.mtime, &e.attrs, y, dpp,
&cache_info, refresh_version);
*info = e.info;
if (ret < 0) {
}
-int RGWSI_Bucket_SObj::store_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::store_bucket_instance_info(const string& key,
RGWBucketInfo& info,
std::optional<RGWBucketInfo *> orig_info,
bool exclusive,
* we're here because orig_info wasn't passed in
* we don't have info about what was there before, so need to fetch first
*/
- int r = read_bucket_instance_info(ctx,
- key,
- &shared_bucket_info,
- nullptr, nullptr,
- y,
- dpp,
+ int r = read_bucket_instance_info(key, &shared_bucket_info,
+ nullptr, nullptr, y, dpp,
nullptr, boost::none);
if (r < 0) {
if (r != -ENOENT) {
return ret;
}
-int RGWSI_Bucket_SObj::remove_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const string& key,
+int RGWSI_Bucket_SObj::remove_bucket_instance_info(const string& key,
const RGWBucketInfo& info,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
return 0;
}
-int RGWSI_Bucket_SObj::read_bucket_stats(RGWSI_Bucket_X_Ctx& ctx,
- const rgw_bucket& bucket,
+int RGWSI_Bucket_SObj::read_bucket_stats(const rgw_bucket& bucket,
RGWBucketEnt *ent,
optional_yield y,
const DoutPrefixProvider *dpp)
{
RGWBucketInfo bucket_info;
- int ret = read_bucket_info(ctx, bucket, &bucket_info, nullptr, nullptr, boost::none, y, dpp);
+ int ret = read_bucket_info(bucket, &bucket_info, nullptr, nullptr, boost::none, y, dpp);
if (ret < 0) {
return ret;
}
return read_bucket_stats(bucket_info, ent, y, dpp);
}
-int RGWSI_Bucket_SObj::read_buckets_stats(RGWSI_Bucket_X_Ctx& ctx,
- std::vector<RGWBucketEnt>& buckets,
+int RGWSI_Bucket_SObj::read_buckets_stats(std::vector<RGWBucketEnt>& buckets,
optional_yield y,
const DoutPrefixProvider *dpp)
{
for (auto& ent : buckets) {
- int r = read_bucket_stats(ctx, ent.bucket, &ent, y, dpp);
+ int r = read_bucket_stats(ent.bucket, &ent, y, dpp);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: " << __func__ << "(): read_bucket_stats returned r=" << r << dendl;
return r;
int do_start(optional_yield, const DoutPrefixProvider *dpp) override;
- int do_read_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ int do_read_bucket_instance_info(const std::string& key,
RGWBucketInfo *info,
real_time *pmtime,
std::map<std::string, bufferlist> *pattrs,
RGWSI_Bucket_Sync *_bucket_sync_svc);
- int read_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const std::string& key,
+ int read_bucket_entrypoint_info(const std::string& key,
RGWBucketEntryPoint *entry_point,
RGWObjVersionTracker *objv_tracker,
real_time *pmtime,
rgw_cache_entry_info *cache_info = nullptr,
boost::optional<obj_version> refresh_version = boost::none) override;
- int store_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const std::string& key,
+ int store_bucket_entrypoint_info(const std::string& key,
RGWBucketEntryPoint& info,
bool exclusive,
real_time mtime,
optional_yield y,
const DoutPrefixProvider *dpp) override;
- int remove_bucket_entrypoint_info(RGWSI_Bucket_EP_Ctx& ctx,
- const std::string& key,
+ int remove_bucket_entrypoint_info(const std::string& key,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp) override;
- int read_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ int read_bucket_instance_info(const std::string& key,
RGWBucketInfo *info,
real_time *pmtime,
std::map<std::string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info = nullptr,
boost::optional<obj_version> refresh_version = boost::none) override;
- int read_bucket_info(RGWSI_Bucket_X_Ctx& ep_ctx,
- const rgw_bucket& bucket,
+ int read_bucket_info(const rgw_bucket& bucket,
RGWBucketInfo *info,
real_time *pmtime,
std::map<std::string, bufferlist> *pattrs,
optional_yield y,
const DoutPrefixProvider *dpp) override;
- int store_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ int store_bucket_instance_info(const std::string& key,
RGWBucketInfo& info,
std::optional<RGWBucketInfo *> orig_info, /* nullopt: orig_info was not fetched,
nullptr: orig_info was not found (new bucket instance */
optional_yield y,
const DoutPrefixProvider *dpp) override;
- int remove_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
- const std::string& key,
+ int remove_bucket_instance_info(const std::string& key,
const RGWBucketInfo& bucket_info,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
const DoutPrefixProvider *dpp) override;
- int read_bucket_stats(RGWSI_Bucket_X_Ctx& ctx,
- const rgw_bucket& bucket,
+ int read_bucket_stats(const rgw_bucket& bucket,
RGWBucketEnt *ent,
optional_yield y,
const DoutPrefixProvider *dpp) override;
- int read_buckets_stats(RGWSI_Bucket_X_Ctx& ctx,
- std::vector<RGWBucketEnt>& buckets,
+ int read_buckets_stats(std::vector<RGWBucketEnt>& buckets,
optional_yield y,
const DoutPrefixProvider *dpp) override;
};
public:
RGWSI_Bucket_Sync(CephContext *cct) : RGWServiceInstance(cct) {}
- virtual int get_policy_handler(RGWSI_Bucket_X_Ctx& ctx,
- std::optional<rgw_zone_id> zone,
+ virtual int get_policy_handler(std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *handler,
optional_yield y,
return 0;
}
-void RGWSI_Bucket_Sync_SObj::get_hint_entities(RGWSI_Bucket_X_Ctx& ctx,
- const std::set<rgw_zone_id>& zones,
+void RGWSI_Bucket_Sync_SObj::get_hint_entities(const std::set<rgw_zone_id>& zones,
const std::set<rgw_bucket>& buckets,
std::set<rgw_sync_bucket_entity> *hint_entities,
optional_yield y, const DoutPrefixProvider *dpp)
for (auto& b : buckets) {
RGWBucketInfo hint_bucket_info;
- int ret = svc.bucket_sobj->read_bucket_info(ctx, b, &hint_bucket_info,
+ int ret = svc.bucket_sobj->read_bucket_info(b, &hint_bucket_info,
nullptr, nullptr, boost::none,
y, dpp);
if (ret < 0) {
}
}
-int RGWSI_Bucket_Sync_SObj::resolve_policy_hints(RGWSI_Bucket_X_Ctx& ctx,
- rgw_sync_bucket_entity& self_entity,
+int RGWSI_Bucket_Sync_SObj::resolve_policy_hints(rgw_sync_bucket_entity& self_entity,
RGWBucketSyncPolicyHandlerRef& handler,
RGWBucketSyncPolicyHandlerRef& zone_policy_handler,
std::map<optional_zone_bucket, RGWBucketSyncPolicyHandlerRef>& temp_map,
std::set<rgw_sync_bucket_entity> hint_entities;
- get_hint_entities(ctx, source_zones, handler->get_source_hints(), &hint_entities, y, dpp);
- get_hint_entities(ctx, target_zones, handler->get_target_hints(), &hint_entities, y, dpp);
+ get_hint_entities(source_zones, handler->get_source_hints(), &hint_entities, y, dpp);
+ get_hint_entities(target_zones, handler->get_target_hints(), &hint_entities, y, dpp);
std::set<rgw_sync_bucket_pipe> resolved_sources;
std::set<rgw_sync_bucket_pipe> resolved_dests;
if (iter != temp_map.end()) {
hint_bucket_handler = iter->second;
} else {
- int r = do_get_policy_handler(ctx, zid, hint_bucket, temp_map, &hint_bucket_handler, y, dpp);
+ int r = do_get_policy_handler(zid, hint_bucket, temp_map, &hint_bucket_handler, y, dpp);
if (r < 0) {
ldpp_dout(dpp, 20) << "could not get bucket sync policy handler for hint bucket=" << hint_bucket << " ... skipping" << dendl;
continue;
return 0;
}
-int RGWSI_Bucket_Sync_SObj::do_get_policy_handler(RGWSI_Bucket_X_Ctx& ctx,
- std::optional<rgw_zone_id> zone,
+int RGWSI_Bucket_Sync_SObj::do_get_policy_handler(std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> _bucket,
std::map<optional_zone_bucket, RGWBucketSyncPolicyHandlerRef>& temp_map,
RGWBucketSyncPolicyHandlerRef *handler,
if (bucket.bucket_id.empty()) {
RGWBucketEntryPoint ep_info;
- int ret = svc.bucket_sobj->read_bucket_entrypoint_info(ctx.ep,
- RGWSI_Bucket::get_entrypoint_meta_key(bucket),
+ int ret = svc.bucket_sobj->read_bucket_entrypoint_info(RGWSI_Bucket::get_entrypoint_meta_key(bucket),
&ep_info,
nullptr, /* objv_tracker */
nullptr, /* mtime */
RGWBucketInfo bucket_info;
map<string, bufferlist> attrs;
- int r = svc.bucket_sobj->read_bucket_instance_info(ctx.bi,
- bucket_key,
+ int r = svc.bucket_sobj->read_bucket_instance_info(bucket_key,
&bucket_info,
nullptr,
&attrs,
rgw_sync_bucket_entity self_entity(zone.value_or(svc.zone->zone_id()), bucket);
- r = resolve_policy_hints(ctx, self_entity,
+ r = resolve_policy_hints(self_entity,
e.handler,
zone_policy_handler,
temp_map, y, dpp);
return 0;
}
-int RGWSI_Bucket_Sync_SObj::get_policy_handler(RGWSI_Bucket_X_Ctx& ctx,
- std::optional<rgw_zone_id> zone,
+int RGWSI_Bucket_Sync_SObj::get_policy_handler(std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> _bucket,
RGWBucketSyncPolicyHandlerRef *handler,
optional_yield y,
const DoutPrefixProvider *dpp)
{
std::map<optional_zone_bucket, RGWBucketSyncPolicyHandlerRef> temp_map;
- return do_get_policy_handler(ctx, zone, _bucket, temp_map, handler, y, dpp);
+ return do_get_policy_handler(zone, _bucket, temp_map, handler, y, dpp);
}
static bool diff_sets(std::set<rgw_bucket>& orig_set,
}
};
- void get_hint_entities(RGWSI_Bucket_X_Ctx& ctx,
- const std::set<rgw_zone_id>& zone_names,
+ void get_hint_entities(const std::set<rgw_zone_id>& zone_names,
const std::set<rgw_bucket>& buckets,
std::set<rgw_sync_bucket_entity> *hint_entities,
optional_yield y, const DoutPrefixProvider *);
- int resolve_policy_hints(RGWSI_Bucket_X_Ctx& ctx,
- rgw_sync_bucket_entity& self_entity,
+ int resolve_policy_hints(rgw_sync_bucket_entity& self_entity,
RGWBucketSyncPolicyHandlerRef& handler,
RGWBucketSyncPolicyHandlerRef& zone_policy_handler,
std::map<optional_zone_bucket, RGWBucketSyncPolicyHandlerRef>& temp_map,
optional_yield y,
const DoutPrefixProvider *dpp);
- int do_get_policy_handler(RGWSI_Bucket_X_Ctx& ctx,
- std::optional<rgw_zone_id> zone,
+ int do_get_policy_handler(std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> _bucket,
std::map<optional_zone_bucket, RGWBucketSyncPolicyHandlerRef>& temp_map,
RGWBucketSyncPolicyHandlerRef *handler,
RGWSI_Bucket_SObj *_bucket_sobj_svc);
- int get_policy_handler(RGWSI_Bucket_X_Ctx& ctx,
- std::optional<rgw_zone_id> zone,
+ int get_policy_handler(std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *handler,
optional_yield y,
projects / ceph.git / commitdiff