#include "account.h"
#include "buckets.h"
+#include "rgw_metadata_lister.h"
#include "rgw_reshard.h"
#include "rgw_pubsub.h"
JSONDecoder::decode_json("attrs", attrs, obj);
}
-class RGWBucketMetadataHandler : public RGWBucketMetadataHandlerBase {
-public:
+class RGWBucketMetadataHandler : public RGWMetadataHandler {
+ protected:
librados::Rados& rados;
- struct Svc {
- RGWSI_Bucket *bucket{nullptr};
- } svc;
+ RGWSI_Bucket* svc_bucket{nullptr};
+ RGWBucketCtl *ctl_bucket{nullptr};
- struct Ctl {
- RGWBucketCtl *bucket{nullptr};
- } ctl;
-
- explicit RGWBucketMetadataHandler(librados::Rados& rados)
- : rados(rados) {}
-
- void init(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl) override {
- base_init(bucket_svc->ctx(),
- bucket_svc->get_ep_be_handler().get());
- svc.bucket = bucket_svc;
- ctl.bucket = bucket_ctl;
- }
+ public:
+ RGWBucketMetadataHandler(librados::Rados& rados,
+ RGWSI_Bucket* svc_bucket,
+ RGWBucketCtl* ctl_bucket)
+ : rados(rados), svc_bucket(svc_bucket), ctl_bucket(ctl_bucket) {}
string get_type() override { return "bucket"; }
return new RGWBucketEntryMetadataObject(be, objv, mtime);
}
- int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj, optional_yield y, const DoutPrefixProvider *dpp) override {
- RGWObjVersionTracker ot;
- RGWBucketEntryPoint be;
-
- real_time mtime;
- map<string, bufferlist> attrs;
-
- int ret = svc.bucket->read_bucket_entrypoint_info(entry, &be, &ot, &mtime, &attrs, y, dpp);
- if (ret < 0)
- return ret;
-
- RGWBucketEntryMetadataObject *mdo = new RGWBucketEntryMetadataObject(be, ot.read_version, mtime, std::move(attrs));
-
- *obj = mdo;
-
- return 0;
- }
-
- int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
- RGWMetadataObject *obj,
- RGWObjVersionTracker& objv_tracker,
- optional_yield y,
- const DoutPrefixProvider *dpp,
- RGWMDLogSyncType type, bool from_remote_zone) override;
-
- int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
- optional_yield y, const DoutPrefixProvider *dpp) override {
- RGWBucketEntryPoint be;
-
- real_time orig_mtime;
-
- int ret = svc.bucket->read_bucket_entrypoint_info(entry, &be, &objv_tracker, &orig_mtime, nullptr, y, dpp);
- if (ret < 0)
- return ret;
-
- /*
- * We're unlinking the bucket but we don't want to update the entrypoint here - we're removing
- * 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(rados, be.owner, be.bucket, y, dpp, false);
- if (ret < 0) {
- ldpp_dout(dpp, -1) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
- }
-
- 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;
- }
- /* idempotent */
- return 0;
- }
-
- int call(std::function<int(RGWSI_Bucket_EP_Ctx& ctx)> f) {
- return call(nullopt, f);
- }
-
- int call(std::optional<RGWSI_MetaBackend_CtxParams> bectx_params,
- std::function<int(RGWSI_Bucket_EP_Ctx& ctx)> f) {
- return be_handler->call(bectx_params, [&](RGWSI_MetaBackend_Handler::Op *op) {
- RGWSI_Bucket_EP_Ctx ctx(op->ctx());
- return f(ctx);
- });
- }
+ int get(std::string& entry, RGWMetadataObject** obj, optional_yield y,
+ const DoutPrefixProvider *dpp) override;
+ int put(std::string& entry, RGWMetadataObject* obj,
+ RGWObjVersionTracker& objv_tracker,
+ optional_yield y, const DoutPrefixProvider* dpp,
+ RGWMDLogSyncType type, bool from_remote_zone) override;
+ int remove(std::string& entry, RGWObjVersionTracker& objv_tracker,
+ optional_yield y, const DoutPrefixProvider *dpp) override;
+
+ int mutate(const std::string& entry, const ceph::real_time& mtime,
+ RGWObjVersionTracker* objv_tracker, optional_yield y,
+ const DoutPrefixProvider* dpp, RGWMDLogStatus op_type,
+ std::function<int()> f) override;
+
+ int list_keys_init(const DoutPrefixProvider* dpp, const std::string& marker,
+ void** phandle) override;
+ int list_keys_next(const DoutPrefixProvider* dpp, void* handle, int max,
+ std::list<std::string>& keys, bool* truncated) override;
+ void list_keys_complete(void *handle) override;
+ std::string get_marker(void *handle) override;
};
-class RGWMetadataHandlerPut_Bucket : public RGWMetadataHandlerPut_SObj
+int RGWBucketMetadataHandler::get(std::string& entry, RGWMetadataObject** obj,
+ optional_yield y, const DoutPrefixProvider *dpp)
{
- RGWBucketMetadataHandler *bhandler;
- librados::Rados& rados;
- RGWBucketEntryMetadataObject *obj;
-public:
- RGWMetadataHandlerPut_Bucket(RGWBucketMetadataHandler *_handler, librados::Rados& rados,
- RGWSI_MetaBackend_Handler::Op *op, string& entry,
- RGWMetadataObject *_obj, RGWObjVersionTracker& objv_tracker,
- optional_yield y,
- RGWMDLogSyncType type, bool from_remote_zone)
- : RGWMetadataHandlerPut_SObj(_handler, op, entry, _obj, objv_tracker, y, type, from_remote_zone),
- bhandler(_handler),
- rados(rados),
- obj(static_cast<RGWBucketEntryMetadataObject *>(_obj))
- {}
+ RGWObjVersionTracker ot;
+ RGWBucketEntryPoint be;
+ real_time mtime;
+ map<string, bufferlist> attrs;
- void encode_obj(bufferlist *bl) override {
- obj->get_ep().encode(*bl);
+ int ret = svc_bucket->read_bucket_entrypoint_info(entry, &be, &ot, &mtime,
+ &attrs, y, dpp);
+ if (ret < 0) {
+ return ret;
}
- int put_checked(const DoutPrefixProvider *dpp) override;
- int put_post(const DoutPrefixProvider *dpp) override;
-};
-
-int RGWBucketMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
- RGWMetadataObject *obj,
- RGWObjVersionTracker& objv_tracker,
- optional_yield y,
- const DoutPrefixProvider *dpp,
- RGWMDLogSyncType type, bool from_remote_zone)
-{
- RGWMetadataHandlerPut_Bucket put_op(this, rados, op, entry, obj, objv_tracker,
- y, type, from_remote_zone);
- return do_put_operate(&put_op, dpp);
+ *obj = new RGWBucketEntryMetadataObject(be, ot.read_version, mtime,
+ std::move(attrs));
+ return 0;
}
-int RGWMetadataHandlerPut_Bucket::put_checked(const DoutPrefixProvider *dpp)
+int RGWBucketMetadataHandler::put(std::string& entry, RGWMetadataObject* obj,
+ RGWObjVersionTracker& objv_tracker,
+ optional_yield y, const DoutPrefixProvider* dpp,
+ RGWMDLogSyncType type, bool from_remote_zone)
{
- RGWBucketEntryMetadataObject *orig_obj = static_cast<RGWBucketEntryMetadataObject *>(old_obj);
-
- if (orig_obj) {
- obj->set_pattrs(&orig_obj->get_attrs());
+ std::optional old_be = RGWBucketEntryPoint{};
+ int ret = svc_bucket->read_bucket_entrypoint_info(
+ entry, &*old_be, &objv_tracker, nullptr, nullptr, y, dpp);
+ if (ret == -ENOENT) {
+ old_be = std::nullopt;
+ } else if (ret < 0) {
+ return ret;
}
- auto& be = obj->get_ep();
- auto mtime = obj->get_mtime();
- auto pattrs = obj->get_pattrs();
+ auto* epobj = static_cast<RGWBucketEntryMetadataObject*>(obj);
+ RGWBucketEntryPoint& new_be = epobj->get_ep();
- RGWSI_Bucket_EP_Ctx ctx(op->ctx());
-
- return bhandler->svc.bucket->store_bucket_entrypoint_info(entry,
- be,
- false,
- mtime,
- pattrs,
- &objv_tracker,
- y,
- dpp);
-}
-
-int RGWMetadataHandlerPut_Bucket::put_post(const DoutPrefixProvider *dpp)
-{
- auto* orig_obj = static_cast<RGWBucketEntryMetadataObject *>(old_obj);
- auto* old_be = orig_obj ? &orig_obj->get_ep() : nullptr;
- auto& new_be = obj->get_ep();
+ ret = svc_bucket->store_bucket_entrypoint_info(
+ entry, new_be, false, obj->get_mtime(),
+ obj->get_pattrs(), &objv_tracker, y, dpp);
+ if (ret < 0) {
+ return ret;
+ }
- RGWBucketCtl& ctl = *bhandler->ctl.bucket;
constexpr bool update_entrypoint = false;
if (old_be && (old_be->owner != new_be.owner || // owner changed
(old_be->linked && !new_be.linked))) { // linked -> false
- int ret = ctl.unlink_bucket(rados, old_be->owner, old_be->bucket,
- y, dpp, update_entrypoint);
+ int ret = ctl_bucket->unlink_bucket(rados, old_be->owner, old_be->bucket,
+ y, dpp, update_entrypoint);
if (ret < 0) {
return ret;
}
if (new_be.linked && (!old_be || !old_be->linked || // linked -> true
old_be->owner != new_be.owner)) { // owner changed
- int ret = ctl.link_bucket(rados, new_be.owner, new_be.bucket,
- new_be.creation_time, y, dpp, update_entrypoint);
+ int ret = ctl_bucket->link_bucket(rados, new_be.owner, new_be.bucket,
+ new_be.creation_time, y, dpp,
+ update_entrypoint);
if (ret < 0) {
return ret;
}
return ret;
}
+int RGWBucketMetadataHandler::remove(std::string& entry, RGWObjVersionTracker& objv_tracker,
+ optional_yield y, const DoutPrefixProvider *dpp)
+{
+ RGWBucketEntryPoint be;
+ int ret = svc_bucket->read_bucket_entrypoint_info(entry, &be, &objv_tracker,
+ nullptr, nullptr, y, dpp);
+ if (ret < 0) {
+ return ret;
+ }
+
+ constexpr bool update_ep = false; // removing anyway
+ ret = ctl_bucket->unlink_bucket(rados, be.owner, be.bucket, y, dpp, update_ep);
+ if (ret < 0) {
+ ldpp_dout(dpp, -1) << "could not unlink bucket=" << entry << " owner=" << be.owner << dendl;
+ }
+
+ 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;
+ }
+ /* idempotent */
+ return 0;
+}
+
+int RGWBucketMetadataHandler::mutate(const std::string& entry, const ceph::real_time& mtime,
+ RGWObjVersionTracker* objv_tracker, optional_yield y,
+ const DoutPrefixProvider* dpp, RGWMDLogStatus op_type,
+ std::function<int()> f)
+{
+ return -ENOTSUP; // unused
+}
+
+int RGWBucketMetadataHandler::list_keys_init(const DoutPrefixProvider* dpp,
+ const std::string& marker,
+ void** phandle)
+{
+ std::unique_ptr<RGWMetadataLister> lister;
+ int ret = svc_bucket->create_entrypoint_lister(dpp, marker, lister);
+ if (ret < 0) {
+ return ret;
+ }
+ *phandle = lister.release(); // release ownership
+ return 0;
+}
+
+int RGWBucketMetadataHandler::list_keys_next(const DoutPrefixProvider* dpp,
+ void* handle, int max,
+ std::list<std::string>& keys,
+ bool* truncated)
+{
+ auto lister = static_cast<RGWMetadataLister*>(handle);
+ return lister->get_next(dpp, max, keys, truncated);
+}
+
+void RGWBucketMetadataHandler::list_keys_complete(void *handle)
+{
+ delete static_cast<RGWMetadataLister*>(handle);
+}
+
+std::string RGWBucketMetadataHandler::get_marker(void *handle)
+{
+ auto lister = static_cast<RGWMetadataLister*>(handle);
+ return lister->get_marker();
+}
+
static void get_md5_digest(const RGWBucketEntryPoint *be, string& md5_digest) {
char md5[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 1];
WRITE_CLASS_ENCODER(archive_meta_info)
class RGWArchiveBucketMetadataHandler : public RGWBucketMetadataHandler {
-public:
- explicit RGWArchiveBucketMetadataHandler(librados::Rados& rados)
- : RGWBucketMetadataHandler(rados) {}
-
- int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
- optional_yield y, const DoutPrefixProvider *dpp) override {
- auto cct = svc.bucket->ctx();
+ public:
+ RGWArchiveBucketMetadataHandler(librados::Rados& rados,
+ RGWSI_Bucket* svc_bucket,
+ RGWBucketCtl* ctl_bucket)
+ : RGWBucketMetadataHandler(rados, svc_bucket, ctl_bucket) {}
+
+ int remove(std::string& entry, RGWObjVersionTracker& objv_tracker,
+ optional_yield y, const DoutPrefixProvider *dpp) override
+ {
+ auto cct = svc_bucket->ctx();
ldpp_dout(dpp, 5) << "SKIP: bucket removal is not allowed on archive zone: bucket:" << entry << " ... proceeding to rename" << dendl;
RGWBucketEntryPoint be;
map<string, bufferlist> attrs;
- int ret = svc.bucket->read_bucket_entrypoint_info(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;
}
ceph::real_time orig_mtime;
RGWBucketInfo old_bi;
- ret = ctl.bucket->read_bucket_instance_info(be.bucket, &old_bi, y, dpp, RGWBucketCtl::BucketInstance::GetParams()
+ ret = ctl_bucket->read_bucket_instance_info(be.bucket, &old_bi, y, dpp, RGWBucketCtl::BucketInstance::GetParams()
.set_mtime(&orig_mtime)
.set_attrs(&attrs_m));
if (ret < 0) {
archive_meta_info ami;
- if (!ami.from_attrs(svc.bucket->ctx(), attrs_m)) {
+ if (!ami.from_attrs(svc_bucket->ctx(), attrs_m)) {
ami.orig_bucket = old_bi.bucket;
ami.store_in_attrs(attrs_m);
}
new_be.bucket.name = new_bucket_name;
- ret = ctl.bucket->store_bucket_instance_info(new_be.bucket, new_bi, y, dpp, RGWBucketCtl::BucketInstance::PutParams()
+ ret = ctl_bucket->store_bucket_instance_info(new_be.bucket, new_bi, y, dpp, RGWBucketCtl::BucketInstance::PutParams()
.set_exclusive(false)
.set_mtime(orig_mtime)
.set_attrs(&attrs_m)
RGWObjVersionTracker ot;
ot.generate_new_write_ver(cct);
- ret = svc.bucket->store_bucket_entrypoint_info(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;
/* link new bucket */
- ret = ctl.bucket->link_bucket(rados, new_be.owner, new_be.bucket, new_be.creation_time, y, dpp, false);
+ ret = ctl_bucket->link_bucket(rados, new_be.owner, new_be.bucket, new_be.creation_time, y, dpp, false);
if (ret < 0) {
ldpp_dout(dpp, 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(rados, be.owner, entry_bucket, y, dpp, false);
+ ret = ctl_bucket->unlink_bucket(rados, be.owner, entry_bucket, y, dpp, false);
if (ret < 0) {
ldpp_dout(dpp, -1) << "could not unlink bucket=" << entry << " owner=" << be.owner << 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(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);
return ret;
}
- ret = ctl.bucket->remove_bucket_instance_info(be.bucket, old_bi, y, dpp);
+ ret = ctl_bucket->remove_bucket_instance_info(be.bucket, old_bi, y, dpp);
if (ret < 0) {
ldpp_dout(dpp, -1) << "could not delete bucket=" << entry << dendl;
}
return 0;
}
- int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
- RGWMetadataObject *obj,
- RGWObjVersionTracker& objv_tracker,
- optional_yield y, const DoutPrefixProvider *dpp,
- RGWMDLogSyncType type, bool from_remote_zone) override {
+ int put(std::string& entry, RGWMetadataObject* obj,
+ RGWObjVersionTracker& objv_tracker,
+ optional_yield y, const DoutPrefixProvider* dpp,
+ RGWMDLogSyncType type, bool from_remote_zone) override
+ {
if (entry.find("-deleted-") != string::npos) {
RGWObjVersionTracker ot;
RGWMetadataObject *robj;
- int ret = do_get(op, entry, &robj, y, dpp);
+ int ret = get(entry, &robj, y, dpp);
if (ret != -ENOENT) {
if (ret < 0) {
return ret;
ot.read_version = robj->get_version();
delete robj;
- ret = do_remove(op, entry, ot, y, dpp);
+ ret = remove(entry, ot, y, dpp);
if (ret < 0) {
return ret;
}
}
}
- return RGWBucketMetadataHandler::do_put(op, entry, obj,
- objv_tracker, y, dpp, type, from_remote_zone);
+ return RGWBucketMetadataHandler::put(entry, obj, objv_tracker, y,
+ dpp, type, from_remote_zone);
}
-
};
class RGWBucketInstanceMetadataHandler : public RGWBucketInstanceMetadataHandlerBase {
}
void RGWBucketCtl::init(RGWUserCtl *user_ctl,
- RGWBucketMetadataHandler *_bm_handler,
RGWBucketInstanceMetadataHandler *_bmi_handler,
RGWDataChangesLog *datalog,
const DoutPrefixProvider *dpp)
{
ctl.user = user_ctl;
- bm_handler = _bm_handler;
bmi_handler = _bmi_handler;
- bucket_be_handler = bm_handler->get_be_handler();
bi_be_handler = bmi_handler->get_be_handler();
datalog->set_bucket_filter(
return handler->bucket_imports_data();
}
-RGWBucketMetadataHandlerBase* RGWBucketMetaHandlerAllocator::alloc(librados::Rados& rados)
+auto create_bucket_metadata_handler(librados::Rados& rados,
+ RGWSI_Bucket* svc_bucket,
+ RGWBucketCtl* ctl_bucket)
+ -> std::unique_ptr<RGWMetadataHandler>
{
- return new RGWBucketMetadataHandler(rados);
+ return std::make_unique<RGWBucketMetadataHandler>(
+ rados, svc_bucket, ctl_bucket);
}
RGWBucketInstanceMetadataHandlerBase* RGWBucketInstanceMetaHandlerAllocator::alloc(rgw::sal::Driver* driver)
return new RGWBucketInstanceMetadataHandler(driver);
}
-RGWBucketMetadataHandlerBase* RGWArchiveBucketMetaHandlerAllocator::alloc(librados::Rados& rados)
+auto create_archive_bucket_metadata_handler(librados::Rados& rados,
+ RGWSI_Bucket* svc_bucket,
+ RGWBucketCtl* ctl_bucket)
+ -> std::unique_ptr<RGWMetadataHandler>
{
- return new RGWArchiveBucketMetadataHandler(rados);
+ return std::make_unique<RGWArchiveBucketMetadataHandler>(
+ rados, svc_bucket, ctl_bucket);
}
RGWBucketInstanceMetadataHandlerBase* RGWArchiveBucketInstanceMetaHandlerAllocator::alloc(rgw::sal::Driver* driver)
#include "svc_bi.h"
#include "svc_meta.h"
#include "svc_meta_be_sobj.h"
+#include "svc_mdlog.h"
#include "svc_sync_modules.h"
#include "rgw_bucket.h"
+#include "rgw_metadata_lister.h"
#include "rgw_string.h"
#include "rgw_tools.h"
#include "rgw_zone.h"
return key;
}
-class RGWSI_Bucket_SObj_Module : public RGWSI_MBSObj_Handler_Module {
- RGWSI_Bucket_SObj::Svc& svc;
-
- const string prefix;
-public:
- RGWSI_Bucket_SObj_Module(RGWSI_Bucket_SObj::Svc& _svc) : RGWSI_MBSObj_Handler_Module("bucket"),
- svc(_svc) {}
-
- void get_pool_and_oid(const string& key, rgw_pool *pool, string *oid) override {
- if (pool) {
- *pool = svc.zone->get_zone_params().domain_root;
- }
- if (oid) {
- *oid = key;
- }
- }
-
- const string& get_oid_prefix() override {
- return prefix;
- }
-
- bool is_valid_oid(const string& oid) override {
- return (!oid.empty() && oid[0] != '.');
- }
-
- string key_to_oid(const string& key) override {
- return key;
- }
-
- string oid_to_key(const string& oid) override {
- /* should have been called after is_valid_oid(),
- * so no need to check for validity */
- return oid;
- }
-};
-
class RGWSI_BucketInstance_SObj_Module : public RGWSI_MBSObj_Handler_Module {
RGWSI_Bucket_SObj::Svc& svc;
void RGWSI_Bucket_SObj::init(RGWSI_Zone *_zone_svc, RGWSI_SysObj *_sysobj_svc,
RGWSI_SysObj_Cache *_cache_svc, RGWSI_BucketIndex *_bi,
- RGWSI_Meta *_meta_svc, RGWSI_MetaBackend *_meta_be_svc,
+ RGWSI_Meta *_meta_svc, RGWSI_MDLog* mdlog_svc,
+ RGWSI_MetaBackend *_meta_be_svc,
RGWSI_SyncModules *_sync_modules_svc,
RGWSI_Bucket_Sync *_bucket_sync_svc)
{
svc.cache = _cache_svc;
svc.bi = _bi;
svc.meta = _meta_svc;
+ svc.mdlog = mdlog_svc;
svc.meta_be = _meta_be_svc;
svc.sync_modules = _sync_modules_svc;
svc.bucket_sync = _bucket_sync_svc;
binfo_cache.reset(new RGWChainedCacheImpl<bucket_info_cache_entry>);
binfo_cache->init(svc.cache);
- /* create first backend handler for bucket entrypoints */
-
- RGWSI_MetaBackend_Handler *ep_handler;
-
- int r = svc.meta->create_be_handler(RGWSI_MetaBackend::Type::MDBE_SOBJ, &ep_handler);
- if (r < 0) {
- ldpp_dout(dpp, 0) << "ERROR: failed to create be handler: r=" << r << dendl;
- return r;
- }
-
- ep_be_handler = ep_handler;
-
- RGWSI_MetaBackend_Handler_SObj *ep_bh = static_cast<RGWSI_MetaBackend_Handler_SObj *>(ep_handler);
-
- auto ep_module = new RGWSI_Bucket_SObj_Module(svc);
- ep_be_module.reset(ep_module);
- ep_bh->set_module(ep_module);
-
- /* create a second backend handler for bucket instance */
+ /* create a backend handler for bucket instance */
RGWSI_MetaBackend_Handler *bi_handler;
- r = svc.meta->create_be_handler(RGWSI_MetaBackend::Type::MDBE_SOBJ, &bi_handler);
+ int r = svc.meta->create_be_handler(RGWSI_MetaBackend::Type::MDBE_SOBJ, &bi_handler);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: failed to create be handler: r=" << r << dendl;
return r;
return 0;
}
+
+class BucketEntrypointLister : public RGWMetadataLister {
+ public:
+ using RGWMetadataLister::RGWMetadataLister;
+
+ void filter_transform(std::vector<std::string>& oids,
+ std::list<std::string>& keys) override
+ {
+ // bucket entrypoints and instances share a namespace, so filter out the
+ // instances based on prefix
+ constexpr auto filter = [] (const std::string& oid) {
+ return oid.starts_with('.');
+ };
+ // 'oids' is mutable so we can move its elements instead of copying
+ std::remove_copy_if(std::make_move_iterator(oids.begin()),
+ std::make_move_iterator(oids.end()),
+ std::back_inserter(keys), filter);
+ }
+};
+
+int RGWSI_Bucket_SObj::create_entrypoint_lister(
+ const DoutPrefixProvider* dpp,
+ const std::string& marker,
+ std::unique_ptr<RGWMetadataLister>& lister)
+{
+ const rgw_pool& pool = svc.zone->get_zone_params().domain_root;
+ auto p = std::make_unique<BucketEntrypointLister>(svc.sysobj->get_pool(pool));
+ int r = p->init(dpp, marker, ""); // empty prefix
+ if (r < 0) {
+ return r;
+ }
+ lister = std::move(p);
+ return 0;
+}
+
int RGWSI_Bucket_SObj::read_bucket_entrypoint_info(const string& key,
RGWBucketEntryPoint *entry_point,
RGWObjVersionTracker *objv_tracker,
encode(info, bl);
const rgw_pool& pool = svc.zone->get_zone_params().domain_root;
- return rgw_put_system_obj(dpp, svc.sysobj, pool, key, bl, exclusive,
- objv_tracker, mtime, y, pattrs);
+ int ret = rgw_put_system_obj(dpp, svc.sysobj, pool, key, bl, exclusive,
+ objv_tracker, mtime, y, pattrs);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return svc.mdlog->complete_entry(dpp, y, "bucket", key, objv_tracker);
}
int RGWSI_Bucket_SObj::remove_bucket_entrypoint_info(const string& key,
const DoutPrefixProvider *dpp)
{
const rgw_pool& pool = svc.zone->get_zone_params().domain_root;
- return rgw_delete_system_obj(dpp, svc.sysobj, pool, key, objv_tracker, y);
+ int ret = rgw_delete_system_obj(dpp, svc.sysobj, pool, key, objv_tracker, y);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return svc.mdlog->complete_entry(dpp, y, "bucket", key, objv_tracker);
}
int RGWSI_Bucket_SObj::read_bucket_instance_info(const string& key,
projects / ceph.git / commitdiff