1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
8 * This is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License version 2.1, as published by the Free Software
11 * Foundation. See file COPYING.
25 #include <curl/curl.h>
27 #include "common/ceph_crypto.h"
28 #include "include/str_list.h"
29 #include "common/ceph_json.h"
30 #include "common/code_environment.h"
31 #include "common/ceph_argparse.h"
32 #include "common/Finisher.h"
33 #include "global/global_init.h"
34 #include "rgw/rgw_common.h"
35 #include "rgw/rgw_rados.h"
38 #include <gtest/gtest.h>
40 #define TEST(x, y) void y()
41 #define ASSERT_EQ(v, s) if(v != s)cout << "Error at " << __LINE__ << "(" << #v << "!= " << #s << "\n"; \
42 else cout << "(" << #v << "==" << #s << ") PASSED\n";
43 #define EXPECT_EQ(v, s) ASSERT_EQ(v, s)
44 #define ASSERT_TRUE(c) if(c)cout << "Error at " << __LINE__ << "(" << #c << ")" << "\n"; \
45 else cout << "(" << #c << ") PASSED\n";
46 #define EXPECT_TRUE(c) ASSERT_TRUE(c)
50 #define CURL_VERBOSE 0
51 #define HTTP_RESPONSE_STR "RespCode"
52 #define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
53 #define RGW_ADMIN_RESP_PATH "/tmp/.test_rgw_admin_resp"
54 #define CEPH_UID "ceph"
56 static string uid = CEPH_UID;
57 static string display_name = "CEPH";
58 static string meta_caps = "metadata";
60 extern "C" int ceph_armor(char *dst, const char *dst_end,
61 const char *src, const char *end);
62 static void print_usage(char *exec){
63 cout << "Usage: " << exec << " <Options>\n";
65 "-g <gw-ip> - The ip address of the gateway\n"
66 "-p <gw-port> - The port number of the gateway\n"
67 "-c <ceph.conf> - Absolute path of ceph config file\n"
68 "-rgw-admin <path/to/radosgw-admin> - radosgw-admin absolute path\n";
71 namespace admin_meta {
77 string rgw_admin_path;
80 map<string, string> response;
81 list<string> extra_hdrs;
85 test_helper() : curl_inst(0), resp_data(NULL), resp_code(0) {
86 curl_global_init(CURL_GLOBAL_ALL);
89 curl_global_cleanup();
91 int send_request(string method, string uri,
92 size_t (*function)(void *,size_t,size_t,void *) = 0,
93 void *ud = 0, size_t length = 0);
94 int extract_input(int argc, char *argv[]);
95 string& get_response(string hdr){
98 void set_extra_header(string hdr){
99 extra_hdrs.push_back(hdr);
101 void set_response(char *val);
102 void set_response_data(char *data, size_t len){
103 if(resp_data) delete resp_data;
104 resp_data = new string(data, len);
106 string& get_rgw_admin_path() {
107 return rgw_admin_path;
109 string& get_ceph_conf_path() {
112 void set_creds(string& c) {
115 const string *get_response_data(){return resp_data;}
116 unsigned get_resp_code(){return resp_code;}
119 int test_helper::extract_input(int argc, char *argv[]){
120 #define ERR_CHECK_NEXT_PARAM(o) \
121 if(((int)loop + 1) >= argc)return -1; \
122 else o = argv[loop+1];
124 for(unsigned loop = 1;loop < (unsigned)argc; loop += 2){
125 if(strcmp(argv[loop], "-g") == 0){
126 ERR_CHECK_NEXT_PARAM(host);
127 }else if(strcmp(argv[loop],"-p") == 0){
128 ERR_CHECK_NEXT_PARAM(port);
129 }else if(strcmp(argv[loop], "-c") == 0){
130 ERR_CHECK_NEXT_PARAM(conf_path);
131 }else if(strcmp(argv[loop], "-rgw-admin") == 0){
132 ERR_CHECK_NEXT_PARAM(rgw_admin_path);
135 if(host.length() <= 0 ||
136 rgw_admin_path.length() <= 0)
141 void test_helper::set_response(char *r){
143 size_t off = sr.find(": ");
144 if(off != string::npos){
145 h.assign(sr, 0, off);
146 v.assign(sr, off + 2, sr.find("\r\n") - (off+2));
148 /*Could be the status code*/
149 if(sr.find("HTTP/") != string::npos){
150 h.assign(HTTP_RESPONSE_STR);
152 v.assign(sr, off + 1, sr.find("\r\n") - (off + 1));
153 resp_code = atoi((v.substr(0, 3)).c_str());
159 size_t write_header(void *ptr, size_t size, size_t nmemb, void *ud){
160 test_helper *h = static_cast<test_helper *>(ud);
161 h->set_response((char *)ptr);
165 size_t write_data(void *ptr, size_t size, size_t nmemb, void *ud){
166 test_helper *h = static_cast<test_helper *>(ud);
167 h->set_response_data((char *)ptr, size*nmemb);
171 static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
175 for (i = 0; i < len; i++) {
176 sprintf(&str[i*2], "%02x", (int)buf[i]);
180 static void calc_hmac_sha1(const char *key, int key_len,
181 const char *msg, int msg_len, char *dest)
182 /* destination should be CEPH_CRYPTO_HMACSHA1_DIGESTSIZE bytes long */
184 ceph::crypto::HMACSHA1 hmac((const unsigned char *)key, key_len);
185 hmac.Update((const unsigned char *)msg, msg_len);
186 hmac.Final((unsigned char *)dest);
188 char hex_str[(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2) + 1];
189 admin_meta::buf_to_hex((unsigned char *)dest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE, hex_str);
192 static int get_s3_auth(string method, string creds, string date, string res, string& out){
193 string aid, secret, auth_hdr;
195 size_t off = creds.find(":");
197 if(off != string::npos){
198 aid.assign(creds, 0, off);
199 secret.assign(creds, off + 1, string::npos);
201 /*sprintf(auth_hdr, "%s\n\n\n%s\n%s", req_type, date, res);*/
202 char hmac_sha1[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
203 char b64[65]; /* 64 is really enough */
204 size_t off = res.find("?");
205 if(off == string::npos)
208 tmp_res.assign(res, 0, off);
209 auth_hdr.append(method + string("\n\n\n") + date + string("\n") + tmp_res);
210 admin_meta::calc_hmac_sha1(secret.c_str(), secret.length(),
211 auth_hdr.c_str(), auth_hdr.length(), hmac_sha1);
212 int ret = ceph_armor(b64, b64 + 64, hmac_sha1,
213 hmac_sha1 + CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
215 cout << "ceph_armor failed\n";
219 out.append(aid + string(":") + b64);
224 void get_date(string& d){
228 char *days[] = {(char *)"Sun", (char *)"Mon", (char *)"Tue",
229 (char *)"Wed", (char *)"Thu", (char *)"Fri",
231 char *months[] = {(char *)"Jan", (char *)"Feb", (char *)"Mar",
232 (char *)"Apr", (char *)"May", (char *)"Jun",
233 (char *)"Jul",(char *) "Aug", (char *)"Sep",
234 (char *)"Oct", (char *)"Nov", (char *)"Dec"};
235 gettimeofday(&tv, NULL);
236 gmtime_r(&tv.tv_sec, &tm);
237 sprintf(date, "%s, %d %s %d %d:%d:%d GMT",
239 tm.tm_mday, months[tm.tm_mon],
241 tm.tm_hour, tm.tm_min, 0 /*tm.tm_sec*/);
245 int test_helper::send_request(string method, string res,
246 size_t (*read_function)( void *,size_t,size_t,void *),
251 url.append(string("http://") + host);
252 if(port.length() > 0)url.append(string(":") + port);
254 curl_inst = curl_easy_init();
256 curl_easy_setopt(curl_inst, CURLOPT_URL, url.c_str());
257 curl_easy_setopt(curl_inst, CURLOPT_CUSTOMREQUEST, method.c_str());
258 curl_easy_setopt(curl_inst, CURLOPT_VERBOSE, CURL_VERBOSE);
259 curl_easy_setopt(curl_inst, CURLOPT_HEADERFUNCTION, admin_meta::write_header);
260 curl_easy_setopt(curl_inst, CURLOPT_WRITEHEADER, (void *)this);
261 curl_easy_setopt(curl_inst, CURLOPT_WRITEFUNCTION, admin_meta::write_data);
262 curl_easy_setopt(curl_inst, CURLOPT_WRITEDATA, (void *)this);
264 curl_easy_setopt(curl_inst, CURLOPT_READFUNCTION, read_function);
265 curl_easy_setopt(curl_inst, CURLOPT_READDATA, (void *)ud);
266 curl_easy_setopt(curl_inst, CURLOPT_UPLOAD, 1L);
267 curl_easy_setopt(curl_inst, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
272 http_date.append(string("Date: ") + date);
275 if (admin_meta::get_s3_auth(method, creds, date, res, s3auth) < 0)
277 auth.append(string("Authorization: AWS ") + s3auth);
279 struct curl_slist *slist = NULL;
280 slist = curl_slist_append(slist, auth.c_str());
281 slist = curl_slist_append(slist, http_date.c_str());
282 for(list<string>::iterator it = extra_hdrs.begin();
283 it != extra_hdrs.end(); ++it){
284 slist = curl_slist_append(slist, (*it).c_str());
287 curl_slist_append(slist, "Expect:");
288 curl_easy_setopt(curl_inst, CURLOPT_HTTPHEADER, slist);
290 response.erase(response.begin(), response.end());
291 extra_hdrs.erase(extra_hdrs.begin(), extra_hdrs.end());
292 CURLcode res = curl_easy_perform(curl_inst);
294 cout << "Curl perform failed for " << url << ", res: " <<
295 curl_easy_strerror(res) << "\n";
298 curl_slist_free_all(slist);
300 curl_easy_cleanup(curl_inst);
305 admin_meta::test_helper *g_test;
308 int run_rgw_admin(string& cmd, string& resp) {
314 get_str_list(cmd, " \t", l);
315 char *argv[l.size()];
318 argv[0] = (char *)"radosgw-admin";
319 for (list<string>::iterator it = l.begin();
320 it != l.end(); ++it) {
321 argv[loop++] = (char *)(*it).c_str();
324 if (!freopen(RGW_ADMIN_RESP_PATH, "w+", stdout)) {
325 cout << "Unable to open stdout file" << std::endl;
327 execv((g_test->get_rgw_admin_path()).c_str(), argv);
328 } else if (pid > 0) {
330 waitpid(pid, &status, 0);
331 if (WIFEXITED(status)) {
332 if(WEXITSTATUS(status) != 0) {
333 cout << "Child exited with status " << WEXITSTATUS(status) << std::endl;
340 if (stat(RGW_ADMIN_RESP_PATH, &st) < 0) {
341 cout << "Error stating the admin response file, errno " << errno << std::endl;
344 char *data = (char *)malloc(st.st_size + 1);
345 in.open(RGW_ADMIN_RESP_PATH);
346 in.read(data, st.st_size);
348 data[st.st_size] = 0;
351 unlink(RGW_ADMIN_RESP_PATH);
352 /* cout << "radosgw-admin " << cmd << ": " << resp << std::endl;*/
359 int get_creds(string& json, string& creds) {
361 if(!parser.parse(json.c_str(), json.length())) {
362 cout << "Error parsing create user response" << std::endl;
367 decode_json_obj(info, &parser);
369 for(map<string, RGWAccessKey>::iterator it = info.access_keys.begin();
370 it != info.access_keys.end(); ++it) {
371 RGWAccessKey _k = it->second;
372 /*cout << "accesskeys [ " << it->first << " ] = " <<
373 "{ " << _k.id << ", " << _k.key << ", " << _k.subuser << "}" << std::endl;*/
374 creds.append(it->first + string(":") + _k.key);
380 int user_create(string& uid, string& display_name, bool set_creds = true) {
383 ss << "-c " << g_test->get_ceph_conf_path() << " user create --uid=" << uid
384 << " --display-name=" << display_name;
387 string cmd = ss.str();
388 if(run_rgw_admin(cmd, out) != 0) {
389 cout << "Error creating user" << std::endl;
392 get_creds(out, creds);
394 g_test->set_creds(creds);
398 int user_info(string& uid, string& display_name, RGWUserInfo& uinfo) {
400 ss << "-c " << g_test->get_ceph_conf_path() << " user info --uid=" << uid
401 << " --display-name=" << display_name;
404 string cmd = ss.str();
405 if(run_rgw_admin(cmd, out) != 0) {
406 cout << "Error reading user information" << std::endl;
410 if(!parser.parse(out.c_str(), out.length())) {
411 cout << "Error parsing create user response" << std::endl;
414 decode_json_obj(uinfo, &parser);
418 int user_rm(string& uid, string& display_name) {
420 ss << "-c " << g_test->get_ceph_conf_path() << " user rm --uid=" << uid
421 << " --display-name=" << display_name;
424 string cmd = ss.str();
425 if(run_rgw_admin(cmd, out) != 0) {
426 cout << "Error removing user" << std::endl;
432 int meta_caps_add(const char *perm) {
435 ss << "-c " << g_test->get_ceph_conf_path() << " caps add --caps=" <<
436 meta_caps << "=" << perm << " --uid=" << uid;
438 string cmd = ss.str();
439 if(run_rgw_admin(cmd, out) != 0) {
440 cout << "Error creating user" << std::endl;
446 int meta_caps_rm(const char *perm) {
449 ss << "-c " << g_test->get_ceph_conf_path() << " caps rm --caps=" <<
450 meta_caps << "=" << perm << " --uid=" << uid;
452 string cmd = ss.str();
453 if(run_rgw_admin(cmd, out) != 0) {
454 cout << "Error creating user" << std::endl;
460 int compare_access_keys(RGWAccessKey& k1, RGWAccessKey& k2) {
461 if (k1.id.compare(k2.id) != 0)
463 if (k1.key.compare(k2.key) != 0)
465 if (k1.subuser.compare(k2.subuser) != 0)
471 int compare_user_info(RGWUserInfo& i1, RGWUserInfo& i2) {
474 if ((rv = i1.user_id.compare(i2.user_id)) != 0)
476 if ((rv = i1.display_name.compare(i2.display_name)) != 0)
478 if ((rv = i1.user_email.compare(i2.user_email)) != 0)
480 if (i1.access_keys.size() != i2.access_keys.size())
482 for (map<string, RGWAccessKey>::iterator it = i1.access_keys.begin();
483 it != i1.access_keys.end(); ++it) {
486 if (i2.access_keys.count(it->first) == 0)
488 k2 = i2.access_keys[it->first];
489 if (compare_access_keys(k1, k2) != 0)
492 if (i1.swift_keys.size() != i2.swift_keys.size())
494 for (map<string, RGWAccessKey>::iterator it = i1.swift_keys.begin();
495 it != i1.swift_keys.end(); ++it) {
498 if (i2.swift_keys.count(it->first) == 0)
500 k2 = i2.swift_keys[it->first];
501 if (compare_access_keys(k1, k2) != 0)
504 if (i1.subusers.size() != i2.subusers.size())
506 for (map<string, RGWSubUser>::iterator it = i1.subusers.begin();
507 it != i1.subusers.end(); ++it) {
510 if (!i2.subusers.count(it->first))
512 k2 = i2.subusers[it->first];
513 if (k1.name.compare(k2.name) != 0)
515 if (k1.perm_mask != k2.perm_mask)
518 if (i1.suspended != i2.suspended)
520 if (i1.max_buckets != i2.max_buckets)
523 p1 = p2 = RGW_CAP_ALL;
524 if (i1.caps.check_cap(meta_caps, p1) != 0)
526 if (i2.caps.check_cap(meta_caps, p2) != 0)
531 size_t read_dummy_post(void *ptr, size_t s, size_t n, void *ud) {
533 memcpy(ptr, &dummy, sizeof(dummy));
534 return sizeof(dummy);
538 int parse_json_resp(JSONParser &parser) {
540 resp = (string *)g_test->get_response_data();
543 if(!parser.parse(resp->c_str(), resp->length())) {
544 cout << "Error parsing create user response" << std::endl;
550 size_t meta_read_json(void *ptr, size_t s, size_t n, void *ud){
551 stringstream *ss = (stringstream *)ud;
552 size_t len = ss->str().length();
554 cout << "Cannot copy json data, as len is not enough\n";
557 memcpy(ptr, (void *)ss->str().c_str(), len);
561 TEST(TestRGWAdmin, meta_list){
564 const char *perm = "*";
566 ASSERT_EQ(0, user_create(uid, display_name));
567 ASSERT_EQ(0, meta_caps_add(perm));
569 /*Check the sections*/
570 g_test->send_request(string("GET"), string("/admin/metadata/"));
571 EXPECT_EQ(200U, g_test->get_resp_code());
573 ASSERT_TRUE(parse_json_resp(parser) == 0);
574 EXPECT_TRUE(parser.is_array());
577 l = parser.get_array_elements();
578 for(vector<string>::iterator it = l.begin();
579 it != l.end(); ++it) {
580 if((*it).compare("\"user\"") == 0) {
587 /*Check with a wrong section*/
588 g_test->send_request(string("GET"), string("/admin/metadata/users"));
589 EXPECT_EQ(404U, g_test->get_resp_code());
591 /*Check the list of keys*/
592 g_test->send_request(string("GET"), string("/admin/metadata/user"));
593 EXPECT_EQ(200U, g_test->get_resp_code());
595 ASSERT_TRUE(parse_json_resp(parser) == 0);
596 EXPECT_TRUE(parser.is_array());
598 l = parser.get_array_elements();
599 EXPECT_EQ(1U, l.size());
600 for(vector<string>::iterator it = l.begin();
601 it != l.end(); ++it) {
602 if((*it).compare(string("\"") + uid + string("\"")) == 0) {
609 /*Check with second user*/
610 string uid2 = "ceph1", display_name2 = "CEPH1";
611 ASSERT_EQ(0, user_create(uid2, display_name2, false));
612 /*Check the list of keys*/
613 g_test->send_request(string("GET"), string("/admin/metadata/user"));
614 EXPECT_EQ(200U, g_test->get_resp_code());
616 ASSERT_TRUE(parse_json_resp(parser) == 0);
617 EXPECT_TRUE(parser.is_array());
619 l = parser.get_array_elements();
620 EXPECT_EQ(2U, l.size());
622 for(vector<string>::iterator it = l.begin();
623 it != l.end(); ++it) {
624 if((*it).compare(string("\"") + uid + string("\"")) == 0) {
627 if((*it).compare(string("\"") + uid2 + string("\"")) == 0) {
631 EXPECT_TRUE(found && found2);
632 ASSERT_EQ(0, user_rm(uid2, display_name2));
634 /*Remove the metadata caps*/
635 int rv = meta_caps_rm(perm);
639 g_test->send_request(string("GET"), string("/admin/metadata/"));
640 EXPECT_EQ(403U, g_test->get_resp_code());
642 g_test->send_request(string("GET"), string("/admin/metadata/user"));
643 EXPECT_EQ(403U, g_test->get_resp_code());
645 ASSERT_EQ(0, user_rm(uid, display_name));
648 TEST(TestRGWAdmin, meta_get){
650 const char *perm = "*";
653 ASSERT_EQ(0, user_create(uid, display_name));
654 ASSERT_EQ(0, meta_caps_add(perm));
656 ASSERT_EQ(0, user_info(uid, display_name, info));
658 g_test->send_request(string("GET"), string("/admin/metadata/user?key=test"));
659 EXPECT_EQ(404U, g_test->get_resp_code());
661 g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
662 EXPECT_EQ(200U, g_test->get_resp_code());
664 ASSERT_TRUE(parse_json_resp(parser) == 0);
665 RGWObjVersionTracker objv_tracker;
668 obj_version *objv = &objv_tracker.read_version;
670 JSONDecoder::decode_json("key", metadata_key, &parser);
671 JSONDecoder::decode_json("ver", *objv, &parser);
672 JSONObj *jo = parser.find_obj("data");
674 string exp_meta_key = "user:";
675 exp_meta_key.append(uid);
676 EXPECT_TRUE(metadata_key.compare(exp_meta_key) == 0);
678 RGWUserInfo obt_info;
679 decode_json_obj(obt_info, jo);
681 EXPECT_TRUE(compare_user_info(info, obt_info) == 0);
683 /*Make a modification and check if its reflected*/
684 ASSERT_EQ(0, meta_caps_rm(perm));
686 ASSERT_EQ(0, meta_caps_add(perm));
689 g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
690 EXPECT_EQ(200U, g_test->get_resp_code());
692 ASSERT_TRUE(parse_json_resp(parser1) == 0);
694 RGWObjVersionTracker objv_tracker1;
695 obj_version *objv1 = &objv_tracker1.read_version;
697 JSONDecoder::decode_json("key", metadata_key, &parser1);
698 JSONDecoder::decode_json("ver", *objv1, &parser1);
699 jo = parser1.find_obj("data");
702 decode_json_obj(obt_info, jo);
706 EXPECT_TRUE (info.caps.check_cap(meta_caps, p1) == 0);
707 EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, p2) == 0);
709 EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, p2) != 0);
711 /*Version and tag infromation*/
712 EXPECT_TRUE(objv1->ver > objv->ver);
713 EXPECT_EQ(objv1->tag, objv->tag);
715 int rv = meta_caps_rm(perm);
719 g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
720 EXPECT_EQ(403U, g_test->get_resp_code());
722 ASSERT_EQ(0, user_rm(uid, display_name));
725 TEST(TestRGWAdmin, meta_put){
727 const char *perm = "*";
730 ASSERT_EQ(0, user_create(uid, display_name));
731 ASSERT_EQ(0, meta_caps_add(perm));
733 g_test->send_request(string("GET"), (string("/admin/metadata/user?key=") + uid));
734 EXPECT_EQ(200U, g_test->get_resp_code());
736 ASSERT_TRUE(parse_json_resp(parser) == 0);
737 RGWObjVersionTracker objv_tracker;
740 obj_version *objv = &objv_tracker.read_version;
742 JSONDecoder::decode_json("key", metadata_key, &parser);
743 JSONDecoder::decode_json("ver", *objv, &parser);
744 JSONObj *jo = parser.find_obj("data");
746 string exp_meta_key = "user:";
747 exp_meta_key.append(uid);
748 EXPECT_TRUE(metadata_key.compare(exp_meta_key) == 0);
750 RGWUserInfo obt_info;
751 decode_json_obj(obt_info, jo);
753 /*Change the cap and PUT */
756 Formatter *f = new JSONFormatter();
758 new_cap = meta_caps + string("=write");
759 caps.add_from_string(new_cap);
760 obt_info.caps = caps;
761 f->open_object_section("metadata_info");
762 ::encode_json("key", metadata_key, f);
763 ::encode_json("ver", *objv, f);
764 ::encode_json("data", obt_info, f);
766 std::stringstream ss;
769 g_test->send_request(string("PUT"), (string("/admin/metadata/user?key=") + uid),
771 (void *)&ss, ss.str().length());
772 EXPECT_EQ(200U, g_test->get_resp_code());
774 ASSERT_EQ(0, user_info(uid, display_name, obt_info));
777 EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, cp) == 0);
779 EXPECT_TRUE (obt_info.caps.check_cap(meta_caps, cp) != 0);
781 int rv = meta_caps_rm("write");
784 g_test->send_request(string("PUT"), (string("/admin/metadata/user?key=") + uid));
785 EXPECT_EQ(403U, g_test->get_resp_code());
787 ASSERT_EQ(0, user_rm(uid, display_name));
790 TEST(TestRGWAdmin, meta_lock_unlock) {
791 const char *perm = "*";
794 ASSERT_EQ(0, user_create(uid, display_name));
795 ASSERT_EQ(0, meta_caps_add(perm));
797 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3";
798 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
799 EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
801 rest_req = "/admin/metadata/user?lock&length=3&lock_id=ceph";
802 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
803 EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
805 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock";
806 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
807 EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
809 rest_req = "/admin/metadata/user?unlock&lock_id=ceph";
810 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
811 EXPECT_EQ(400U, g_test->get_resp_code()); /*Bad request*/
813 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
814 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
815 EXPECT_EQ(200U, g_test->get_resp_code());
817 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
818 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
819 EXPECT_EQ(200U, g_test->get_resp_code());
821 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph1";
822 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
823 EXPECT_EQ(200U, g_test->get_resp_code());
825 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph1";
826 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
827 EXPECT_EQ(200U, g_test->get_resp_code());
829 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
830 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
831 EXPECT_EQ(200U, g_test->get_resp_code());
832 utime_t sleep_time(3, 0);
834 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph1";
835 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
836 EXPECT_EQ(500U, g_test->get_resp_code());
838 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
839 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
840 EXPECT_EQ(409U, g_test->get_resp_code());
843 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph1";
844 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
845 EXPECT_EQ(200U, g_test->get_resp_code());
847 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph1";
848 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
849 EXPECT_EQ(200U, g_test->get_resp_code());
851 ASSERT_EQ(0, meta_caps_rm(perm));
853 ASSERT_EQ(0, meta_caps_add(perm));
854 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
855 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
856 EXPECT_EQ(403U, g_test->get_resp_code());
858 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
859 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
860 EXPECT_EQ(403U, g_test->get_resp_code());
862 ASSERT_EQ(0, meta_caps_rm(perm));
864 ASSERT_EQ(0, meta_caps_add(perm));
865 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
866 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
867 EXPECT_EQ(200U, g_test->get_resp_code());
869 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
870 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
871 EXPECT_EQ(200U, g_test->get_resp_code());
873 ASSERT_EQ(0, meta_caps_rm(perm));
874 rest_req = "/admin/metadata/user?key=" CEPH_UID "&lock&length=3&lock_id=ceph";
875 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
876 EXPECT_EQ(403U, g_test->get_resp_code());
878 rest_req = "/admin/metadata/user?key=" CEPH_UID "&unlock&lock_id=ceph";
879 g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
880 EXPECT_EQ(403U, g_test->get_resp_code());
882 ASSERT_EQ(0, user_rm(uid, display_name));
885 TEST(TestRGWAdmin, meta_delete){
887 const char *perm = "*";
890 ASSERT_EQ(0, user_create(uid, display_name));
891 ASSERT_EQ(0, meta_caps_add(perm));
893 g_test->send_request(string("DELETE"), (string("/admin/metadata/user?key=") + uid));
894 EXPECT_EQ(200U, g_test->get_resp_code());
896 ASSERT_TRUE(user_info(uid, display_name, info) != 0);
898 ASSERT_EQ(0, user_create(uid, display_name));
900 ASSERT_EQ(0, meta_caps_add(perm));
902 g_test->send_request(string("DELETE"), (string("/admin/metadata/user?key=") + uid));
903 EXPECT_EQ(403U, g_test->get_resp_code());
904 ASSERT_EQ(0, user_rm(uid, display_name));
907 int main(int argc, char *argv[]){
908 vector<const char*> args;
909 argv_to_vec(argc, (const char **)argv, args);
911 auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
912 CODE_ENVIRONMENT_UTILITY, 0);
913 common_init_finish(g_ceph_context);
914 g_test = new admin_meta::test_helper();
915 finisher = new Finisher(g_ceph_context);
917 ::testing::InitGoogleTest(&argc, argv);
921 if(g_test->extract_input(argc, argv) < 0){
922 print_usage(argv[0]);
926 int r = RUN_ALL_TESTS();
928 cout << "There are no failures in the test case\n";
930 cout << "There are some failures\n";