set<string>::iterator iter;
};
- class HandlerModule : public RGWSI_MetaBackend::Module {
- public:
- void get_pool_and_oid(const string& key, rgw_pool& pool, string& oid) {}
- void key_to_oid(string& key) {}
- void oid_to_key(string& oid) {}
- };
-
struct Svc {
RGWSI_Meta *meta{nullptr};
} svc;
return new RGWMetadataObject;
}
- int do_get(RGWSI_MetaBackend::Context *ctx, string& entry, RGWMetadataObject **obj, optional_yield y) override { return -ENOTSUP; }
- int do_put(RGWSI_MetaBackend::Context *ctx, string& entry, RGWMetadataObject *obj,
+ int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj, optional_yield y) override { return -ENOTSUP; }
+ int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker, optional_yield y, RGWMDLogSyncType type) override { return -ENOTSUP; }
- int do_remove(RGWSI_MetaBackend::Context *ctx, string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y) override { return -ENOTSUP; }
+ int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y) override { return -ENOTSUP; }
int list_keys_init(const string& marker, void **phandle) override {
iter_data *data = new iter_data;
int RGWMetadataHandler::init(RGWMetadataManager *manager)
{
- int r = init_module();
+ int r = init_handler();
if (r < 0) {
return r;
}
- return manager->register_handler(this, &meta_be, &be_handle);
+ return manager->register_handler(this);
}
-RGWMetadataHandler::Put::Put(RGWMetadataHandler *handler, RGWSI_MetaBackend::Context *_ctx,
+RGWMetadataHandler::Put::Put(RGWMetadataHandler *handler,
string& _entry, RGWMetadataObject *_obj,
RGWObjVersionTracker& _objv_tracker,
optional_yield _y,
obj(_obj), objv_tracker(_objv_tracker),
apply_type(_type), y(_y)
{
- meta_be = handler->get_meta_be();
+ meta_be = handler->meta_be;
}
int RGWMetadataHandlerPut_SObj::put()
return 0;
}
-int RGWMetadataHandler::call_with_ctx(std::function<int(RGWSI_MetaBackend::Context *ctx)> f)
-{
- RGWSI_Meta_Ctx ctx;
- meta_be->init_ctx(be_handle, &ctx);
- return f(ctx.get());
-}
-
-int RGWMetadataHandler::call_with_ctx(const string& entry, std::function<int(RGWSI_MetaBackend::Context *ctx)> f)
+int RGWMetadataHandler::get(string& entry, RGWMetadataObject **obj)
{
- RGWSI_Meta_Ctx ctx;
- meta_be->init_ctx(be_handle, &ctx);
- ctx->set_key(entry);
- return f(ctx.get());
-}
-
-int RGWMetadataHandler::get(string& entry, RGWMetadataObject **obj, optional_yield y)
-{
- return call_with_ctx(entry, [&](RGWSI_MetaBackend::Context *ctx) {
- return do_get(ctx, entry, obj, y);
+ return meta_be->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return do_get(op, entry, obj, y);
});
}
int RGWMetadataHandler::put(string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
optional_yield y, RGWMDLogSyncType type)
{
- return call_with_ctx(entry, [&](RGWSI_MetaBackend::Context *ctx) {
- return do_put(ctx, entry, obj, objv_tracker, y, type);
+ return meta_be->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return do_put(op, entry, obj, objv_tracker, y, type);
});
}
int RGWMetadataHandler::remove(string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y)
{
- return call_with_ctx(entry, [&](RGWSI_MetaBackend::Context *ctx) {
- return do_remove(ctx, entry, objv_tracker, y);
+ return handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return do_remove(op, entry, objv_tracker, y);
});
}
-int RGWMetadataManager::register_handler(RGWMetadataHandler *handler, RGWSI_MetaBackend **pmeta_be, RGWSI_MetaBackend_Handle *phandle)
+int RGWMetadataManager::register_handler(RGWMetadataHandler *handler)
{
string type = handler->get_type();
if (handlers.find(type) != handlers.end())
- return -EINVAL;
+ return -EEXIST;
int ret = meta_svc->init_handler(handler, pmeta_be, phandle);
if (ret < 0) {
friend class RGWMetadataManager;
friend class Put;
+protected:
+ RGWSI_MetaBackend_Handler *meta_be;
public:
class Put {
protected:
- RGWSI_MetaBackend *meta_be;
RGWMetadataHandler *handler;
- RGWSI_MetaBackend::Context *ctx;
+ RGWSI_MetaBackend_Handler::Op *op;
string& entry;
RGWMetadataObject *obj;
RGWObjVersionTracker& objv_tracker;
optional_yield y;
int get(RGWMetadataObject **obj) {
- return handler->do_get(ctx, entry, obj, y);
+ return handler->do_get(op, entry, obj, y);
}
public:
- Put(RGWMetadataHandler *handler, RGWSI_MetaBackend::Context *_ctx,
+ Put(RGWMetadataHandler *handler, RGWSI_MetaBackend_Handler::Op *_op,
string& _entry, RGWMetadataObject *_obj,
RGWObjVersionTracker& _objv_tracker, optional_yield _y,
RGWMDLogSyncType _type);
};
protected:
- RGWSI_MetaBackend *meta_be{nullptr};
- RGWSI_MetaBackend_Handle be_handle{0};
- RGWSI_MetaBackend::ModuleRef be_module;
+ virtual int init_handler() {
+ return 0;
+ }
- virtual int do_get(RGWSI_MetaBackend::Context *ctx, string& entry, RGWMetadataObject **obj,
- optional_yield y) = 0;
- virtual int do_put(RGWSI_MetaBackend::Context *ctx, string& entry, RGWMetadataObject *obj,
- RGWObjVersionTracker& objv_tracker, RGWMDLogSyncType type,
+ 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,
+ optional_yield y, RGWMDLogSyncType type) = 0;
virtual int do_put_operate(Put *put_op);
- virtual int do_remove(RGWSI_MetaBackend::Context *ctx, string& entry, RGWObjVersionTracker& objv_tracker,
+ virtual int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
optional_yield y) = 0;
- virtual int init_module() = 0;
-
public:
virtual ~RGWMetadataHandler() {}
virtual string get_type() = 0;
- virtual RGWSI_MetaBackend::ModuleRef& get_be_module() {
- return be_module;
- }
-
- RGWSI_MetaBackend *get_meta_be() {
- return meta_be;
- }
-
virtual RGWMetadataObject *get_meta_obj(JSONObj *jo, const obj_version& objv, const ceph::real_time& mtime) = 0;
int get(string& entry, RGWMetadataObject **obj, optional_yield y);
virtual string get_marker(void *handle) = 0;
- int init(RGWMetadataManager *manager);
+ virtual int init(RGWMetadataManager *manager);
/**
* Compare an incoming versus on-disk tag/version+mtime combo against
}
return true;
}
-
- int call_with_ctx(std::function<int(RGWSI_MetaBackend::Context *ctx)> f);
- int call_with_ctx(const string& entry, std::function<int(RGWSI_MetaBackend::Context *ctx)> f);
-
};
class RGWMetadataTopHandler;
std::unique_ptr<RGWMetadataTopHandler> md_top_handler;
int find_handler(const string& metadata_key, RGWMetadataHandler **handler, string& entry);
- int register_handler(RGWMetadataHandler *handler, RGWSI_MetaBackend **pmeta_be, RGWSI_MetaBackend_Handle *phandle);
+ int register_handler(RGWMetadataHandler *handler);
-protected:
- int call_with_ctx(const string& entry, RGWMetadataObject *obj, std::function<int(RGWSI_MetaBackend::Context *ctx)> f);
public:
RGWMetadataManager(RGWSI_Meta *_meta_svc);
~RGWMetadataManager();
class RGWMetadataHandlerPut_SObj : public RGWMetadataHandler::Put
{
public:
- RGWMetadataHandlerPut_SObj(RGWMetadataHandler *handler, RGWSI_MetaBackend::Context *ctx,
+ RGWMetadataHandlerPut_SObj(RGWMetadataHandler *handler, RGWSI_MetaBackend_Handler::Op *op,
string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
- RGWMDLogSyncType type) : Put(handler, ctx, entry, obj, objv_tracker, type) {}
+ RGWMDLogSyncType type) : Put(handler, op, entry, obj, objv_tracker, type) {}
~RGWMetadataHandlerPut_SObj() {}
int put() override;
op_state.max_entries = 1000;
}
- auto meta_mgr = store->svc.meta->get_mgr();
+ auto meta_mgr = store->ctl.meta.mgr;
int ret = meta_mgr->list_keys_init(metadata_key, op_state.marker, &handle);
if (ret < 0) {
}
class RGWUserMetadataHandler : public RGWMetadataHandler {
+ RGWSI_MetaBackend_Handler *be_handler{nullptr};
public:
struct Svc {
RGWSI_User *user{nullptr};
RGWUserMetadataHandler(RGWSI_User *user_svc) {
svc.user = user_svc;
+ be_handler = svc.user->get_be_handler();
+ }
+
+ RGWSI_MetaBackend_Handler *get_be_handler() {
+ return be_handler;
}
string get_type() override { return "user"; }
- int do_get(RGWSI_MetaBackend::Context *ctx, string& entry, RGWMetadataObject **obj, optional_yield y) override {
+ int do_get(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWMetadataObject **obj, optional_yield y) override {
RGWUserCompleteInfo uci;
RGWObjVersionTracker objv_tracker;
real_time mtime;
- int ret = svc.user->read_user_info(ctx, &uci.info, &objv_tracker,
+ rgw_user user = RGWSI_User::user_from_meta_key(entry);
+
+ int ret = svc.user->read_user_info(op->ctx(), user, &uci.info, &objv_tracker,
&mtime, nullptr, &uci.attrs,
y);
if (ret < 0) {
return new RGWUserMetadataObject(uci, objv, mtime);
}
- int do_put(RGWSI_MetaBackend::Context *ctx, string& entry,
+ int do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
RGWListRawObjsCtx ctx;
};
- int do_remove(RGWSI_MetaBackend::Context *ctx, string& entry, RGWObjVersionTracker& objv_tracker,
+ int do_remove(RGWSI_MetaBackend_Handler::Op *op, string& entry, RGWObjVersionTracker& objv_tracker,
optional_yield y) {
RGWUserInfo info;
- int ret = svc.user->read_user_info(ctx, &info, nullptr,
+ rgw_user user = RGWSI_User::user_from_meta_key(entry);
+
+ int ret = svc.user->read_user_info(op->ctx(), user, &info, nullptr,
nullptr, nullptr, nullptr,
y);
if (ret < 0) {
return ret;
}
- return svc.user->remove_user_info(ctx, info, &objv_tracker,
+ return svc.user->remove_user_info(op->ctx(), info, &objv_tracker,
y);
}
RGWUserMetadataObject *uobj;
public:
RGWMetadataHandlerPut_User(RGWUserMetadataHandler *_handler,
- RGWSI_MetaBackend::Context *ctx, string& entry,
+ RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
optional_yield y,
- RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(handler, ctx, entry, obj, objv_tracker, y, type),
- handler(_handler) {
+ RGWMDLogSyncType type) : RGWMetadataHandlerPut_SObj(handler, op, entry, obj, objv_tracker, y, type),
+ handler(_handler) {
uobj = static_cast<RGWUserMetadataObject *>(obj);
}
int put_checked(RGWMetadataObject *_old_obj) override;
};
-int RGWUserMetadataHandler::do_put(RGWSI_MetaBackend::Context *ctx, string& entry,
+int RGWUserMetadataHandler::do_put(RGWSI_MetaBackend_Handler::Op *op, string& entry,
RGWMetadataObject *obj,
RGWObjVersionTracker& objv_tracker,
optional_yield y,
RGWMDLogSyncType type)
{
- RGWMetadataHandlerPut_User op(this, ctx, entry, obj, objv_tracker, y, type);
- return do_put_operate(&op);
+ RGWMetadataHandlerPut_User put_op(this, op, entry, obj, objv_tracker, y, type);
+ return do_put_operate(&put_op);
}
int RGWMetadataHandlerPut_User::put_checked(RGWMetadataObject *_old_obj)
auto mtime = obj->get_mtime();
- int ret = handler->svc.user->store_user_info(ctx, uci.info, pold_info,
+ int ret = handler->svc.user->store_user_info(op->ctx(), uci.info, pold_info,
&objv_tracker, mtime,
false, pattrs, y);
if (ret < 0) {
}
+RGWUserCtl::RGWUserCtl(RGWSI_Zone *zone_svc,
+ RGWSI_User *user_svc,
+ RGWUserMetadataHandler *_umhandler) : umhandler(_umhandler) {
+ svc.zone = zone_svc;
+ svc.user = user_svc;
+ be_handler = umhandler->get_be_handler();
+}
+
int RGWUserCtl::get_info_by_uid(const rgw_user& uid, GetParams& params)
{
- string key = RGWSI_User::get_meta_key(uid);
-
- return umhandler->call_with_ctx(key, [&](RGWSI_MetaBackend::Context *ctx) {
- return svc.user->read_user_info(ctx,
+ return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return svc.user->read_user_info(op->ctx(),
+ uid,
params.info,
params.objv_tracker,
params.mtime,
int RGWUserCtl::get_info_by_email(const string& email, GetParams& params)
{
- return umhandler->call_with_ctx([&](RGWSI_MetaBackend::Context *ctx) {
- return svc.user->get_user_info_by_email(ctx, email,
+ return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return svc.user->get_user_info_by_email(op->ctx(), email,
params.info,
params.objv_tracker,
params.mtime,
int RGWUserCtl::get_info_by_swift(const string& swift_name, GetParams& params)
{
- return umhandler->call_with_ctx([&](RGWSI_MetaBackend::Context *ctx) {
- return svc.user->get_user_info_by_swift(ctx, swift_name,
+ return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return svc.user->get_user_info_by_swift(op->ctx(), swift_name,
params.info,
params.objv_tracker,
params.mtime,
int RGWUserCtl::get_info_by_access_key(const string& access_key, GetParams& params)
{
- return umhandler->call_with_ctx([&](RGWSI_MetaBackend::Context *ctx) {
- return svc.user->get_user_info_by_swift(ctx, access_key,
+ return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return svc.user->get_user_info_by_swift(op->ctx(), access_key,
params.info,
params.objv_tracker,
params.mtime,
}
int RGWUserCtl::store_info(const RGWUserInfo& info, PutParams& params)
-
{
string key = RGWSI_User::get_meta_key(info.user_id);
- return umhandler->call_with_ctx(key, [&](RGWSI_MetaBackend::Context *ctx) {
- return svc.user->store_user_info(ctx, info,
+ return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return svc.user->store_user_info(op->ctx(), info,
params.old_info,
params.objv_tracker,
params.mtime,
{
string key = RGWSI_User::get_meta_key(info.user_id);
- return umhandler->call_with_ctx(key, [&](RGWSI_MetaBackend::Context *ctx) {
- return svc.user->remove_user_info(ctx, info,
+ return be_handler->call([&](RGWSI_MetaBackend_Handler::Op *op) {
+ return svc.user->remove_user_info(op->ctx(), info,
params.objv_tracker,
params.y);
});
} svc;
RGWUserMetadataHandler *umhandler;
+ RGWSI_MetaBackend_Handler *be_handler;
public:
RGWUserCtl(RGWSI_Zone *zone_svc,
RGWSI_User *user_svc,
- RGWUserMetadataHandler *_umhandler) : umhandler(_umhandler) {
- svc.zone = zone_svc;
- svc.user = user_svc;
- }
+ RGWUserMetadataHandler *_umhandler);
struct GetParams {
RGWUserInfo *info{nullptr};
RGWSI_MetaBackend::RemoveParams::~RemoveParams() {} // ...
int RGWSI_MetaBackend::pre_modify(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
RGWMetadataLogData& log_data,
RGWObjVersionTracker *objv_tracker,
RGWMDLogStatus op_type)
bufferlist logbl;
encode(log_data, logbl);
- int ret = mdlog_svc->add_entry(ctx->module, ctx->section, ctx->key, logbl);
+ int ret = mdlog_svc->add_entry(ctx->module, ctx->section, key, logbl);
if (ret < 0)
return ret;
}
int RGWSI_MetaBackend::post_modify(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
RGWMetadataLogData& log_data,
RGWObjVersionTracker *objv_tracker, int ret)
{
bufferlist logbl;
encode(log_data, logbl);
- int r = mdlog_svc->add_entry(ctx->module, ctx->section, ctx->key, logbl);
+ int r = mdlog_svc->add_entry(ctx->module, ctx->section, key, logbl);
if (ret < 0)
return ret;
}
int RGWSI_MetaBackend::prepare_mutate(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
const real_time& mtime,
RGWObjVersionTracker *objv_tracker,
RGWMDLogSyncType sync_mode)
real_time orig_mtime;
unique_ptr<GetParams> params(alloc_default_get_params(&orig_mtime));
- int ret = get_entry(ctx, *params, objv_tracker);
+ int ret = get_entry(ctx, key, *params, objv_tracker);
if (ret < 0 && ret != -ENOENT) {
return ret;
}
}
int RGWSI_MetaBackend::mutate(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
RGWMDLogStatus op_type,
int ret;
if (generic_prepare) {
- ret = prepare_mutate(ctx, mtime, objv_tracker, sync_mode);
+ ret = prepare_mutate(ctx, key, mtime, objv_tracker, sync_mode);
if (ret < 0 ||
ret == STATUS_NO_APPLY) {
return ret;
}
RGWMetadataLogData log_data;
- ret = pre_modify(ctx, log_data, objv_tracker, op_type);
+ ret = pre_modify(ctx, key, log_data, objv_tracker, op_type);
if (ret < 0) {
return ret;
}
/* cascading ret into post_modify() */
- ret = post_modify(ctx, log_data, objv_tracker, ret);
+ ret = post_modify(ctx, key, log_data, objv_tracker, ret);
if (ret < 0)
return ret;
}
int RGWSI_MetaBackend::get(Context *ctx,
+ const string& key,
GetParams& params,
RGWObjVersionTracker *objv_tracker)
{
- return get_entry(ctx, params, objv_tracker);
+ return get_entry(ctx, key, params, objv_tracker);
}
int RGWSI_MetaBackend::put(Context *ctx,
+ const string& key,
PutParams& params,
RGWObjVersionTracker *objv_tracker,
RGWMDLogSyncType sync_mode)
{
std::function<int()> f = [&]() {
- return put_entry(ctx, params, objv_tracker);
+ return put_entry(ctx, key, params, objv_tracker);
};
- return mutate(ctx, params.mtime, objv_tracker,
+ return mutate(ctx, key, params.mtime, objv_tracker,
MDLOG_STATUS_WRITE, sync_mode,
f,
false);
}
int RGWSI_MetaBackend::remove(Context *ctx,
+ const string& key,
RemoveParams& params,
RGWObjVersionTracker *objv_tracker,
RGWMDLogSyncType sync_mode)
{
std::function<int()> f = [&]() {
- return remove_entry(ctx, params, objv_tracker);
+ return remove_entry(ctx, key, params, objv_tracker);
};
- return mutate(ctx, params.mtime, objv_tracker,
+ return mutate(ctx, key, params.mtime, objv_tracker,
MDLOG_STATUS_REMOVE, sync_mode,
f,
false);
}
+
+int RGWSI_MetaBackend_Handler::call(std::function<int(Op *)> f)
+{
+ return be->call([&](RGWSI_MetaBackend::Context *ctx) {
+ ctx->init(this);
+ Op op(be, ctx);
+ return f(&op);
+ });
+}
+
#include "rgw/rgw_service.h"
#include "rgw/rgw_mdlog_types.h"
-class RGWMetadataHandler;
class RGWMetadataLogData;
-class RGWMetadataObject;
class RGWSI_MDLog;
class RGWSI_Meta;
-
-typedef void *RGWSI_MetaBackend_Handle;
+class RGWObjVersionTracker;
+class RGWSI_MetaBackend_Handler;
class RGWSI_MetaBackend : public RGWServiceInstance
{
class Module;
class Context;
protected:
- map<string, RGWMetadataHandler *> handlers;
-
RGWSI_MDLog *mdlog_svc{nullptr};
- int find_handler(const string& metadata_key, RGWMetadataHandler **handler, string& entry);
-
void base_init(RGWSI_MDLog *_mdlog_svc) {
mdlog_svc = _mdlog_svc;
}
- virtual int init_handler(RGWMetadataHandler *handler, RGWSI_MetaBackend_Handle *phandle) { return 0; }
-
int prepare_mutate(RGWSI_MetaBackend::Context *ctx,
- const real_time& mtime,
+ const std::string& key,
+ const ceph::real_time& mtime,
RGWObjVersionTracker *objv_tracker,
RGWMDLogSyncType sync_mode);
virtual int mutate(Context *ctx,
+ const std::string& key,
const ceph::real_time& mtime, RGWObjVersionTracker *objv_tracker,
RGWMDLogStatus op_type,
RGWMDLogSyncType sync_mode,
bool generic_prepare);
virtual int pre_modify(Context *ctx,
+ const std::string& key,
RGWMetadataLogData& log_data,
RGWObjVersionTracker *objv_tracker,
RGWMDLogStatus op_type);
virtual int post_modify(Context *ctx,
+ const std::string& key,
RGWMetadataLogData& log_data,
RGWObjVersionTracker *objv_tracker, int ret);
public:
*/
public:
virtual ~Module() = 0;
- /* key to use for hashing entries for log shard placement */
- virtual void get_hash_key(const string& section, const string& key, string& hash_key) {
- hash_key = section + ":" + key;
- }
};
using ModuleRef = std::shared_ptr<Module>;
*/
virtual ~Context() = 0;
- RGWSI_MetaBackend_Handle handle;
- Module *module{nullptr};
- std::string section;
- std::string key;
-
- virtual void set_key(const string& _key) {
- key = _key;
- }
+ virtual void init(RGWSI_MetaBackend_Handler *h) = 0;
};
struct PutParams {
virtual Type get_type() = 0;
- virtual void init_ctx(RGWSI_MetaBackend_Handle handle, Context *ctx) = 0;
-
+ virtual RGWSI_MetaBackend_Handler *alloc_be_handler() = 0;
virtual GetParams *alloc_default_get_params(ceph::real_time *pmtime) = 0;
/* these should be implemented by backends */
virtual int get_entry(RGWSI_MetaBackend::Context *ctx,
+ const std::string& key,
RGWSI_MetaBackend::GetParams& params,
RGWObjVersionTracker *objv_tracker,
optional_yield y) = 0;
virtual int put_entry(RGWSI_MetaBackend::Context *ctx,
+ const std::string& key,
RGWSI_MetaBackend::PutParams& params,
RGWObjVersionTracker *objv_tracker,
optional_yield y) = 0;
virtual int remove_entry(Context *ctx,
+ const std::string& key,
RGWSI_MetaBackend::RemoveParams& params,
RGWObjVersionTracker *objv_tracker,
optional_yield y) = 0;
- /* these should be called by handlers */
+ virtual int call(std::function<int(RGWSI_MetaBackend::Context *)> f) = 0;
+
+ /* higher level */
virtual int get(Context *ctx,
+ const std::string& key,
GetParams ¶ms,
RGWObjVersionTracker *objv_tracker,
optional_yield y);
virtual int put(Context *ctx,
+ const std::string& key,
PutParams& params,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
RGWMDLogSyncType sync_mode);
virtual int remove(Context *ctx,
+ const std::string& key,
RemoveParams& params,
RGWObjVersionTracker *objv_tracker,
optional_yield y,
RGWMDLogSyncType sync_mode);
+
+};
+
+class RGWSI_MetaBackend_Handler {
+ RGWSI_MetaBackend *be{nullptr};
+
+public:
+ class Op {
+ friend class RGWSI_MetaBackend_Handler;
+
+ RGWSI_MetaBackend *be;
+ RGWSI_MetaBackend::Context *be_ctx;
+
+ Op(RGWSI_MetaBackend *_be,
+ RGWSI_MetaBackend::Context *_ctx) : be(_be), be_ctx(_ctx) {}
+
+ public:
+ RGWSI_MetaBackend::Context *ctx() {
+ return be_ctx;
+ }
+
+ int get(const std::string& key,
+ RGWSI_MetaBackend::GetParams ¶ms,
+ RGWObjVersionTracker *objv_tracker) {
+ return be->get(be_ctx, key, params, objv_tracker);
+ }
+
+ int put(const std::string& key,
+ RGWSI_MetaBackend::PutParams& params,
+ RGWObjVersionTracker *objv_tracker,
+ RGWMDLogSyncType sync_mode) {
+ return be->put(be_ctx, key, params, objv_tracker, sync_mode);
+ }
+
+ int remove(const std::string& key,
+ RGWSI_MetaBackend::RemoveParams& params,
+ RGWObjVersionTracker *objv_tracker,
+ RGWMDLogSyncType sync_mode) {
+ return be->remove(be_ctx, key, params, objv_tracker, sync_mode);
+ }
+ };
+
+ RGWSI_MetaBackend_Handler(RGWSI_MetaBackend *_be) : be(_be) {}
+ virtual ~RGWSI_MetaBackend_Handler() {}
+
+ virtual int call(std::function<int(Op *)> f);
};
RGWSI_MetaBackend_SObj::~RGWSI_MetaBackend_SObj() {
}
-int RGWSI_MetaBackend_SObj::init_handler(RGWMetadataHandler *handler, RGWSI_MetaBackend_Handle *phandle)
+RGWSI_MetaBackend_Handler *RGWSI_MetaBackend_SObj::alloc_be_handler()
{
- const auto& section = handler->get_type();
-
- auto& info = handlers[section];
- info.section = section;
- info._module = handler->get_be_module();
- info.module = static_cast<RGWSI_MBSObj_Handler_Module *>(info._module.get());
-
- *phandle = (RGWSI_MetaBackend_Handle)(&info);
-
- return 0;
+ return new RGWSI_MetaBackend_Handler_SObj(this);
}
-void RGWSI_MetaBackend_SObj::init_ctx(RGWSI_MetaBackend_Handle handle, RGWSI_MetaBackend::Context *_ctx)
+int RGWSI_MetaBackend_SObj::call(std::function<int(RGWSI_MetaBackend::Context *)> f)
{
- RGWSI_MetaBackend_SObj::Context_SObj *ctx = static_cast<RGWSI_MetaBackend_SObj::Context_SObj *>(_ctx);
- rgwsi_meta_be_sobj_handler_info *h = static_cast<rgwsi_meta_be_sobj_handler_info *>(handle);
-
- ctx->handle = handle;
- ctx->module = h->module;
- ctx->section = h->section;
- ctx->_obj_ctx.emplace(sysobj_svc->init_obj_ctx());
- ctx->obj_ctx = &(*ctx->_obj_ctx);
+ RGWSI_MetaBackend_SObj::Context_SObj ctx(sysobj_svc);
+ return f(&ctx);
}
-void RGWSI_MetaBackend_SObj::Context_SObj::set_key(const string& _key)
+void RGWSI_MetaBackend_SObj::Context_SObj::init(RGWSI_MetaBackend_Handler *h)
{
- RGWSI_MetaBackend::Context::set_key(_key);
- static_cast<RGWSI_MBSObj_Handler_Module *>(module)->get_pool_and_oid(key, pool, oid);
-}
-
-RGWSI_MetaBackend_SObj::Context_SObj *RGWSI_MetaBackend_SObj::Context_SObj::clone(const string& key)
-{
- if (!_ctx2) {
- _ctx2.reset(new RGWSI_MetaBackend_SObj::Context_SObj);
- }
- *_ctx2 = *this;
- _ctx2->set_key(key);
- return _ctx2.get();
+ RGWSI_MetaBackend_Handler_SObj *handler = static_cast<RGWSI_MetaBackend_Handler_SObj *>(h);
+ module = handler->module;
+ obj_ctx.emplace(sysobj_svc->init_obj_ctx());
}
RGWSI_MetaBackend::GetParams *RGWSI_MetaBackend_SObj::alloc_default_get_params(ceph::real_time *pmtime)
}
int RGWSI_MetaBackend_SObj::get_entry(RGWSI_MetaBackend::Context *_ctx,
+ const string& key,
GetParams& _params,
RGWObjVersionTracker *objv_tracker)
{
RGWSI_MetaBackend_SObj::Context_SObj *ctx = static_cast<RGWSI_MetaBackend_SObj::Context_SObj *>(_ctx);
RGWSI_MBSObj_GetParams& params = static_cast<RGWSI_MBSObj_GetParams&>(_params);
- return rgw_get_system_obj(*ctx->obj_ctx, ctx->pool, ctx->oid, *params.pbl,
+ rgw_pool pool;
+ string oid;
+ ctx->module->get_pool_and_oid(key, &pool, &oid);
+
+ return rgw_get_system_obj(*ctx->obj_ctx, pool, oid, *params.pbl,
objv_tracker, params.pmtime,
params.y,
params.pattrs, params.cache_info,
}
int RGWSI_MetaBackend_SObj::put_entry(RGWSI_MetaBackend::Context *_ctx,
+ const string& key,
PutParams& _params,
RGWObjVersionTracker *objv_tracker)
{
RGWSI_MetaBackend_SObj::Context_SObj *ctx = static_cast<RGWSI_MetaBackend_SObj::Context_SObj *>(_ctx);
RGWSI_MBSObj_PutParams& params = static_cast<RGWSI_MBSObj_PutParams&>(_params);
- return rgw_put_system_obj(*ctx->obj_ctx, ctx->pool, ctx->oid, params.bl, params.exclusive,
+ rgw_pool pool;
+ string oid;
+ ctx->module->get_pool_and_oid(key, &pool, &oid);
+
+ return rgw_put_system_obj(*ctx->obj_ctx, pool, oid, params.bl, params.exclusive,
objv_tracker, params.mtime, params.y, params.pattrs);
}
int RGWSI_MetaBackend_SObj::remove_entry(RGWSI_MetaBackend::Context *_ctx,
+ const string& key,
RemoveParams& params,
RGWObjVersionTracker *objv_tracker)
{
RGWSI_MetaBackend_SObj::Context_SObj *ctx = static_cast<RGWSI_MetaBackend_SObj::Context_SObj *>(_ctx);
- rgw_raw_obj k(ctx->pool, ctx->oid);
+ rgw_pool pool;
+ string oid;
+ ctx->module->get_pool_and_oid(key, &pool, &oid);
+ rgw_raw_obj k(pool, oid);
auto sysobj = ctx->obj_ctx->get_obj(k);
return sysobj.wop()
#include "svc_sys_obj.h"
-class RGWSI_MBSObj_Handler_Module;
-
-struct rgwsi_meta_be_sobj_handler_info {
- RGWSI_MetaBackend::ModuleRef _module;
- RGWSI_MBSObj_Handler_Module *module;
- string section;
-};
-
-
class RGWSI_MBSObj_Handler_Module : public RGWSI_MetaBackend::Module {
public:
- virtual void get_pool_and_oid(const string& key, rgw_pool& pool, string& oid) = 0;
+ virtual void get_pool_and_oid(const string& key, rgw_pool *pool, string *oid) = 0;
virtual void key_to_oid(string& key) {}
virtual void oid_to_key(string& oid) {}
+
+ /* key to use for hashing entries for log shard placement */
+ virtual void get_hash_key(const std::string& section, const std::string& key, std::string& hash_key) {
+ hash_key = section + ":" + key;
+ }
};
struct RGWSI_MBSObj_GetParams : public RGWSI_MetaBackend::GetParams {
map<string, bufferlist> *pattrs{nullptr};
rgw_cache_entry_info *cache_info{nullptr};
boost::optional<obj_version> refresh_version;
- optional_yield y{null_yield};
RGWSI_MBSObj_GetParams() {}
RGWSI_MBSObj_GetParams(bufferlist *_pbl,
std::map<string, bufferlist> *_pattrs,
- ceph::real_time *_pmtime,
- optional_yield _y) : RGWSI_MetaBackend::GetParams(_pmtime),
+ ceph::real_time *_pmtime) : RGWSI_MetaBackend::GetParams(_pmtime),
pbl(_pbl),
- pattrs(_pattrs),
- y(_y) {}
+ pattrs(_pattrs) {}
};
struct RGWSI_MBSObj_PutParams : public RGWSI_MetaBackend::PutParams {
bufferlist bl;
map<string, bufferlist> *pattrs{nullptr};
bool exclusive{false};
- optional_yield y{null_yield};
RGWSI_MBSObj_PutParams() {}
RGWSI_MBSObj_PutParams(std::map<string, bufferlist> *_pattrs,
- const ceph::real_time& _mtime,
- optional_yield _y) : RGWSI_MetaBackend::PutParams(_mtime),
- pattrs(_pattrs),
- y(_y) {}
+ const ceph::real_time& _mtime) : RGWSI_MetaBackend::PutParams(_mtime),
+ pattrs(_pattrs) {}
RGWSI_MBSObj_PutParams(bufferlist& _bl,
std::map<string, bufferlist> *_pattrs,
const ceph::real_time& _mtime,
- bool _exclusive,
- optional_yield _y) : RGWSI_MetaBackend::PutParams(_mtime),
- bl(_bl),
- pattrs(_pattrs),
- exclusive(_exclusive),
- y(_y) {}
+ bool _exclusive) : RGWSI_MetaBackend::PutParams(_mtime),
+ bl(_bl),
+ pattrs(_pattrs),
+ exclusive(_exclusive) {}
};
struct RGWSI_MBSObj_RemoveParams : public RGWSI_MetaBackend::RemoveParams {
- optional_yield y{null_yield};
-
- RGWSI_MBSObj_RemoveParams() {}
- RGWSI_MBSObj_RemoveParams(optional_yield _y) : y(_y) {}
};
class RGWSI_MetaBackend_SObj : public RGWSI_MetaBackend
protected:
RGWSI_SysObj *sysobj_svc{nullptr};
- map<string, rgwsi_meta_be_sobj_handler_info> handlers;
-
- int init_handler(RGWMetadataHandler *handler, RGWSI_MetaBackend_Handle *phandle) override;
-
public:
struct Context_SObj : public RGWSI_MetaBackend::Context {
- std::optional<RGWSysObjectCtx> _obj_ctx;
- RGWSysObjectCtx *obj_ctx{nullptr};
- rgw_pool pool;
- string oid;
+ RGWSI_SysObj *sysobj_svc{nullptr};
- std::unique_ptr<Context_SObj> _ctx2;
+ RGWSI_MBSObj_Handler_Module *module{nullptr};
+ optional<RGWSysObjectCtx> obj_ctx;
- Context_SObj& operator=(const Context_SObj& rhs) {
- _obj_ctx.reset();
- obj_ctx = rhs.obj_ctx;
- pool = rhs.pool;
- oid = rhs.oid;
- _ctx2.reset(); /* this isn't carried over */
- return *this;
- }
+ Context_SObj(RGWSI_SysObj *_sysobj_svc) : sysobj_svc(_sysobj_svc) {}
- void set_key(const string& key) override;
-
- Context_SObj *clone(const string& key);
+ void init(RGWSI_MetaBackend_Handler *h) override;
};
RGWSI_MetaBackend_SObj(CephContext *cct);
sysobj_svc = _sysobj_svc;
}
- void init_ctx(RGWSI_MetaBackend_Handle handle, RGWSI_MetaBackend::Context *ctx) override;
+ RGWSI_MetaBackend_Handler *alloc_be_handler() override;
RGWSI_MetaBackend::GetParams *alloc_default_get_params(ceph::real_time *pmtime) override;
int get_entry(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
RGWSI_MetaBackend::GetParams& params,
RGWObjVersionTracker *objv_tracker) override;
int put_entry(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
RGWSI_MetaBackend::PutParams& params,
RGWObjVersionTracker *objv_tracker) override;
int remove_entry(RGWSI_MetaBackend::Context *ctx,
+ const string& key,
RGWSI_MetaBackend::RemoveParams& params,
RGWObjVersionTracker *objv_tracker) override;
+
+ int call(std::function<int(RGWSI_MetaBackend::Context *)> f) override;
};
+class RGWSI_MetaBackend_Handler_SObj : public RGWSI_MetaBackend_Handler {
+ friend class RGWSI_MetaBackend_SObj::Context_SObj;
+
+ RGWSI_MBSObj_Handler_Module *module{nullptr};
+
+public:
+ RGWSI_MetaBackend_Handler_SObj(RGWSI_MetaBackend *be) :
+ RGWSI_MetaBackend_Handler(be) {}
+
+ void set_module(RGWSI_MBSObj_Handler_Module *_module) {
+ module = _module;
+ }
+
+ RGWSI_MBSObj_Handler_Module *get_module() {
+ return module;
+ }
+};
#include "svc_sys_obj.h"
#include "svc_sys_obj_cache.h"
#include "svc_meta.h"
+#include "svc_meta_be_sobj.h"
#include "svc_sync_modules.h"
#include "rgw/rgw_user.h"
#define dout_subsys ceph_subsys_rgw
+class RGWSI_User_Module : public RGWSI_MBSObj_Handler_Module {
+ RGWSI_User::Svc& svc;
+public:
+ RGWSI_User_Module(RGWSI_User::Svc& _svc) : svc(_svc) {}
+
+ void get_pool_and_oid(const string& key, rgw_pool *pool, string *oid) override {
+ *oid = key;
+ *pool = svc.zone->get_zone_params().user_uid_pool;
+ }
+};
+
RGWSI_User::RGWSI_User(CephContext *cct): RGWServiceInstance(cct) {
}
{
uinfo_cache.reset(new RGWChainedCacheImpl<user_info_cache_entry>);
uinfo_cache->init(svc.cache);
+
+ int r = svc.meta->create_be_handler(RGWSI_MetaBackend::Type::MDBE_SOBJ, &be_handler);
+ if (r < 0) {
+ ldout(ctx(), 0) << "ERROR: failed to create be handler: r=" << r << dendl;
+ return r;
+ }
+
+ RGWSI_MetaBackend_Handler_SObj *bh = static_cast<RGWSI_MetaBackend_Handler_SObj *>(be_handler);
+
+ auto module = new RGWSI_User_Module(svc);
+ be_module.reset(module);
+ bh->set_module(module);
return 0;
}
int RGWSI_User::read_user_info(RGWSI_MetaBackend::Context *ctx,
+ const rgw_user& user,
RGWUserInfo *info,
RGWObjVersionTracker * const objv_tracker,
real_time * const pmtime,
RGWSI_MBSObj_GetParams params(&bl, pattrs, pmtime);
- int ret = svc.meta_be->get_entry(ctx, params, objv_tracker, y);
+ int ret = svc.meta_be->get_entry(ctx, get_meta_key(user), params, objv_tracker, y);
if (ret < 0) {
return ret;
}
auto iter = bl.cbegin();
try {
decode(user_id, iter);
- auto meta_key = get_meta_key(user_id.user_id);
- if (meta_key != ctx->key) {
- lderr(svc.meta_be->ctx()) << "ERROR: rgw_get_user_info_by_uid(): user id mismatch: " << meta_key << " != " << ctx->key << dendl;
+ if (user_id.user_id != user) {
+ lderr(svc.meta_be->ctx()) << "ERROR: rgw_get_user_info_by_uid(): user id mismatch: " << user_id.user_id << " != " << user << dendl;
return -EIO;
}
if (!iter.end()) {
RGWSI_MBSObj_PutParams params(data_bl, pattrs, mtime, exclusive);
- int ret = svc.meta_be->put_entry(ctx, params, &ot);
+ int ret = svc.meta_be->put_entry(ctx, RGWSI_User::get_meta_key(info.user_id), params, &ot);
if (ret < 0)
return ret;
{
ldout(cct, 10) << "removing user index: " << user_info.user_id << dendl;
- RGWSI_MBSObj_RemoveParams params;
+ RGWSI_MBSObj_RemoveParams params(y);
#warning need mtime?
#if 0
params.mtime = user_info.mtime;
#endif
- int ret = svc.meta_be->remove_entry(ctx, params, objv_tracker, y);
+ int ret = svc.meta_be->remove_entry(ctx, get_meta_key(user_info.user_id), params, objv_tracker);
if (ret < 0 && ret != -ENOENT && ret != -ECANCELED) {
string key;
user_info.user_id.to_str(key);
try {
decode(uid, iter);
- int ret = read_user_info(ctx->clone(get_meta_key(uid.user_id)),
+ int ret = read_user_info(ctx, uid.user_id,
&e.info, &e.objv_tracker, nullptr, &cache_info, nullptr, y);
if (ret < 0) {
return ret;
class RGWSI_SysObj_Cache;
class RGWSI_Meta;
class RGWSI_SyncModules;
-class RGWMetadataHandler;
+class RGWSI_MetaBackend_Handler;
struct rgw_cache_entry_info;
template <class T>
class RGWChainedCacheImpl;
+/* FIXME:
+ * split RGWSI_User to base class and RGWSI_User_SObj
+ */
+
class RGWSI_User : public RGWServiceInstance
{
friend class User;
friend class PutOperation;
- RGWMetadataHandler *user_meta_handler;
+ std::unique_ptr<RGWSI_MetaBackend::Module> be_module;
+
+ RGWSI_MetaBackend_Handler *be_handler;
struct user_info_cache_entry {
RGWUserInfo info;
RGWSI_MetaBackend *_meta_be_svc,
RGWSI_SyncModules *_sync_modules);
+ RGWSI_MetaBackend_Handler *get_be_handler() {
+ return be_handler;
+ }
+
static string get_meta_key(const rgw_user& user) {
return user.to_str();
}
- static string get_buckets_oid(const rgw_user& user_id) {
-#define RGW_BUCKETS_OID_SUFFIX ".buckets"
- return user_id.to_str() + RGW_BUCKETS_OID_SUFFIX;
+ static rgw_user user_from_meta_key(const string& key) {
+ return rgw_user(key);
}
/* base svc_user interfaces */
int read_user_info(RGWSI_MetaBackend::Context *ctx,
+ const rgw_user& user,
RGWUserInfo *info,
RGWObjVersionTracker * const objv_tracker,
real_time * const pmtime,
projects / ceph-ci.git / commitdiff