RGWBucketAdminOpState bucket_op;
string infile;
string metadata_key;
+ RGWObjVersionTracker objv_tracker;
std::string val;
std::ostringstream errs;
map<std::string, bufferlist>& attrs, RGWObjCategory category, int flags,
map<std::string, bufferlist>* rmattrs, const bufferlist *data,
RGWObjManifest *manifest, const string *ptag, list<string> *remove_objs,
- bool modify_version, obj_version *objv);
+ bool modify_version, RGWObjVersionTracker *objv_tracker);
int put_obj_data(void *ctx, rgw_obj& obj, const char *data,
off_t ofs, size_t len, bool exclusive);
- int get_obj(void *ctx, obj_version *objv, void **handle, rgw_obj& obj, bufferlist& bl, off_t ofs, off_t end);
+ int get_obj(void *ctx, RGWObjVersionTracker *objv_tracker, void **handle, rgw_obj& obj, bufferlist& bl, off_t ofs, off_t end);
- int obj_stat(void *ctx, rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs, bufferlist *first_chunk, obj_version *objv);
+ int obj_stat(void *ctx, rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs,
+ bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker);
int delete_obj(void *ctx, rgw_obj& obj);
};
}
template <class T>
-int RGWCache<T>::get_obj(void *ctx, obj_version *objv, void **handle, rgw_obj& obj, bufferlist& obl, off_t ofs, off_t end)
+int RGWCache<T>::get_obj(void *ctx, RGWObjVersionTracker *objv_tracker, void **handle, rgw_obj& obj, bufferlist& obl, off_t ofs, off_t end)
{
rgw_bucket bucket;
string oid;
normalize_bucket_and_obj(obj.bucket, obj.object, bucket, oid);
if (bucket.name[0] != '.' || ofs != 0)
- return T::get_obj(ctx, objv, handle, obj, obl, ofs, end);
+ return T::get_obj(ctx, objv_tracker, handle, obj, obl, ofs, end);
string name = normal_name(obj.bucket, oid);
i.copy_all(obl);
return bl.length();
}
- int r = T::get_obj(ctx, objv, handle, obj, obl, ofs, end);
+ int r = T::get_obj(ctx, objv_tracker, handle, obj, obl, ofs, end);
if (r < 0) {
if (r == -ENOENT) { // only update ENOENT, we'd rather retry other errors
info.status = r;
map<std::string, bufferlist>& attrs, RGWObjCategory category, int flags,
map<std::string, bufferlist>* rmattrs, const bufferlist *data,
RGWObjManifest *manifest, const string *ptag, list<string> *remove_objs,
- bool modify_version, obj_version *objv)
+ bool modify_version, RGWObjVersionTracker *objv_tracker)
{
rgw_bucket bucket;
string oid;
}
}
int ret = T::put_obj_meta_impl(ctx, obj, size, mtime, attrs, category, flags, rmattrs, data, manifest, ptag, remove_objs,
- modify_version, objv);
+ modify_version, objv_tracker);
if (cacheable) {
string name = normal_name(bucket, oid);
if (ret >= 0) {
template <class T>
int RGWCache<T>::obj_stat(void *ctx, rgw_obj& obj, uint64_t *psize, time_t *pmtime,
uint64_t *pepoch, map<string, bufferlist> *attrs,
- bufferlist *first_chunk, obj_version *objv)
+ bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker)
{
rgw_bucket bucket;
string oid;
normalize_bucket_and_obj(obj.bucket, obj.object, bucket, oid);
if (bucket.name[0] != '.')
- return T::obj_stat(ctx, obj, psize, pmtime, pepoch, attrs, first_chunk, objv);
+ return T::obj_stat(ctx, obj, psize, pmtime, pepoch, attrs, first_chunk, objv_tracker);
string name = normal_name(bucket, oid);
epoch = info.epoch;
goto done;
}
- r = T::obj_stat(ctx, obj, &size, &mtime, &epoch, &info.xattrs, first_chunk, objv);
+ r = T::obj_stat(ctx, obj, &size, &mtime, &epoch, &info.xattrs, first_chunk, objv_tracker);
if (r < 0) {
if (r == -ENOENT) {
info.status = r;
virtual string get_type() { return string(); }
virtual int get(RGWRados *store, string& entry, RGWMetadataObject **obj) { return -ENOTSUP; }
- virtual int put(RGWRados *store, string& entry, obj_version& objv, JSONObj *obj) { return -ENOTSUP; }
+ virtual int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker, JSONObj *obj) { return -ENOTSUP; }
+ virtual int put_obj(RGWRados *store, string& key, bufferlist& bl, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs) { return -ENOTSUP; }
virtual int list_keys_init(RGWRados *store, void **phandle) {
iter_data *data = new iter_data;
return 0;
}
+RGWMetadataHandler *RGWMetadataManager::get_handler(const char *type)
+{
+ map<string, RGWMetadataHandler *>::iterator iter = handlers.find(type);
+ if (iter == handlers.end())
+ return NULL;
+
+ return iter->second;
+}
+
void RGWMetadataManager::parse_metadata_key(const string& metadata_key, string& type, string& entry)
{
int pos = metadata_key.find(':');
}
string meadata_key;
- obj_version objv;
+ RGWObjVersionTracker objv_tracker;
+
+ obj_version *objv = &objv_tracker.write_version;
+
JSONDecoder::decode_json("key", metadata_key, &parser);
- JSONDecoder::decode_json("ver", objv, &parser);
+ JSONDecoder::decode_json("ver", *objv, &parser);
JSONObj *jo = parser.find_obj("data");
if (!jo) {
return -EINVAL;
}
- return handler->put(store, entry, objv, jo);
+ return handler->put(store, entry, objv_tracker, jo);
}
}
+int RGWMetadataManager::put_obj(RGWMetadataHandler *handler, string& key, bufferlist& bl, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs)
+{
+ return handler->put_obj(store, key, bl, exclusive, objv_tracker, pattrs);
+}
+
class RGWRados;
class JSONObj;
+class RGWObjVersionTracker;
struct obj_version;
virtual void dump(Formatter *f) const = 0;
};
+class RGWMetadataManager;
+
class RGWMetadataHandler {
+ friend class RGWMetadataManager;
+
+protected:
+ virtual int put_obj(RGWRados *store, string& key, bufferlist& bl, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs = NULL) = 0;
public:
virtual ~RGWMetadataHandler() {}
virtual string get_type() = 0;
virtual int get(RGWRados *store, string& entry, RGWMetadataObject **obj) = 0;
- virtual int put(RGWRados *store, string& entry, obj_version& objv, JSONObj *obj) = 0;
+ virtual int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker, JSONObj *obj) = 0;
+
virtual int list_keys_init(RGWRados *store, void **phandle) = 0;
virtual int list_keys_next(void *handle, int max, list<string>& keys, bool *truncated) = 0;
int register_handler(RGWMetadataHandler *handler);
+ RGWMetadataHandler *get_handler(const char *type);
+
+ int put_obj(RGWMetadataHandler *handler, string& key, bufferlist& bl, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs = NULL);
int get(string& metadata_key, Formatter *f);
int put(string& metadata_key, bufferlist& bl);
return 0;
}
+
+void RGWObjVersionTracker::prepare_op_for_read(ObjectReadOperation *op)
+{
+ obj_version *check_objv = version_for_check();
+
+ if (check_objv) {
+ cls_version_check(*op, *check_objv, VER_COND_EQ);
+ }
+
+ cls_version_read(*op, &read_version);
+}
+
+void RGWObjVersionTracker::prepare_op_for_write(ObjectWriteOperation *op)
+{
+ obj_version *check_objv = version_for_check();
+ obj_version *modify_version = version_for_write();
+
+ if (check_objv) {
+ cls_version_check(*op, *check_objv, VER_COND_EQ);
+ }
+
+ if (modify_version) {
+ cls_version_set(*op, *modify_version);
+ } else {
+ cls_version_inc(*op);
+ }
+}
+
void RGWObjManifest::append(RGWObjManifest& m)
{
map<uint64_t, RGWObjManifestPart>::iterator iter;
const string *ptag,
list<string> *remove_objs,
bool modify_version,
- obj_version *objv)
+ RGWObjVersionTracker *objv_tracker)
{
rgw_bucket bucket;
std::string oid, key;
return r;
}
- if (modify_version) {
- if (objv) {
- cls_version_set(op, *objv);
- } else {
- cls_version_inc(op);
- }
+ if (objv_tracker) {
+ objv_tracker->prepare_op_for_write(&op);
}
if (data) {
if (r < 0)
goto done_cancel;
+ if (objv_tracker) {
+ objv_tracker->apply_write();
+ }
+
epoch = io_ctx.get_last_version();
r = complete_atomic_overwrite(rctx, state, obj);
tag_bl.append(tag.c_str(), tag.size() + 1);
}
-int RGWRados::get_obj_state(RGWRadosCtx *rctx, rgw_obj& obj, RGWObjState **state, obj_version *objv)
+int RGWRados::get_obj_state(RGWRadosCtx *rctx, rgw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker)
{
RGWObjState *s = rctx->get_state(obj);
ldout(cct, 20) << "get_obj_state: rctx=" << (void *)rctx << " obj=" << obj << " state=" << (void *)s << " s->prefetch_data=" << s->prefetch_data << dendl;
if (s->has_attrs)
return 0;
- int r = obj_stat(rctx, obj, &s->size, &s->mtime, &s->epoch, &s->attrset, (s->prefetch_data ? &s->data : NULL), objv);
+ int r = obj_stat(rctx, obj, &s->size, &s->mtime, &s->epoch, &s->attrset, (s->prefetch_data ? &s->data : NULL), objv_tracker);
if (r == -ENOENT) {
s->exists = false;
s->has_attrs = true;
const char *if_nomatch,
uint64_t *total_size,
uint64_t *obj_size,
- obj_version *objv,
+ RGWObjVersionTracker *objv_tracker,
void **handle,
struct rgw_err *err)
{
rctx = new_ctx;
}
- r = get_obj_state(rctx, obj, &astate, objv);
+ r = get_obj_state(rctx, obj, &astate, objv_tracker);
if (r < 0)
goto done_err;
}
-int RGWRados::get_obj(void *ctx, obj_version *objv, void **handle, rgw_obj& obj,
+int RGWRados::get_obj(void *ctx, RGWObjVersionTracker *objv_tracker, void **handle, rgw_obj& obj,
bufferlist& bl, off_t ofs, off_t end)
{
rgw_bucket bucket;
goto done_ret;
}
- if (objv) {
- cls_version_check(op, *objv, VER_COND_EQ);
+ if (objv_tracker) {
+ objv_tracker->prepare_op_for_read(&op);
}
read_len = len;
}
int RGWRados::obj_stat(void *ctx, rgw_obj& obj, uint64_t *psize, time_t *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs, bufferlist *first_chunk,
- obj_version *objv)
+ RGWObjVersionTracker *objv_tracker)
{
rgw_bucket bucket;
std::string oid, key;
time_t mtime = 0;
ObjectReadOperation op;
- if (objv) {
- cls_version_read(op, objv);
+ if (objv_tracker) {
+ objv_tracker->prepare_op_for_read(&op);
}
op.getxattrs(&attrset, NULL);
op.stat(&size, &mtime, NULL);
prepend_bucket_marker(bucket, obj.key, key);
}
+struct RGWObjVersionTracker {
+ obj_version read_version;
+ obj_version write_version;
+
+ obj_version *version_for_read() {
+ return &read_version;
+ }
+
+ obj_version *version_for_write() {
+ if (write_version.ver == 0)
+ return NULL;
+
+ return &write_version;
+ }
+
+ obj_version *version_for_check() {
+ if (read_version.ver == 0)
+ return NULL;
+
+ return &read_version;
+ }
+
+ void prepare_op_for_read(librados::ObjectReadOperation *op);
+ void prepare_op_for_write(librados::ObjectWriteOperation *op);
+
+ void apply_write() {
+ read_version = write_version;
+ write_version = obj_version();
+ }
+};
+
struct RGWUsageBatch {
map<utime_t, rgw_usage_log_entry> m;
bufferlist data;
bool prefetch_data;
bool keep_tail;
- obj_version objv;
+ RGWObjVersionTracker objv_tracker;
map<string, bufferlist> attrset;
RGWObjState() : is_atomic(false), has_attrs(0), exists(false),
Mutex bucket_id_lock;
uint64_t max_bucket_id;
- int get_obj_state(RGWRadosCtx *rctx, rgw_obj& obj, RGWObjState **state, obj_version *objv);
+ int get_obj_state(RGWRadosCtx *rctx, rgw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker);
int append_atomic_test(RGWRadosCtx *rctx, rgw_obj& obj,
librados::ObjectOperation& op, RGWObjState **state);
int prepare_atomic_for_write_impl(RGWRadosCtx *rctx, rgw_obj& obj,
const string *ptag;
list<string> *remove_objs;
bool modify_version;
- obj_version *objv;
+ RGWObjVersionTracker *objv_tracker;
PutObjMetaExtraParams() : mtime(NULL), rmattrs(NULL),
data(NULL), manifest(NULL), ptag(NULL),
- remove_objs(NULL), modify_version(false), objv(NULL) {}
+ remove_objs(NULL), modify_version(false),
+ objv_tracker(NULL) {}
};
/** Write/overwrite an object to the bucket storage. */
map<std::string, bufferlist>& attrs, RGWObjCategory category, int flags,
map<std::string, bufferlist>* rmattrs, const bufferlist *data,
RGWObjManifest *manifest, const string *ptag, list<string> *remove_objs,
- bool modify_version, obj_version *objv);
+ bool modify_version, RGWObjVersionTracker *objv_tracker);
virtual int put_obj_meta(void *ctx, rgw_obj& obj, uint64_t size,
map<std::string, bufferlist>& attrs, RGWObjCategory category, int flags,
RGWObjCategory category, int flags, PutObjMetaExtraParams& params) {
return put_obj_meta_impl(ctx, obj, size, params.mtime, attrs, category, flags,
params.rmattrs, params.data, params.manifest, params.ptag, params.remove_objs,
- params.modify_version, params.objv);
+ params.modify_version, params.objv_tracker);
}
virtual int put_obj_data(void *ctx, rgw_obj& obj, const char *data,
off_t ofs, bool exclusive, void **handle);
/* note that put_obj doesn't set category on an object, only use it for none user objects */
int put_system_obj(void *ctx, rgw_obj& obj, const char *data, size_t len, bool exclusive,
- time_t *mtime, map<std::string, bufferlist>& attrs, obj_version *objv) {
+ time_t *mtime, map<std::string, bufferlist>& attrs, RGWObjVersionTracker *objv_tracker) {
bufferlist bl;
bl.append(data, len);
int flags = PUT_OBJ_CREATE;
ep.mtime = mtime;
ep.data = &bl;
ep.modify_version = true;
- ep.objv = objv;
+ ep.objv_tracker = objv_tracker;
int ret = put_obj_meta(ctx, obj, len, attrs, RGW_OBJ_CATEGORY_NONE, flags, ep);
return ret;
const char *if_nomatch,
uint64_t *total_size,
uint64_t *obj_size,
- obj_version *objv,
+ RGWObjVersionTracker *objv_tracker,
void **handle,
struct rgw_err *err);
- virtual int get_obj(void *ctx, obj_version *objv, void **handle, rgw_obj& obj,
+ virtual int get_obj(void *ctx, RGWObjVersionTracker *objv_tracker, void **handle, rgw_obj& obj,
bufferlist& bl, off_t ofs, off_t end);
virtual void finish_get_obj(void **handle);
virtual int obj_stat(void *ctx, rgw_obj& obj, uint64_t *psize, time_t *pmtime,
uint64_t *epoch, map<string, bufferlist> *attrs, bufferlist *first_chunk,
- obj_version *objv);
+ RGWObjVersionTracker *objv_tracker);
virtual bool supports_omap() { return true; }
int omap_get_vals(rgw_obj& obj, bufferlist& header, const std::string& marker, uint64_t count, std::map<string, bufferlist>& m);
static map<string, string> ext_mime_map;
int rgw_put_system_obj(RGWRados *rgwstore, rgw_bucket& bucket, string& oid, const char *data, size_t size, bool exclusive,
- obj_version *objv, map<string, bufferlist> *pattrs)
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs)
{
map<string,bufferlist> no_attrs;
if (!pattrs)
rgw_obj obj(bucket, oid);
- int ret = rgwstore->put_system_obj(NULL, obj, data, size, exclusive, NULL, *pattrs, objv);
+ int ret = rgwstore->put_system_obj(NULL, obj, data, size, exclusive, NULL, *pattrs, objv_tracker);
if (ret == -ENOENT) {
ret = rgwstore->create_pool(bucket);
if (ret >= 0)
- ret = rgwstore->put_system_obj(NULL, obj, data, size, exclusive, NULL, *pattrs, objv);
+ ret = rgwstore->put_system_obj(NULL, obj, data, size, exclusive, NULL, *pattrs, objv_tracker);
}
return ret;
}
-int rgw_get_system_obj(RGWRados *rgwstore, void *ctx, rgw_bucket& bucket, string& key, bufferlist& bl, obj_version *objv, map<string, bufferlist> *pattrs)
+int rgw_get_system_obj(RGWRados *rgwstore, void *ctx, rgw_bucket& bucket, string& key, bufferlist& bl,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs)
{
int ret;
struct rgw_err err;
bufferlist::iterator iter;
int request_len = READ_CHUNK_LEN;
rgw_obj obj(bucket, key);
+
do {
ret = rgwstore->prepare_get_obj(ctx, obj, NULL, NULL, pattrs, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL, objv, &handle, &err);
+ NULL, NULL, NULL, NULL, NULL, NULL, objv_tracker, &handle, &err);
if (ret < 0)
return ret;
- ret = rgwstore->get_obj(ctx, objv, &handle, obj, bl, 0, request_len - 1);
+ ret = rgwstore->get_obj(ctx, objv_tracker, &handle, obj, bl, 0, request_len - 1);
+#warning FIXME objv_tracker
rgwstore->finish_get_obj(&handle);
if (ret < 0)
return ret;
#include "rgw_common.h"
class RGWRados;
+class RGWObjVersionTracker;
struct obj_version;
-int rgw_put_system_obj(RGWRados *rgwstore, rgw_bucket& bucket, string& oid, const char *data, size_t size, bool exclusive, obj_version *objv, map<string, bufferlist> *pattrs = NULL);
-int rgw_get_system_obj(RGWRados *rgwstore, void *ctx, rgw_bucket& bucket, string& key, bufferlist& bl, obj_version *objv, map<string, bufferlist> *pattrs = NULL);
+int rgw_put_system_obj(RGWRados *rgwstore, rgw_bucket& bucket, string& oid, const char *data, size_t size, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs = NULL);
+int rgw_get_system_obj(RGWRados *rgwstore, void *ctx, rgw_bucket& bucket, string& key, bufferlist& bl,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs = NULL);
int rgw_tools_init(CephContext *cct);
void rgw_tools_cleanup();
using namespace std;
+static RGWMetadataHandler *user_meta_handler = NULL;
+
+
/**
* Get the anonymous (ie, unauthenticated) user info.
*/
* Save the given user information to storage.
* Returns: 0 on success, -ERR# on failure.
*/
-int rgw_store_user_info(RGWRados *store, RGWUserInfo& info, RGWUserInfo *old_info, obj_version *objv, bool exclusive)
+int rgw_store_user_info(RGWRados *store, RGWUserInfo& info, RGWUserInfo *old_info, RGWObjVersionTracker *objv_tracker, bool exclusive)
{
bufferlist bl;
info.encode(bl);
::encode(ui, data_bl);
::encode(info, data_bl);
- ret = rgw_put_system_obj(store, store->zone.user_uid_pool, info.user_id, data_bl.c_str(), data_bl.length(), exclusive, objv);
+ ret = store->meta_mgr->put_obj(user_meta_handler, info.user_id, data_bl, exclusive, objv_tracker);
if (ret < 0)
return ret;
if (!info.user_email.empty()) {
if (!old_info ||
old_info->user_email.compare(info.user_email) != 0) { /* only if new index changed */
- ret = rgw_put_system_obj(store, store->zone.user_email_pool, info.user_email, link_bl.c_str(), link_bl.length(), exclusive, objv);
+ ret = rgw_put_system_obj(store, store->zone.user_email_pool, info.user_email,
+ link_bl.c_str(), link_bl.length(), exclusive, NULL);
if (ret < 0)
return ret;
}
if (old_info && old_info->access_keys.count(iter->first) != 0)
continue;
- ret = rgw_put_system_obj(store, store->zone.user_keys_pool, k.id, link_bl.c_str(), link_bl.length(), exclusive, objv);
+ ret = rgw_put_system_obj(store, store->zone.user_keys_pool, k.id,
+ link_bl.c_str(), link_bl.length(), exclusive,
+ NULL);
if (ret < 0)
return ret;
}
if (old_info && old_info->swift_keys.count(siter->first) != 0)
continue;
- ret = rgw_put_system_obj(store, store->zone.user_swift_pool, k.id, link_bl.c_str(), link_bl.length(), exclusive, objv);
+ ret = rgw_put_system_obj(store, store->zone.user_swift_pool, k.id,
+ link_bl.c_str(), link_bl.length(), exclusive,
+ NULL);
if (ret < 0)
return ret;
}
return ret;
}
-int rgw_get_user_info_from_index(RGWRados *store, string& key, rgw_bucket& bucket, RGWUserInfo& info)
+int rgw_get_user_info_from_index(RGWRados *store, string& key, rgw_bucket& bucket, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker)
{
bufferlist bl;
RGWUID uid;
bufferlist::iterator iter = bl.begin();
try {
::decode(uid, iter);
- return rgw_get_user_info_by_uid(store, uid.user_id, info);
+ return rgw_get_user_info_by_uid(store, uid.user_id, info, objv_tracker);
} catch (buffer::error& err) {
ldout(store->ctx(), 0) << "ERROR: failed to decode user info, caught buffer::error" << dendl;
return -EIO;
* Given a uid, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-static int rgw_read_uid_info(RGWRados *store, string& uid, RGWUserInfo& info, obj_version *objv)
+int rgw_get_user_info_by_uid(RGWRados *store, string& uid, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker)
{
bufferlist bl;
RGWUID user_id;
- int ret = rgw_get_system_obj(store, NULL, store->zone.user_uid_pool, uid, bl, objv);
+ int ret = rgw_get_system_obj(store, NULL, store->zone.user_uid_pool, uid, bl, objv_tracker);
if (ret < 0)
return ret;
return 0;
}
-int rgw_get_user_info_by_uid(RGWRados *store, string& uid, RGWUserInfo& info)
-{
- return rgw_read_uid_info(store, uid, info, NULL);
-}
-
/**
* Given an email, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info)
+int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker)
{
- return rgw_get_user_info_from_index(store, email, store->zone.user_email_pool, info);
+ return rgw_get_user_info_from_index(store, email, store->zone.user_email_pool, info, objv_tracker);
}
/**
* Given an swift username, finds the user_info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUserInfo& info)
+extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker)
{
- return rgw_get_user_info_from_index(store, swift_name, store->zone.user_swift_pool, info);
+ return rgw_get_user_info_from_index(store, swift_name, store->zone.user_swift_pool, info, objv_tracker);
}
/**
* Given an access key, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key, RGWUserInfo& info)
+extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker)
{
- return rgw_get_user_info_from_index(store, access_key, store->zone.user_keys_pool, info);
+ return rgw_get_user_info_from_index(store, access_key, store->zone.user_keys_pool, info, objv_tracker);
}
int rgw_remove_key_index(RGWRados *store, RGWAccessKey& access_key)
}
if (!uid.empty() && (uid.compare(RGW_USER_ANON_ID) != 0))
- found = (rgw_get_user_info_by_uid(store, uid, user_info) >= 0);
+ found = (rgw_get_user_info_by_uid(store, uid, user_info, &op_state.objv) >= 0);
if (!user_email.empty() && !found)
- found = (rgw_get_user_info_by_email(store, user_email, user_info) >= 0);
+ found = (rgw_get_user_info_by_email(store, user_email, user_info, &op_state.objv) >= 0);
if (!swift_user.empty() && !found)
- found = (rgw_get_user_info_by_swift(store, swift_user, user_info) >= 0);
+ found = (rgw_get_user_info_by_swift(store, swift_user, user_info, &op_state.objv) >= 0);
if (!access_key.empty() && !found)
- found = (rgw_get_user_info_by_access_key(store, access_key, user_info) >= 0);
+ found = (rgw_get_user_info_by_access_key(store, access_key, user_info, &op_state.objv) >= 0);
op_state.set_existing_user(found);
if (found) {
int get(RGWRados *store, string& entry, RGWMetadataObject **obj) {
RGWUserInfo info;
- obj_version objv;
+ RGWObjVersionTracker objv_tracker;
- int ret = rgw_read_uid_info(store, entry, info, &objv);
+ int ret = rgw_get_user_info_by_uid(store, entry, info, &objv_tracker);
if (ret < 0)
return ret;
- RGWUserMetadataObject *mdo = new RGWUserMetadataObject(info, objv);
+ RGWUserMetadataObject *mdo = new RGWUserMetadataObject(info, objv_tracker.read_version);
*obj = mdo;
return 0;
}
- int put(RGWRados *store, string& entry, obj_version& objv, JSONObj *obj) {
+ int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker, JSONObj *obj) {
RGWUserInfo info;
decode_json_obj(info, obj);
RGWUserInfo old_info;
- obj_version old_objv;
- int ret = rgw_read_uid_info(store, entry, old_info, &old_objv);
+ int ret = rgw_get_user_info_by_uid(store, entry, old_info, &objv_tracker);
if (ret < 0)
return ret;
- ret = rgw_store_user_info(store, info, &old_info, &objv, false);
+ ret = rgw_store_user_info(store, info, &old_info, &objv_tracker, false);
if (ret < 0)
return ret;
RGWListRawObjsCtx ctx;
};
+ int put_obj(RGWRados *store, string& key, bufferlist& bl, bool exclusive,
+ RGWObjVersionTracker *objv_tracker, map<string, bufferlist> *pattrs) {
+ return rgw_put_system_obj(store, store->zone.user_uid_pool, key,
+ bl.c_str(), bl.length(), exclusive,
+ objv_tracker, pattrs);
+ }
+
int list_keys_init(RGWRados *store, void **phandle)
{
list_keys_info *info = new list_keys_info;
void rgw_user_init(RGWMetadataManager *mm)
{
- mm->register_handler(new RGWUserMetadataHandler);
+ user_meta_handler = new RGWUserMetadataHandler;
+ mm->register_handler(user_meta_handler);
}
* Save the given user information to storage.
* Returns: 0 on success, -ERR# on failure.
*/
-extern int rgw_store_user_info(RGWRados *store, RGWUserInfo& info, RGWUserInfo *old_info, obj_version *objv, bool exclusive);
+extern int rgw_store_user_info(RGWRados *store, RGWUserInfo& info, RGWUserInfo *old_info, RGWObjVersionTracker *objv_tracker, bool exclusive);
/**
* Given an email, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-extern int rgw_get_user_info_by_uid(RGWRados *store, string& user_id, RGWUserInfo& info);
+extern int rgw_get_user_info_by_uid(RGWRados *store, string& user_id, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker = NULL);
/**
* Given an swift username, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-extern int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info);
+extern int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker = NULL);
/**
* Given an swift username, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUserInfo& info);
+extern int rgw_get_user_info_by_swift(RGWRados *store, string& swift_name, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker = NULL);
/**
* Given an access key, finds the user info associated with it.
* returns: 0 on success, -ERR# on failure (including nonexistence)
*/
-extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key, RGWUserInfo& info);
+extern int rgw_get_user_info_by_access_key(RGWRados *store, string& access_key, RGWUserInfo& info, RGWObjVersionTracker *objv_tracker = NULL);
/**
* Given an RGWUserInfo, deletes the user and its bucket ACLs.
*/
uint32_t max_buckets;
__u8 suspended;
std::string caps;
+ RGWObjVersionTracker objv;
// subuser attributes
std::string subuser;
projects / ceph.git / commitdiff