JSONDecoder::decode_json("attrs", attrs, obj);
}
-class RGWBucketMetadataHandler : public RGWMetadataHandler_GenericMetaBE {
+class RGWBucketMetadataHandler : public RGWBucketMetadataHandlerBase {
RGWSI_MetaBackend_Handler *be_handler{nullptr};
public:
struct Svc {
RGWBucketCtl *bucket{nullptr};
} ctl;
- RGWBucketMetadataHandler(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl) : RGWMetadataHandler_GenericMetaBE(bucket_svc->ctx(),
- bucket_svc->get_ep_be_handler()) {
+ RGWBucketMetadataHandler() {}
+
+ void init(RGWSI_Bucket *bucket_svc,
+ RGWBucketCtl *bucket_ctl) override {
+ base_init(bucket_svc->ctx(),
+ bucket_svc->get_ep_be_handler());
svc.bucket = bucket_svc;
ctl.bucket = bucket_ctl;
- be_handler = svc.bucket->get_ep_be_handler();
}
string get_type() override { return "bucket"; }
class RGWArchiveBucketMetadataHandler : public RGWBucketMetadataHandler {
public:
- RGWArchiveBucketMetadataHandler(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl) : RGWBucketMetadataHandler(bucket_svc,
- bucket_ctl) {}
+ RGWArchiveBucketMetadataHandler() {}
int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
optional_yield y) override {
};
-class RGWBucketInstanceMetadataHandler : public RGWMetadataHandler_GenericMetaBE {
+class RGWBucketInstanceMetadataHandler : public RGWBucketInstanceMetadataHandlerBase {
RGWSI_MetaBackend_Handler *be_handler{nullptr};
int read_bucket_instance_entry(RGWSI_MetaBackend_Handler::Op *op,
RGWSI_BucketIndex *bi{nullptr};
} svc;
- RGWBucketInstanceMetadataHandler(RGWSI_Zone *zone_svc,
- RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc) : RGWMetadataHandler_GenericMetaBE(bucket_svc->ctx(),
- bucket_svc->get_bi_be_handler()) {
+ RGWBucketInstanceMetadataHandler() {}
+
+ void init(RGWSI_Zone *zone_svc,
+ RGWSI_Bucket *bucket_svc,
+ RGWSI_BucketIndex *bi_svc) {
+ base_init(bucket_svc->ctx(),
+ bucket_svc->get_bi_be_handler());
svc.zone = zone_svc;
svc.bucket = bucket_svc;
svc.bi = bi_svc;
class RGWArchiveBucketInstanceMetadataHandler : public RGWBucketInstanceMetadataHandler {
public:
- RGWArchiveBucketInstanceMetadataHandler(RGWSI_Zone *zone_svc,
- RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc) : RGWBucketInstanceMetadataHandler(zone_svc, bucket_svc, bi_svc) {}
+ RGWArchiveBucketInstanceMetadataHandler() {}
int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) override {
ldout(cct, 0) << "SKIP: bucket instance removal is not allowed on archive zone: bucket.instance:" << entry << dendl;
}
};
+
RGWBucketCtl::RGWBucketCtl(RGWSI_Zone *zone_svc,
RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc,
- RGWBucketMetadataHandler *_bm_handler,
- RGWBucketInstanceMetadataHandler *_bmi_handler) : cct(zone_svc->ctx()),
- bm_handler(_bm_handler),
- bmi_handler(_bmi_handler)
-
+ RGWSI_BucketIndex *bi_svc) : cct(zone_svc->ctx())
{
svc.zone = zone_svc;
svc.bucket = bucket_svc;
svc.bi = bi_svc;
+}
+
+void RGWBucketCtl::init(RGWUserCtl *user_ctl,
+ RGWBucketMetadataHandler *_bm_handler,
+ RGWBucketInstanceMetadataHandler *_bmi_handler)
+{
+ 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();
}
return ctl.user->flush_bucket_stats(user_id, ent);
}
-RGWMetadataHandler *RGWBucketMetaHandlerAllocator::alloc(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl) {
- return new RGWBucketMetadataHandler(bucket_svc, bucket_ctl);
+RGWBucketMetadataHandlerBase *RGWBucketMetaHandlerAllocator::alloc()
+{
+ return new RGWBucketMetadataHandler();
}
-RGWMetadataHandler *RGWBucketInstanceMetaHandlerAllocator::alloc(RGWSI_Zone *zone_svc,
- RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc) {
- return new RGWBucketInstanceMetadataHandler(zone_svc, bucket_svc, bi_svc);
+RGWBucketInstanceMetadataHandlerBase *RGWBucketInstanceMetaHandlerAllocator::alloc()
+{
+ return new RGWBucketInstanceMetadataHandler();
}
-RGWMetadataHandler *RGWArchiveBucketMetaHandlerAllocator::alloc(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl) {
- return new RGWArchiveBucketMetadataHandler(bucket_svc, bucket_ctl);
+RGWBucketMetadataHandlerBase *RGWArchiveBucketMetaHandlerAllocator::alloc()
+{
+ return new RGWArchiveBucketMetadataHandler();
}
-RGWMetadataHandler *RGWArchiveBucketInstanceMetaHandlerAllocator::alloc(RGWSI_Zone *zone_svc,
- RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc) {
- return new RGWArchiveBucketInstanceMetadataHandler(zone_svc, bucket_svc, bi_svc);
+RGWBucketInstanceMetadataHandlerBase *RGWArchiveBucketInstanceMetaHandlerAllocator::alloc()
+{
+ return new RGWArchiveBucketInstanceMetadataHandler();
}
};
WRITE_CLASS_ENCODER(RGWUserBuckets)
-class RGWMetadataManager;
-class RGWMetadataHandler;
+class RGWBucketMetadataHandlerBase : public RGWMetadataHandler_GenericMetaBE {
+public:
+ virtual ~RGWBucketMetadataHandlerBase() {}
+ virtual void init(RGWSI_Bucket *bucket_svc,
+ RGWBucketCtl *bucket_ctl) = 0;
+
+};
+
+class RGWBucketInstanceMetadataHandlerBase : public RGWMetadataHandler_GenericMetaBE {
+public:
+ virtual ~RGWBucketInstanceMetadataHandlerBase() {}
+ virtual void init(RGWSI_Zone *zone_svc,
+ RGWSI_Bucket *bucket_svc,
+ RGWSI_BucketIndex *bi_svc) = 0;
+
+};
class RGWBucketMetaHandlerAllocator {
public:
- static RGWMetadataHandler *alloc(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl);
+ static RGWBucketMetadataHandlerBase *alloc();
};
class RGWBucketInstanceMetaHandlerAllocator {
public:
- static RGWMetadataHandler *alloc(RGWSI_Zone *zone_svc,
- RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc);
+ static RGWBucketInstanceMetadataHandlerBase *alloc();
};
class RGWArchiveBucketMetaHandlerAllocator {
public:
- static RGWMetadataHandler *alloc(RGWSI_Bucket *bucket_svc,
- RGWBucketCtl *bucket_ctl);
+ static RGWBucketMetadataHandlerBase *alloc();
};
class RGWArchiveBucketInstanceMetaHandlerAllocator {
public:
- static RGWMetadataHandler *alloc(RGWSI_Zone *zone_svc,
- RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc);
+ static RGWBucketInstanceMetadataHandlerBase *alloc();
};
extern void rgw_bucket_init(RGWMetadataManager *mm);
public:
RGWBucketCtl(RGWSI_Zone *zone_svc,
RGWSI_Bucket *bucket_svc,
- RGWSI_BucketIndex *bi_svc,
- RGWBucketMetadataHandler *_bm_handler,
- RGWBucketInstanceMetadataHandler *_bmi_handler);
+ RGWSI_BucketIndex *bi_svc);
- void init(RGWUserCtl *user_ctl) {
- ctl.user = user_ctl;
- }
+ void init(RGWUserCtl *user_ctl,
+ RGWBucketMetadataHandler *_bm_handler,
+ RGWBucketInstanceMetadataHandler *_bmi_handler);
struct Bucket {
struct GetParams {
{
#warning what about attrs?
map<string, bufferlist> attrs;
- int ret = get(entry, &old_obj);
+ int ret = get(&old_obj);
if (ret < 0 && ret != -ENOENT) {
return ret;
}
oo.reset(old_obj);
- return 0;
-}
-
-int RGWMetadataHandlerPut_SObj::put_check()
-{
auto old_ver = (!old_obj ? obj_version() : old_obj->get_version());
auto old_mtime = (!old_obj ? ceph::real_time() : old_obj->get_mtime());
CephContext *cct;
public:
- RGWMetadataHandler(CephContext *_cct) : cct(_cct) {}
+ RGWMetadataHandler() {}
virtual ~RGWMetadataHandler() {}
virtual string get_type() = 0;
+ void base_init(CephContext *_cct) {
+ cct = _cct;
+ }
+
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 string get_marker(void *handle) = 0;
- virtual int init(RGWMetadataManager *manager);
+ virtual int attach(RGWMetadataManager *manager);
};
class RGWMetadataHandler_GenericMetaBE : public RGWMetadataHandler {
virtual int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker) = 0;
public:
- RGWMetadataHandler_GenericMetaBE(CephContext *_cct,
- RGWSI_MetaBackend_Handler *_be_handler) : RGWMetadataHandler(_cct),
- be_handler(_be_handler) {}
+ RGWMetadataHandler_GenericMetaBE() {}
+
+ void base_init(CephContext *_cct,
+ RGWSI_MetaBackend_Handler *_be_handler) {
+ RGWMetadataHandler::base_init(_cct);
+ be_handler = _be_handler;
+ }
RGWSI_MetaBackend_Handler *get_be_handler() {
return be_handler;
int put_pre() override;
int put() override;
- virtual int put_check();
+ virtual int put_check() {
+ return 0;
+ }
virtual int put_checked();
virtual void encode_obj(bufferlist *bl) {}
};
finisher->init();
bi_rados->init(zone.get(), rados.get());
bucket->init(zone.get(), sysobj.get(), sysobj_cache.get(),
- bi_rados.get(), meta.get(), sync_modules.get());
+ bi_rados.get(), meta.get(), meta_be_sobj.get(),
+ sync_modules.get());
cls->init(zone.get(), rados.get());
mdlog->init(zone.get(), sysobj.get());
meta->init(sysobj.get(), mdlog.get(), meta_bes);
meta.otp.reset(RGWOTPMetaHandlerAllocator::alloc(svc.zone, svc.meta_be_otp));
user.reset(new RGWUserCtl(svc.zone, svc.user, (RGWUserMetadataHandler *)meta.user.get()));
- bucket.reset(new RGWBucketCtl(svc.zone, svc.bucket, svc.bi,
- (RGWBucketMetadataHandler *)meta.bucket.get()),
- (RGWBucketInstanceMetadataHandler *)meta.bucket_instance.get());
+ bucket.reset(new RGWBucketCtl(svc.zone,
+ svc.bucket,
+ svc.bi));
+
+ RGWBucketMetadataHandlerBase *bucket_meta_handler = static_cast<RGWBucketMetadataHandlerBase *>(meta.bucket.get());
+ RGWBucketInstanceMetadataHandlerBase *bi_meta_handler = static_cast<RGWBucketInstanceMetadataHandlerBase *>(meta.bucket_instance.get());
+
+ bucket_meta_handler->init(svc.bucket, bucket.get());
+ bi_meta_handler->init(svc.zone, svc.bucket, svc.bi);
user->init(bucket.get());
- bucket->init(user.get());
+ bucket->init(user.get(),
+ (RGWBucketMetadataHandler *)bucket_meta_handler,
+ (RGWBucketInstanceMetadataHandler *)bi_meta_handler);
return 0;
}
user = _ctl.user.get();
bucket = _ctl.bucket.get();
- r = meta.user->init(meta.mgr);
+ r = meta.user->attach(meta.mgr);
if (r < 0) {
ldout(svc.cct, 0) << "ERROR: failed to start init meta.user ctl (" << cpp_strerror(-r) << dendl;
return r;
}
- r = meta.bucket->init(meta.mgr);
+ r = meta.bucket->attach(meta.mgr);
if (r < 0) {
ldout(svc.cct, 0) << "ERROR: failed to start init meta.bucket ctl (" << cpp_strerror(-r) << dendl;
return r;
}
- r = meta.bucket_instance->init(meta.mgr);
+ r = meta.bucket_instance->attach(meta.mgr);
if (r < 0) {
ldout(svc.cct, 0) << "ERROR: failed to start init meta.bucket_instance ctl (" << cpp_strerror(-r) << dendl;
return r;
}
- r = meta.otp->init(meta.mgr);
+ r = meta.otp->attach(meta.mgr);
if (r < 0) {
ldout(svc.cct, 0) << "ERROR: failed to start init otp ctl (" << cpp_strerror(-r) << dendl;
return r;
RGWSI_User *user{nullptr};
} svc;
- RGWUserMetadataHandler(RGWSI_User *user_svc) : RGWMetadataHandler_GenericMetaBE(user_svc->ctx(),
- user_svc->get_be_handler()) {
+ RGWUserMetadataHandler(RGWSI_User *user_svc) {
+ base_init(user_svc->ctx(), user_svc->get_be_handler());
svc.user = user_svc;
}
uobj = static_cast<RGWUserMetadataObject *>(obj);
}
- int put_checked(RGWMetadataObject *_old_obj) override;
+ int put_checked() override;
};
int RGWUserMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
return do_put_operate(&put_op);
}
-int RGWMetadataHandlerPut_User::put_checked(RGWMetadataObject *_old_obj)
+int RGWMetadataHandlerPut_User::put_checked()
{
- RGWUserMetadataObject *old_obj = static_cast<RGWUserMetadataObject *>(_old_obj);
+ RGWUserMetadataObject *orig_obj = static_cast<RGWUserMetadataObject *>(old_obj);
RGWUserCompleteInfo& uci = uobj->get_uci();
map<string, bufferlist> *pattrs{nullptr};
pattrs = &uci.attrs;
}
- RGWUserInfo *pold_info = (old_obj ? &old_obj->get_uci().info : nullptr);
+ RGWUserInfo *pold_info = (orig_obj ? &orig_obj->get_uci().info : nullptr);
auto mtime = obj->get_mtime();