} else {
from_index = op.marker;
}
- bool use_time_boundary = (!op.from_time.is_zero() && !op.to_time.is_zero() && (op.to_time >= op.from_time));
+ bool use_time_boundary = (!op.from_time.is_zero() && (op.to_time >= op.from_time));
if (use_time_boundary)
get_index_time_prefix(op.to_time, to_index);
int RGWDataChangesLog::trim_entries(int shard_id, utime_t& start_time, utime_t& end_time)
{
- int ret = store->time_log_trim(oids[shard_id], start_time, end_time);
- if ((ret < 0) && (ret != -ENOENT))
- return ret;
+ int ret;
- return 0;
+ ret = store->time_log_trim(oids[shard_id], start_time, end_time);
+
+ if (ret == -ENOENT)
+ ret = 0;
+
+ return ret;
}
int RGWDataChangesLog::trim_entries(utime_t& start_time, utime_t& end_time)
int trim_entries(int shard_id, utime_t& start_time, utime_t& end_time);
int trim_entries(utime_t& start_time, utime_t& end_time);
int lock_exclusive(int shard_id, utime_t& duration, string& owner_id) {
- return store->log_lock_exclusive(oids[shard_id], duration, owner_id);
+ return store->lock_exclusive(store->zone.log_pool, oids[shard_id], duration, owner_id);
}
int unlock(int shard_id, string& owner_id) {
- return store->log_unlock(oids[shard_id], owner_id);
+ return store->unlock(store->zone.log_pool, oids[shard_id], owner_id);
}
struct LogMarker {
int shard;
if (ret == -ENOENT)
ret = 0;
- if (ret < 0)
- return ret;
-
- return 0;
+ return ret;
}
int RGWMetadataLog::lock_exclusive(int shard_id, utime_t& duration, string& owner_id) {
string oid;
get_shard_oid(shard_id, oid);
- return store->log_lock_exclusive(oid, duration, owner_id);
+ return store->lock_exclusive(store->zone.log_pool, oid, duration, owner_id);
}
int RGWMetadataLog::unlock(int shard_id, string& owner_id) {
string oid;
get_shard_oid(shard_id, oid);
- return store->log_unlock(oid, owner_id);
+ return store->unlock(store->zone.log_pool, oid, owner_id);
}
obj_version& RGWMetadataObject::get_version()
return handler->remove(store, entry, objv_tracker);
}
+int RGWMetadataManager::lock_exclusive(string& metadata_key, utime_t duration, string& owner_id) {
+ RGWMetadataHandler *handler;
+ string entry;
+
+ int ret = find_handler(metadata_key, &handler, entry);
+ if (ret < 0)
+ return ret;
+
+ rgw_bucket pool;
+ string oid;
+
+ handler->get_pool_and_oid(store, entry, pool, oid);
+
+ return store->lock_exclusive(pool, oid, duration, owner_id);
+}
+
+int RGWMetadataManager::unlock(string& metadata_key, string& owner_id) {
+ librados::IoCtx io_ctx;
+ RGWMetadataHandler *handler;
+ string entry;
+
+ int ret = find_handler(metadata_key, &handler, entry);
+ if (ret < 0)
+ return ret;
+
+ rgw_bucket pool;
+ string oid;
+
+ handler->get_pool_and_oid(store, entry, pool, oid);
+
+ return store->unlock(pool, oid, owner_id);
+}
struct list_keys_handle {
void *handle;
void dump_log_entry(cls_log_entry& entry, Formatter *f);
void get_sections(list<string>& sections);
+ int lock_exclusive(string& metadata_key, utime_t duration, string& owner_id);
+ int unlock(string& metadata_key, string& owner_id);
RGWMetadataLog *get_log() { return md_log; }
};
static string default_region_info_oid = "default.region";
static string region_map_oid = "region_map";
-static string rgw_log_lock_name = "rgw_process";
static RGWObjCategory main_category = RGW_OBJ_CATEGORY_MAIN;
return cls_log_trim(io_ctx, oid, start_time, end_time);
}
-int RGWRados::log_lock_exclusive(const string& oid, utime_t& duration, string& owner_id) {
+
+int RGWRados::lock_exclusive(rgw_bucket& pool, const string& oid, utime_t& duration, string& owner_id) {
librados::IoCtx io_ctx;
- const char *log_pool = zone.log_pool.name.c_str();
- int r = rados->ioctx_create(log_pool, io_ctx);
+ const char *pool_name = pool.name.c_str();
+
+ int r = rados->ioctx_create(pool_name, io_ctx);
if (r < 0)
return r;
- rados::cls::lock::Lock l(rgw_log_lock_name);
+
+ string lock_name = RGW_INDEX_LOCK_NAME;
+ rados::cls::lock::Lock l(lock_name);
l.set_duration(duration);
l.set_cookie(owner_id);
+
return l.lock_exclusive(&io_ctx, oid);
}
-int RGWRados::log_unlock(const string& oid, string& owner_id) {
+int RGWRados::unlock(rgw_bucket& pool, const string& oid, string& owner_id) {
librados::IoCtx io_ctx;
- const char *log_pool = zone.log_pool.name.c_str();
- int r = rados->ioctx_create(log_pool, io_ctx);
+ const char *pool_name = pool.name.c_str();
+
+ int r = rados->ioctx_create(pool_name, io_ctx);
if (r < 0)
return r;
- rados::cls::lock::Lock l(rgw_log_lock_name);
+
+ string lock_name = RGW_INDEX_LOCK_NAME;
+ rados::cls::lock::Lock l(lock_name);
l.set_cookie(owner_id);
+
return l.unlock(&io_ctx, oid);
}
#define RGW_OBJ_NS_MULTIPART "multipart"
#define RGW_OBJ_NS_SHADOW "shadow"
+#define RGW_INDEX_LOCK_NAME "rgw_process"
static inline void prepend_bucket_marker(rgw_bucket& bucket, string& orig_oid, string& oid)
{
int time_log_list(const string& oid, utime_t& start_time, utime_t& end_time,
int max_entries, list<cls_log_entry>& entries, string& marker, bool *truncated);
int time_log_trim(const string& oid, utime_t& start_time, utime_t& end_time);
- int log_lock_exclusive(const string& oid, utime_t& duration, string& owner_id);
- int log_unlock(const string& oid, string& owner_id);
+ int lock_exclusive(rgw_bucket& pool, const string& oid, utime_t& duration, string& owner_id);
+ int unlock(rgw_bucket& pool, const string& oid, string& owner_id);
/// clean up/process any temporary objects older than given date[/time]
int remove_temp_objects(string date, string time);
http_ret = meta_log->trim(shard_id, ut_st, ut_et);
}
-int RGWOp_MDLog_Post::check_caps(RGWUserCaps& caps) {
- if (caps.check_cap("mdlog", RGW_CAP_READ) &&
- caps.check_cap("mdlog", RGW_CAP_WRITE)) {
- return -EPERM;
+void RGWOp_MDLog_Lock::execute() {
+ string shard_id_str, duration_str, lock_id;
+ int shard_id;
+
+ http_ret = 0;
+
+ shard_id_str = s->info.args.get("id");
+ duration_str = s->info.args.get("length");
+ lock_id = s->info.args.get("lock_id");
+
+ if (shard_id_str.empty() ||
+ (duration_str.empty()) ||
+ lock_id.empty()) {
+ dout(5) << "Error invalid parameter list" << dendl;
+ http_ret = -EINVAL;
+ return;
}
- return 0;
-}
-const char *RGWOp_MDLog_Post::name() {
- int pt = get_post_type();
- if (pt == MDLOG_POST_LOCK)
- return "lock mdlog object";
- else if (pt == MDLOG_POST_UNLOCK)
- return "unlock mdlog object";
- return NULL;
+ string err;
+ shard_id = strict_strtol(shard_id_str.c_str(), 10, &err);
+ if (!err.empty()) {
+ dout(5) << "Error parsing shard_id param " << shard_id_str << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+
+ RGWMetadataLog *meta_log = store->meta_mgr->get_log();
+ int dur;
+ dur = strict_strtol(duration_str.c_str(), 10, &err);
+ if (!err.empty() || dur <= 0) {
+ dout(5) << "invalid length param " << duration_str << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+ utime_t time(dur, 0);
+ http_ret = meta_log->lock_exclusive(shard_id, time, lock_id);
}
-void RGWOp_MDLog_Post::execute() {
- string shard_id_str, duration_str, lock_id;
+void RGWOp_MDLog_Unlock::execute() {
+ string shard_id_str, lock_id;
int shard_id;
- int pt = get_post_type();
http_ret = 0;
shard_id_str = s->info.args.get("id");
- if (pt == MDLOG_POST_LOCK)
- duration_str = s->info.args.get("length");
lock_id = s->info.args.get("lock_id");
if (shard_id_str.empty() ||
- (pt == MDLOG_POST_LOCK && duration_str.empty()) ||
lock_id.empty()) {
dout(5) << "Error invalid parameter list" << dendl;
http_ret = -EINVAL;
}
RGWMetadataLog *meta_log = store->meta_mgr->get_log();
- if (pt == MDLOG_POST_LOCK) {
- int dur;
- dur = strict_strtol(duration_str.c_str(), 10, &err);
- if (!err.empty() || dur <= 0) {
- dout(5) << "invalid length param " << duration_str << dendl;
- http_ret = -EINVAL;
- return;
- }
- utime_t time(dur, 0);
- http_ret = meta_log->lock_exclusive(shard_id, time, lock_id);
- } else if (pt == MDLOG_POST_UNLOCK) {
- http_ret = meta_log->unlock(shard_id, lock_id);
- } else
- http_ret = -EINVAL;
+ http_ret = meta_log->unlock(shard_id, lock_id);
}
void RGWOp_BILog_List::execute() {
}
void RGWOp_DATALog_List::execute() {
- string shard = s->args.get("id");
+ string shard = s->info.args.get("id");
- string st = s->args.get("start-time"),
- et = s->args.get("end-time"),
+ string st = s->info.args.get("start-time"),
+ et = s->info.args.get("end-time"),
err;
utime_t ut_st,
ut_et;
flusher.flush();
}
-int RGWOp_DATALog_Post::check_caps(RGWUserCaps& caps) {
- if (caps.check_cap("datalog", RGW_CAP_READ) &&
- caps.check_cap("datalog", RGW_CAP_WRITE)) {
- return -EPERM;
+void RGWOp_DATALog_Lock::execute() {
+ string shard_id_str, duration_str, lock_id;
+ int shard_id;
+
+ http_ret = 0;
+
+ shard_id_str = s->info.args.get("id");
+ duration_str = s->info.args.get("length");
+ lock_id = s->info.args.get("lock_id");
+
+ if (shard_id_str.empty() ||
+ (duration_str.empty()) ||
+ lock_id.empty()) {
+ dout(5) << "Error invalid parameter list" << dendl;
+ http_ret = -EINVAL;
+ return;
}
- return 0;
-}
-const char *RGWOp_DATALog_Post::name() {
- int pt = get_post_type();
- if (pt == DATALOG_POST_LOCK)
- return "lock datalog object";
- else if (pt == DATALOG_POST_UNLOCK)
- return "unlock datalog object";
- return NULL;
+ string err;
+ shard_id = strict_strtol(shard_id_str.c_str(), 10, &err);
+ if (!err.empty()) {
+ dout(5) << "Error parsing shard_id param " << shard_id_str << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+
+ int dur;
+ dur = strict_strtol(duration_str.c_str(), 10, &err);
+ if (!err.empty() || dur <= 0) {
+ dout(5) << "invalid length param " << duration_str << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+ utime_t time(dur, 0);
+ http_ret = store->data_log->lock_exclusive(shard_id, time, lock_id);
}
-void RGWOp_DATALog_Post::execute() {
- string shard_id_str, duration_str, lock_id;
+void RGWOp_DATALog_Unlock::execute() {
+ string shard_id_str, lock_id;
int shard_id;
- int pt = get_post_type();
http_ret = 0;
- shard_id_str = s->args.get("id");
- if (pt == DATALOG_POST_LOCK)
- duration_str = s->args.get("length");
- lock_id = s->args.get("lock_id");
+ shard_id_str = s->info.args.get("id");
+ lock_id = s->info.args.get("lock_id");
if (shard_id_str.empty() ||
- (pt == DATALOG_POST_LOCK && duration_str.empty()) ||
lock_id.empty()) {
dout(5) << "Error invalid parameter list" << dendl;
http_ret = -EINVAL;
return;
}
- if (pt == DATALOG_POST_LOCK) {
- int dur;
- dur = strict_strtol(duration_str.c_str(), 10, &err);
- if (!err.empty() || dur <= 0) {
- dout(5) << "invalid length param " << duration_str << dendl;
- http_ret = -EINVAL;
- return;
- }
- utime_t time(dur, 0);
- http_ret = store->data_log->lock_exclusive(shard_id, time, lock_id);
- } else if (pt == DATALOG_POST_UNLOCK) {
- http_ret = store->data_log->unlock(shard_id, lock_id);
- } else
- http_ret = -EINVAL;
+ http_ret = store->data_log->unlock(shard_id, lock_id);
}
void RGWOp_DATALog_Delete::execute() {
- string st = s->args.get("start-time"),
- et = s->args.get("end-time"),
- shard = s->args.get("id"),
+ string st = s->info.args.get("start-time"),
+ et = s->info.args.get("end-time"),
+ shard = s->info.args.get("id"),
err;
utime_t ut_st,
ut_et;
} else if (type.compare("bucket-index") == 0) {
return new RGWOp_BILog_List;
} else if (type.compare("data") == 0) {
- if (s->args.exists("id")) {
+ if (s->info.args.exists("id")) {
return new RGWOp_DATALog_List;
} else {
return new RGWOp_DATALog_GetShardsInfo;
return NULL;
}
- if (type.compare("metadata") == 0)
- return new RGWOp_MDLog_Post;
- else if (type.compare("data") == 0)
- return new RGWOp_DATALog_Post;
+ if (type.compare("metadata") == 0) {
+ if (s->info.args.exists("lock"))
+ return new RGWOp_MDLog_Lock;
+ else if (s->info.args.exists("unlock"))
+ return new RGWOp_MDLog_Unlock;
+ } else if (type.compare("data") == 0) {
+ if (s->info.args.exists("lock"))
+ return new RGWOp_DATALog_Lock;
+ else if (s->info.args.exists("unlock"))
+ return new RGWOp_DATALog_Unlock;
+ }
return NULL;
}
}
};
-class RGWOp_MDLog_Post : public RGWRESTOp {
- enum {
- MDLOG_POST_INVALID = 0,
- MDLOG_POST_LOCK,
- MDLOG_POST_UNLOCK
- };
- int get_post_type() {
- bool exists;
- s->info.args.get("lock", &exists);
- if (exists)
- return MDLOG_POST_LOCK;
- s->info.args.get("unlock", &exists);
- if (exists)
- return MDLOG_POST_UNLOCK;
- return MDLOG_POST_INVALID;
+class RGWOp_MDLog_Lock : public RGWRESTOp {
+public:
+ RGWOp_MDLog_Lock() {}
+ ~RGWOp_MDLog_Lock() {}
+
+ int check_caps(RGWUserCaps& caps) {
+ return caps.check_cap("mdlog", RGW_CAP_WRITE);
+ }
+ void execute();
+ virtual const char *name() {
+ return "lock_mdlog_object";
}
+};
+
+class RGWOp_MDLog_Unlock : public RGWRESTOp {
public:
- RGWOp_MDLog_Post() {}
- ~RGWOp_MDLog_Post() {}
+ RGWOp_MDLog_Unlock() {}
+ ~RGWOp_MDLog_Unlock() {}
- int check_caps(RGWUserCaps& caps);
+ int check_caps(RGWUserCaps& caps) {
+ return caps.check_cap("mdlog", RGW_CAP_WRITE);
+ }
void execute();
- virtual const char *name();
+ virtual const char *name() {
+ return "unlock_mdlog_object";
+ }
};
class RGWOp_MDLog_Delete : public RGWRESTOp {
}
};
-class RGWOp_DATALog_Post : public RGWRESTOp {
- enum {
- DATALOG_POST_INVALID = 0,
- DATALOG_POST_LOCK,
- DATALOG_POST_UNLOCK
- };
- int get_post_type() {
- bool exists;
- s->args.get("lock", &exists);
- if (exists)
- return DATALOG_POST_LOCK;
- s->args.get("unlock", &exists);
- if (exists)
- return DATALOG_POST_UNLOCK;
- return DATALOG_POST_INVALID;
+class RGWOp_DATALog_Lock : public RGWRESTOp {
+public:
+ RGWOp_DATALog_Lock() {}
+ ~RGWOp_DATALog_Lock() {}
+
+ int check_caps(RGWUserCaps& caps) {
+ return caps.check_cap("datalog", RGW_CAP_WRITE);
+ }
+ void execute();
+ virtual const char *name() {
+ return "lock_datalog_object";
}
+};
+
+class RGWOp_DATALog_Unlock : public RGWRESTOp {
public:
- RGWOp_DATALog_Post() {}
- ~RGWOp_DATALog_Post() {}
+ RGWOp_DATALog_Unlock() {}
+ ~RGWOp_DATALog_Unlock() {}
- int check_caps(RGWUserCaps& caps);
+ int check_caps(RGWUserCaps& caps) {
+ return caps.check_cap("datalog", RGW_CAP_WRITE);
+ }
void execute();
- virtual const char *name();
+ virtual const char *name() {
+ return "unlock_datalog_object";
+ }
};
class RGWOp_DATALog_Delete : public RGWRESTOp {
#include "rgw_rest_metadata.h"
#include "rgw_client_io.h"
#include "common/errno.h"
-#define dout_subsys ceph_subsys_rgw
+#include "common/strtol.h"
+#define dout_subsys ceph_subsys_rgw
const char *RGWOp_Metadata_Get::name() {
return "get_metadata";
http_ret = 0;
}
+void RGWOp_Metadata_Lock::execute() {
+ string duration_str, lock_id;
+ string metadata_key;
+
+ frame_metadata_key(s, metadata_key);
+
+ http_ret = 0;
+
+ duration_str = s->info.args.get("length");
+ lock_id = s->info.args.get("lock_id");
+
+ if ((!s->info.args.exists("key")) ||
+ (duration_str.empty()) ||
+ lock_id.empty()) {
+ dout(5) << "Error invalid parameter list" << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+
+ int dur;
+ string err;
+
+ dur = strict_strtol(duration_str.c_str(), 10, &err);
+ if (!err.empty() || dur <= 0) {
+ dout(5) << "invalid length param " << duration_str << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+ utime_t time(dur, 0);
+ http_ret = store->meta_mgr->lock_exclusive(metadata_key, time, lock_id);
+}
+
+void RGWOp_Metadata_Unlock::execute() {
+ string lock_id;
+ string metadata_key;
+
+ frame_metadata_key(s, metadata_key);
+
+ http_ret = 0;
+
+ lock_id = s->info.args.get("lock_id");
+
+ if ((!s->info.args.exists("key")) ||
+ lock_id.empty()) {
+ dout(5) << "Error invalid parameter list" << dendl;
+ http_ret = -EINVAL;
+ return;
+ }
+
+ http_ret = store->meta_mgr->unlock(metadata_key, lock_id);
+}
+
RGWOp *RGWHandler_Metadata::op_get() {
if (s->info.args.exists("key"))
return new RGWOp_Metadata_Get;
RGWOp *RGWHandler_Metadata::op_delete() {
return new RGWOp_Metadata_Delete;
}
+
+RGWOp *RGWHandler_Metadata::op_post() {
+ if (s->info.args.exists("lock"))
+ return new RGWOp_Metadata_Lock;
+ else if (s->info.args.exists("unlock"))
+ return new RGWOp_Metadata_Unlock;
+
+ return NULL;
+}
+
virtual const char *name() { return "remove_metadata"; }
};
+class RGWOp_Metadata_Lock : public RGWRESTOp {
+public:
+ RGWOp_Metadata_Lock() {}
+ ~RGWOp_Metadata_Lock() {}
+
+ int check_caps(RGWUserCaps& caps) {
+ return caps.check_cap("metadata", RGW_CAP_WRITE);
+ }
+ void execute();
+ virtual const char *name() {
+ return "lock_metadata_object";
+ }
+};
+
+class RGWOp_Metadata_Unlock : public RGWRESTOp {
+public:
+ RGWOp_Metadata_Unlock() {}
+ ~RGWOp_Metadata_Unlock() {}
+
+ int check_caps(RGWUserCaps& caps) {
+ return caps.check_cap("metadata", RGW_CAP_WRITE);
+ }
+ void execute();
+ virtual const char *name() {
+ return "unlock_metadata_object";
+ }
+};
+
class RGWHandler_Metadata : public RGWHandler_Auth_S3 {
protected:
RGWOp *op_get();
RGWOp *op_put();
RGWOp *op_delete();
+ RGWOp *op_post();
int read_permissions(RGWOp*) {
return 0;
EXPECT_EQ (parse_json_resp(parser), 0);
JSONDecoder::decode_json("num_objects", num_objects, (JSONObj *)&parser);
ASSERT_EQ(num_objects,g_ceph_context->_conf->rgw_data_log_num_shards);
-
+
+ sleep(1);
ASSERT_EQ(0, create_bucket());
char *bucket_obj = (char *)malloc(TEST_BUCKET_OBJECT_SIZE);
ASSERT_TRUE(bucket_obj != NULL);
EXPECT_EQ(put_bucket_obj(TEST_BUCKET_OBJECT, bucket_obj, TEST_BUCKET_OBJECT_SIZE), 0);
free(bucket_obj);
-
+ sleep(1);
ss << "/admin/log?type=data&id=" << shard_id << "&start-time=" << start_time;
rest_req = ss.str();
g_test->send_request(string("GET"), rest_req);
EXPECT_EQ(entry.entity_type, ENTITY_TYPE_BUCKET);
EXPECT_EQ(entry.key.compare(TEST_BUCKET_NAME), 0);
}
-
ASSERT_EQ(0, delete_obj(TEST_BUCKET_OBJECT));
sleep(1);
ASSERT_EQ(get_formatted_time(end_time), 0);
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=data&lock&id=1&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
- EXPECT_EQ(200U, g_test->get_resp_code());
+ EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/log?type=data&unlock&id=1&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
- EXPECT_EQ(200U, g_test->get_resp_code());
+ EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "write";
ASSERT_EQ(0, caps_add(cname, perm));
rest_req = "/admin/log?type=metadata&lock&id=1&length=3&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
- EXPECT_EQ(200U, g_test->get_resp_code());
+ EXPECT_EQ(403U, g_test->get_resp_code());
rest_req = "/admin/log?type=metadata&unlock&id=1&lock_id=ceph";
g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
- EXPECT_EQ(200U, g_test->get_resp_code());
+ EXPECT_EQ(403U, g_test->get_resp_code());
ASSERT_EQ(0, caps_rm(cname, perm));
perm = "write";
#define HTTP_RESPONSE_STR "RespCode"
#define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
#define RGW_ADMIN_RESP_PATH "/tmp/.test_rgw_admin_resp"
+#define CEPH_UID "ceph"
-static string uid = "ceph";
+static string uid = CEPH_UID;
static string display_name = "CEPH";
static string meta_caps = "metadata";
resp = data;
free(data);
unlink(RGW_ADMIN_RESP_PATH);
- /* cout << "radosgw-admin " << cmd << ": " << resp << std::endl; */
+ /* cout << "radosgw-admin " << cmd << ": " << resp << std::endl;*/
}
} else
return -1;
return 0;
}
+size_t read_dummy_post(void *ptr, size_t s, size_t n, void *ud) {
+ int dummy = 0;
+ memcpy(ptr, &dummy, sizeof(dummy));
+ return sizeof(dummy);
+}
+
+
int parse_json_resp(JSONParser &parser) {
string *resp;
resp = (string *)g_test->get_response_data();
ASSERT_EQ(0, user_rm(uid, display_name));
}
+TEST(TestRGWAdmin, meta_lock_unlock) {
+ const char *perm = "*";
+ string rest_req;
+
+ ASSERT_EQ(0, user_create(uid, display_name));
+ ASSERT_EQ(0, meta_caps_add(perm));
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
+
+ rest_req = "/admin/metadata/user?lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
+
+ rest_req = "/admin/metadata/user?unlock&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph1";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock&lock_id=ceph1";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+ utime_t sleep_time(3, 0);
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph1";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(500U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(409U, g_test->get_resp_code());
+ sleep_time.sleep();
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph1";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock&lock_id=ceph1";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ ASSERT_EQ(0, meta_caps_rm(perm));
+ perm = "read";
+ ASSERT_EQ(0, meta_caps_add(perm));
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(403U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(403U, g_test->get_resp_code());
+
+ ASSERT_EQ(0, meta_caps_rm(perm));
+ perm = "write";
+ ASSERT_EQ(0, meta_caps_add(perm));
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(200U, g_test->get_resp_code());
+
+ ASSERT_EQ(0, meta_caps_rm(perm));
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&lock&length=3&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(403U, g_test->get_resp_code());
+
+ rest_req = "/admin/metadata/user?key="CEPH_UID"&unlock&lock_id=ceph";
+ g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
+ EXPECT_EQ(403U, g_test->get_resp_code());
+
+ ASSERT_EQ(0, user_rm(uid, display_name));
+}
+
TEST(TestRGWAdmin, meta_delete){
JSONParser parser;
const char *perm = "*";
projects / ceph.git / commitdiff