src/ceph/src/test/test_rgw_admin_opstate.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
   7  *
   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.
  12  *
  13  */
  14 #include <iostream>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <errno.h>
  19 #include <time.h>
  20 #include <sys/wait.h>
  21 #include <unistd.h>
  22 #include <fstream>
  23 #include <map>
  24 #include <list>
  25 extern "C"{
  26 #include <curl/curl.h>
  27 }
  28 #include "common/ceph_crypto.h"
  29 #include "include/str_list.h"
  30 #include "common/ceph_json.h"
  31 #include "common/code_environment.h"
  32 #include "common/ceph_argparse.h"
  33 #include "common/Finisher.h"
  34 #include "global/global_init.h"
  35 #include "rgw/rgw_common.h"
  36 #include "rgw/rgw_bucket.h"
  37 #include "rgw/rgw_rados.h"
  38 #include "include/utime.h"
  39 #include "include/object.h"
  40 #include "cls/statelog/cls_statelog_types.h"
  41 #define GTEST
  42 #ifdef GTEST
  43 #include <gtest/gtest.h>
  44 #else
  45 #define TEST(x, y) void y()
  46 #define ASSERT_EQ(v, s) if(v != s)cout << "Error at " << __LINE__ << "(" << #v << "!= " << #s << "\n"; \
  47                                 else cout << "(" << #v << "==" << #s << ") PASSED\n";
  48 #define EXPECT_EQ(v, s) ASSERT_EQ(v, s)
  49 #define ASSERT_TRUE(c) if(c)cout << "Error at " << __LINE__ << "(" << #c << ")" << "\n"; \
  50                           else cout << "(" << #c << ") PASSED\n";
  51 #define EXPECT_TRUE(c) ASSERT_TRUE(c)
  52 #endif
  53 using namespace std;
  54
  55 #define CURL_VERBOSE 0
  56 #define HTTP_RESPONSE_STR "RespCode"
  57 #define CEPH_CRYPTO_HMACSHA1_DIGESTSIZE 20
  58 #define RGW_ADMIN_RESP_PATH "/tmp/.test_rgw_admin_resp"
  59
  60 static string uid = "ceph";
  61 static string display_name = "CEPH";
  62
  63 extern "C" int ceph_armor(char *dst, const char *dst_end,
  64                           const char *src, const char *end);
  65 static void print_usage(char *exec){
  66   cout << "Usage: " << exec << " <Options>\n";
  67   cout << "Options:\n"
  68           "-g <gw-ip> - The ip address of the gateway\n"
  69           "-p <gw-port> - The port number of the gateway\n"
  70           "-c <ceph.conf> - Absolute path of ceph config file\n"
  71           "-rgw-admin <path/to/radosgw-admin> - radosgw-admin absolute path\n";
  72 }
  73
  74 namespace admin_log {
  75 class test_helper {
  76   private:
  77     string host;
  78     string port;
  79     string creds;
  80     string rgw_admin_path;
  81     string conf_path;
  82     CURL *curl_inst;
  83     map<string, string> response;
  84     list<string> extra_hdrs;
  85     string *resp_data;
  86     unsigned resp_code;
  87   public:
  88     test_helper() : curl_inst(NULL), resp_data(NULL), resp_code(0) {
  89       curl_global_init(CURL_GLOBAL_ALL);
  90     }
  91     ~test_helper(){
  92       curl_global_cleanup();
  93     }
  94     int send_request(string method, string uri,
  95                      size_t (*function)(void *,size_t,size_t,void *) = 0,
  96                      void *ud = 0, size_t length = 0);
  97     int extract_input(int argc, char *argv[]);
  98     string& get_response(string hdr){
  99       return response[hdr];
 100     }
 101     void set_extra_header(string hdr){
 102       extra_hdrs.push_back(hdr);
 103     }
 104     void set_response(char *val);
 105     void set_response_data(char *data, size_t len){
 106       if(resp_data) delete resp_data;
 107       resp_data = new string(data, len);
 108     }
 109     string& get_rgw_admin_path() {
 110       return rgw_admin_path;
 111     }
 112     string& get_ceph_conf_path() {
 113       return conf_path;
 114     }
 115     void set_creds(string& c) {
 116       creds = c;
 117     }
 118     const string *get_response_data(){return resp_data;}
 119     unsigned get_resp_code(){return resp_code;}
 120 };
 121
 122 int test_helper::extract_input(int argc, char *argv[]){
 123 #define ERR_CHECK_NEXT_PARAM(o) \
 124   if(((int)loop + 1) >= argc)return -1;         \
 125   else o = argv[loop+1];
 126
 127   for(unsigned loop = 1;loop < (unsigned)argc; loop += 2){
 128     if(strcmp(argv[loop], "-g") == 0){
 129       ERR_CHECK_NEXT_PARAM(host);
 130     }else if(strcmp(argv[loop],"-p") == 0){
 131       ERR_CHECK_NEXT_PARAM(port);
 132     }else if(strcmp(argv[loop], "-c") == 0){
 133       ERR_CHECK_NEXT_PARAM(conf_path);
 134     }else if(strcmp(argv[loop], "-rgw-admin") == 0){
 135       ERR_CHECK_NEXT_PARAM(rgw_admin_path);
 136     }else return -1;
 137   }
 138   if(host.length() <= 0 ||
 139      rgw_admin_path.length() <= 0)
 140     return -1;
 141   return 0;
 142 }
 143
 144 void test_helper::set_response(char *r){
 145   string sr(r), h, v;
 146   size_t off = sr.find(": ");
 147   if(off != string::npos){
 148     h.assign(sr, 0, off);
 149     v.assign(sr, off + 2, sr.find("\r\n") - (off+2));
 150   }else{
 151     /*Could be the status code*/
 152     if(sr.find("HTTP/") != string::npos){
 153       h.assign(HTTP_RESPONSE_STR);
 154       off = sr.find(" ");
 155       v.assign(sr, off + 1, sr.find("\r\n") - (off + 1));
 156       resp_code = atoi((v.substr(0, 3)).c_str());
 157     }
 158   }
 159   response[h] = v;
 160 }
 161
 162 size_t write_header(void *ptr, size_t size, size_t nmemb, void *ud){
 163   test_helper *h = static_cast<test_helper *>(ud);
 164   h->set_response((char *)ptr);
 165   return size*nmemb;
 166 }
 167
 168 size_t write_data(void *ptr, size_t size, size_t nmemb, void *ud){
 169   test_helper *h = static_cast<test_helper *>(ud);
 170   h->set_response_data((char *)ptr, size*nmemb);
 171   return size*nmemb;
 172 }
 173
 174 static inline void buf_to_hex(const unsigned char *buf, int len, char *str)
 175 {
 176   int i;
 177   str[0] = '\0';
 178   for (i = 0; i < len; i++) {
 179     sprintf(&str[i*2], "%02x", (int)buf[i]);
 180   }
 181 }
 182
 183 static void calc_hmac_sha1(const char *key, int key_len,
 184                     const char *msg, int msg_len, char *dest)
 185 /* destination should be CEPH_CRYPTO_HMACSHA1_DIGESTSIZE bytes long */
 186 {
 187   ceph::crypto::HMACSHA1 hmac((const unsigned char *)key, key_len);
 188   hmac.Update((const unsigned char *)msg, msg_len);
 189   hmac.Final((unsigned char *)dest);
 190
 191   char hex_str[(CEPH_CRYPTO_HMACSHA1_DIGESTSIZE * 2) + 1];
 192   admin_log::buf_to_hex((unsigned char *)dest, CEPH_CRYPTO_HMACSHA1_DIGESTSIZE, hex_str);
 193 }
 194
 195 static int get_s3_auth(string method, string creds, string date, string res, string& out){
 196   string aid, secret, auth_hdr;
 197   string tmp_res;
 198   size_t off = creds.find(":");
 199   out = "";
 200   if(off != string::npos){
 201     aid.assign(creds, 0, off);
 202     secret.assign(creds, off + 1, string::npos);
 203
 204     /*sprintf(auth_hdr, "%s\n\n\n%s\n%s", req_type, date, res);*/
 205     char hmac_sha1[CEPH_CRYPTO_HMACSHA1_DIGESTSIZE];
 206     char b64[65]; /* 64 is really enough */
 207     size_t off = res.find("?");
 208     if(off == string::npos)
 209       tmp_res = res;
 210     else
 211       tmp_res.assign(res, 0, off);
 212     auth_hdr.append(method + string("\n\n\n") + date + string("\n") + tmp_res);
 213     admin_log::calc_hmac_sha1(secret.c_str(), secret.length(),
 214                                auth_hdr.c_str(), auth_hdr.length(), hmac_sha1);
 215     int ret = ceph_armor(b64, b64 + 64, hmac_sha1,
 216                          hmac_sha1 + CEPH_CRYPTO_HMACSHA1_DIGESTSIZE);
 217     if (ret < 0) {
 218       cout << "ceph_armor failed\n";
 219       return -1;
 220     }
 221     b64[ret] = 0;
 222     out.append(aid + string(":") + b64);
 223   }else return -1;
 224   return 0;
 225 }
 226
 227 void get_date(string& d){
 228   struct timeval tv;
 229   char date[64];
 230   struct tm tm;
 231   char *days[] = {(char *)"Sun", (char *)"Mon", (char *)"Tue",
 232                   (char *)"Wed", (char *)"Thu", (char *)"Fri",
 233                   (char *)"Sat"};
 234   char *months[] = {(char *)"Jan", (char *)"Feb", (char *)"Mar",
 235                     (char *)"Apr", (char *)"May", (char *)"Jun",
 236                     (char *)"Jul",(char *) "Aug", (char *)"Sep",
 237                     (char *)"Oct", (char *)"Nov", (char *)"Dec"};
 238   gettimeofday(&tv, NULL);
 239   gmtime_r(&tv.tv_sec, &tm);
 240   sprintf(date, "%s, %d %s %d %d:%d:%d GMT",
 241           days[tm.tm_wday],
 242           tm.tm_mday, months[tm.tm_mon],
 243           tm.tm_year + 1900,
 244           tm.tm_hour, tm.tm_min, tm.tm_sec);
 245   d = date;
 246 }
 247
 248 int test_helper::send_request(string method, string res,
 249                                    size_t (*read_function)( void *,size_t,size_t,void *),
 250                                    void *ud,
 251                                    size_t length){
 252   string url;
 253   string auth, date;
 254   url.append(string("http://") + host);
 255   if(port.length() > 0)url.append(string(":") + port);
 256   url.append(res);
 257   curl_inst = curl_easy_init();
 258   if(curl_inst){
 259     curl_easy_setopt(curl_inst, CURLOPT_URL, url.c_str());
 260     curl_easy_setopt(curl_inst, CURLOPT_CUSTOMREQUEST, method.c_str());
 261     curl_easy_setopt(curl_inst, CURLOPT_VERBOSE, CURL_VERBOSE);
 262     curl_easy_setopt(curl_inst, CURLOPT_HEADERFUNCTION, admin_log::write_header);
 263     curl_easy_setopt(curl_inst, CURLOPT_WRITEHEADER, (void *)this);
 264     curl_easy_setopt(curl_inst, CURLOPT_WRITEFUNCTION, admin_log::write_data);
 265     curl_easy_setopt(curl_inst, CURLOPT_WRITEDATA, (void *)this);
 266     if(read_function){
 267       curl_easy_setopt(curl_inst, CURLOPT_READFUNCTION, read_function);
 268       curl_easy_setopt(curl_inst, CURLOPT_READDATA, (void *)ud);
 269       curl_easy_setopt(curl_inst, CURLOPT_UPLOAD, 1L);
 270       curl_easy_setopt(curl_inst, CURLOPT_INFILESIZE_LARGE, (curl_off_t)length);
 271     }
 272
 273     get_date(date);
 274     string http_date;
 275     http_date.append(string("Date: ") + date);
 276
 277     string s3auth;
 278     if (admin_log::get_s3_auth(method, creds, date, res, s3auth) < 0)
 279       return -1;
 280     auth.append(string("Authorization: AWS ") + s3auth);
 281
 282     struct curl_slist *slist = NULL;
 283     slist = curl_slist_append(slist, auth.c_str());
 284     slist = curl_slist_append(slist, http_date.c_str());
 285     for(list<string>::iterator it = extra_hdrs.begin();
 286         it != extra_hdrs.end(); ++it){
 287       slist = curl_slist_append(slist, (*it).c_str());
 288     }
 289     if(read_function)
 290       curl_slist_append(slist, "Expect:");
 291     curl_easy_setopt(curl_inst, CURLOPT_HTTPHEADER, slist);
 292
 293     response.erase(response.begin(), response.end());
 294     extra_hdrs.erase(extra_hdrs.begin(), extra_hdrs.end());
 295     CURLcode res = curl_easy_perform(curl_inst);
 296     if(res != CURLE_OK){
 297       cout << "Curl perform failed for " << url << ", res: " <<
 298         curl_easy_strerror(res) << "\n";
 299       return -1;
 300     }
 301     curl_slist_free_all(slist);
 302   }
 303   curl_easy_cleanup(curl_inst);
 304   return 0;
 305 }
 306 };
 307
 308 admin_log::test_helper *g_test;
 309 Finisher *finisher;
 310 RGWRados *store;
 311
 312 int run_rgw_admin(string& cmd, string& resp) {
 313   pid_t pid;
 314   pid = fork();
 315   if (pid == 0) {
 316     /* child */
 317     list<string> l;
 318     get_str_list(cmd, " \t", l);
 319     char *argv[l.size()];
 320     unsigned loop = 1;
 321
 322     argv[0] = (char *)"radosgw-admin";
 323     for (list<string>::iterator it = l.begin();
 324          it != l.end(); ++it) {
 325       argv[loop++] = (char *)(*it).c_str();
 326     }
 327     argv[loop] = NULL;
 328     if (!freopen(RGW_ADMIN_RESP_PATH, "w+", stdout)) {
 329       cout << "Unable to open stdout file" << std::endl;
 330     }
 331     execv((g_test->get_rgw_admin_path()).c_str(), argv);
 332   } else if (pid > 0) {
 333     int status;
 334     waitpid(pid, &status, 0);
 335     if (WIFEXITED(status)) {
 336       if(WEXITSTATUS(status) != 0) {
 337         cout << "Child exited with status " << WEXITSTATUS(status) << std::endl;
 338         return -1;
 339       }
 340     }
 341     ifstream in;
 342     struct stat st;
 343
 344     if (stat(RGW_ADMIN_RESP_PATH, &st) < 0) {
 345       cout << "Error stating the admin response file, errno " << errno << std::endl;
 346       return -1;
 347     } else {
 348       char *data = (char *)malloc(st.st_size + 1);
 349       in.open(RGW_ADMIN_RESP_PATH);
 350       in.read(data, st.st_size);
 351       in.close();
 352       data[st.st_size] = 0;
 353       resp = data;
 354       free(data);
 355       unlink(RGW_ADMIN_RESP_PATH);
 356       /* cout << "radosgw-admin " << cmd << ": " << resp << std::endl; */
 357     }
 358   } else
 359     return -1;
 360   return 0;
 361 }
 362
 363 int get_creds(string& json, string& creds) {
 364   JSONParser parser;
 365   if(!parser.parse(json.c_str(), json.length())) {
 366     cout << "Error parsing create user response" << std::endl;
 367     return -1;
 368   }
 369
 370   RGWUserInfo info;
 371   decode_json_obj(info, &parser);
 372   creds = "";
 373   for(map<string, RGWAccessKey>::iterator it = info.access_keys.begin();
 374       it != info.access_keys.end(); ++it) {
 375     RGWAccessKey _k = it->second;
 376     /*cout << "accesskeys [ " << it->first << " ] = " <<
 377       "{ " << _k.id << ", " << _k.key << ", " << _k.subuser << "}" << std::endl;*/
 378     creds.append(it->first + string(":") + _k.key);
 379     break;
 380   }
 381   return 0;
 382 }
 383
 384 int user_create(string& uid, string& display_name, bool set_creds = true) {
 385   stringstream ss;
 386   string creds;
 387   ss << "-c " << g_test->get_ceph_conf_path() << " user create --uid=" << uid
 388     << " --display-name=" << display_name;
 389
 390   string out;
 391   string cmd = ss.str();
 392   if(run_rgw_admin(cmd, out) != 0) {
 393     cout << "Error creating user" << std::endl;
 394     return -1;
 395   }
 396   get_creds(out, creds);
 397   if(set_creds)
 398     g_test->set_creds(creds);
 399   return 0;
 400 }
 401
 402 int user_info(string& uid, string& display_name, RGWUserInfo& uinfo) {
 403   stringstream ss;
 404   ss << "-c " << g_test->get_ceph_conf_path() << " user info --uid=" << uid
 405     << " --display-name=" << display_name;
 406
 407   string out;
 408   string cmd = ss.str();
 409   if(run_rgw_admin(cmd, out) != 0) {
 410     cout << "Error reading user information" << std::endl;
 411     return -1;
 412   }
 413   JSONParser parser;
 414   if(!parser.parse(out.c_str(), out.length())) {
 415     cout << "Error parsing create user response" << std::endl;
 416     return -1;
 417   }
 418   decode_json_obj(uinfo, &parser);
 419   return 0;
 420 }
 421
 422 int user_rm(string& uid, string& display_name) {
 423   stringstream ss;
 424   ss << "-c " << g_test->get_ceph_conf_path() <<
 425     " metadata rm --metadata-key=user:" << uid;
 426
 427   string out;
 428   string cmd = ss.str();
 429   if(run_rgw_admin(cmd, out) != 0) {
 430     cout << "Error removing user" << std::endl;
 431     return -1;
 432   }
 433   return 0;
 434 }
 435
 436 int caps_add(const char * name, const char *perm) {
 437   stringstream ss;
 438
 439   ss << "-c " << g_test->get_ceph_conf_path() << " caps add --caps=" <<
 440      name << "=" << perm << " --uid=" << uid;
 441   string out;
 442   string cmd = ss.str();
 443   if(run_rgw_admin(cmd, out) != 0) {
 444     cout << "Error creating user" << std::endl;
 445     return -1;
 446   }
 447   return 0;
 448 }
 449
 450 int caps_rm(const char * name, const char *perm) {
 451   stringstream ss;
 452
 453   ss << "-c " << g_test->get_ceph_conf_path() << " caps rm --caps=" <<
 454      name << "=" << perm << " --uid=" << uid;
 455   string out;
 456   string cmd = ss.str();
 457   if(run_rgw_admin(cmd, out) != 0) {
 458     cout << "Error creating user" << std::endl;
 459     return -1;
 460   }
 461   return 0;
 462 }
 463
 464 size_t read_dummy_post(void *ptr, size_t s, size_t n, void *ud) {
 465   int dummy = 0;
 466   memcpy(ptr, &dummy, sizeof(dummy));
 467   return sizeof(dummy);
 468 }
 469
 470 int parse_json_resp(JSONParser &parser) {
 471   string *resp;
 472   resp = (string *)g_test->get_response_data();
 473   if(!resp)
 474     return -1;
 475   if(!parser.parse(resp->c_str(), resp->length())) {
 476     cout << "Error parsing create user response" << std::endl;
 477     return -1;
 478   }
 479   return 0;
 480 }
 481
 482 static int decode_json(JSONObj *obj, cls_statelog_entry& ret) {
 483   JSONDecoder::decode_json("op_id", ret.op_id, obj);
 484   JSONDecoder::decode_json("client_id", ret.client_id, obj);
 485   JSONDecoder::decode_json("object", ret.object, obj);
 486   string state;
 487   JSONDecoder::decode_json("state", state, obj);
 488   RGWOpState oc(store);
 489   return oc.state_from_str(state, (RGWOpState::OpState *)&ret.state);
 490 }
 491
 492 static int get_opstate_list(list<cls_statelog_entry> &entries) {
 493   JSONParser parser;
 494   if (parse_json_resp(parser) != 0)
 495     return -1;
 496   if (!parser.is_array())
 497     return -1;
 498
 499   vector<string> l;
 500   l = parser.get_array_elements();
 501   int loop = 0;
 502   for(vector<string>::iterator it = l.begin();
 503       it != l.end(); ++it, loop++) {
 504     JSONParser jp;
 505     cls_statelog_entry entry;
 506
 507     if(!jp.parse((*it).c_str(), (*it).length())) {
 508       cerr << "Error parsing log json object" << std::endl;
 509       return -1;
 510     }
 511     EXPECT_EQ(decode_json((JSONObj *)&jp, entry), 0);
 512     entries.push_back(entry);
 513   }
 514   return 0;
 515 }
 516
 517
 518 TEST(TestRGWAdmin, opstate_set_list_delete) {
 519   const char *cname = "opstate",
 520              *perm = "*";
 521   string rest_req;
 522   stringstream ss;
 523   list<cls_statelog_entry> entries;
 524   string cid_1 = "cid_1", cid_2 = "cid_2";
 525   string oid_1 = "operation", oid_2 = "operation";
 526   string obj_1 = "obj1", obj_2 = "obj2";
 527   string state;
 528
 529   ASSERT_EQ(user_create(uid, display_name), 0);
 530   ASSERT_EQ(0, caps_add(cname, perm));
 531
 532   rest_req = "/admin/opstate?client-id=1&op-id=1&object=o";
 533   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 534   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing state*/
 535
 536   rest_req = "/admin/opstate?client-id=1&op-id=1&state=in-progress";
 537   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 538   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing object*/
 539
 540   rest_req = "/admin/opstate?client-id=1&state=in-progress&object=o";
 541   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 542   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing op-id*/
 543
 544   rest_req = "/admin/opstate?state=in-progress&op-id=1&object=o";
 545   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 546   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing client-id*/
 547
 548   rest_req = "/admin/opstate?state=invalid&op-id=1&object=o&client-id=1";
 549   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 550   EXPECT_EQ(400U, g_test->get_resp_code()); /*Invalid state*/
 551
 552   state = "in-progress";
 553   entries.clear();
 554   ss << "/admin/opstate?client-id=" << cid_1 << "&op-id=" << oid_1
 555     << "&object=" << obj_1 << "&state=" << state;
 556   rest_req = ss.str();
 557   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 558   EXPECT_EQ(200U, g_test->get_resp_code());
 559
 560   ss.str("");
 561   entries.clear();
 562   rest_req = "/admin/opstate";
 563   g_test->send_request(string("GET"), rest_req);
 564   EXPECT_EQ(200U, g_test->get_resp_code());
 565   EXPECT_EQ(get_opstate_list(entries), 0);
 566   EXPECT_EQ(entries.size(), 1U);
 567
 568   if (entries.size() == 1U) {
 569     list<cls_statelog_entry>::iterator it = entries.begin();
 570
 571     EXPECT_TRUE((*it).client_id.compare(cid_1) == 0);
 572     EXPECT_TRUE((*it).op_id.compare(oid_1) == 0);
 573     EXPECT_TRUE((*it).object.compare(obj_1) == 0);
 574     EXPECT_EQ((*it).state, (uint32_t)RGWOpState::OPSTATE_IN_PROGRESS);
 575   }
 576
 577   state = "complete";
 578   ss.str("");
 579   entries.clear();
 580   ss << "/admin/opstate?client-id=" << cid_1 << "&op-id=" << oid_1
 581     << "&object=" << obj_1 << "&state=" << state;
 582   rest_req = ss.str();
 583   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 584   EXPECT_EQ(200U, g_test->get_resp_code());
 585
 586   entries.clear();
 587   rest_req = "/admin/opstate";
 588   g_test->send_request(string("GET"), rest_req);
 589   EXPECT_EQ(200U, g_test->get_resp_code());
 590   EXPECT_EQ(get_opstate_list(entries), 0);
 591   EXPECT_EQ(entries.size(), 1U);
 592
 593   if (entries.size() == 1U) {
 594     list<cls_statelog_entry>::iterator it = entries.begin();
 595
 596     EXPECT_TRUE((*it).client_id.compare(cid_1) == 0);
 597     EXPECT_TRUE((*it).op_id.compare(oid_1) == 0);
 598     EXPECT_TRUE((*it).object.compare(obj_1) == 0);
 599     EXPECT_EQ((*it).state, (uint32_t)RGWOpState::OPSTATE_COMPLETE);
 600   }
 601
 602   ss.str("");
 603   entries.clear();
 604   ss << "/admin/opstate?client-id=" << cid_2 << "&op-id=" << oid_2
 605     << "&object=" << obj_2 << "&state=" << state;
 606   rest_req = ss.str();
 607   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 608   EXPECT_EQ(200U, g_test->get_resp_code());
 609
 610   entries.clear();
 611   rest_req = "/admin/opstate";
 612   g_test->send_request(string("GET"), rest_req);
 613   EXPECT_EQ(200U, g_test->get_resp_code());
 614   EXPECT_EQ(get_opstate_list(entries), 0);
 615   EXPECT_EQ(entries.size(), 2U);
 616
 617   if (entries.size() == 1U) {
 618     list<cls_statelog_entry>::iterator it = entries.begin();
 619
 620     EXPECT_TRUE((*it).client_id.compare(cid_1) == 0);
 621     EXPECT_TRUE((*it).op_id.compare(oid_1) == 0);
 622     EXPECT_TRUE((*it).object.compare(obj_1) == 0);
 623     EXPECT_EQ((*it).state, (uint32_t)RGWOpState::OPSTATE_COMPLETE);
 624
 625     ++it;
 626     EXPECT_TRUE((*it).client_id.compare(cid_2) == 0);
 627     EXPECT_TRUE((*it).op_id.compare(oid_2) == 0);
 628     EXPECT_TRUE((*it).object.compare(obj_2) == 0);
 629     EXPECT_EQ((*it).state, (uint32_t)RGWOpState::OPSTATE_COMPLETE);
 630   }
 631
 632   entries.clear();
 633   rest_req = "/admin/opstate?max-entries=1";
 634   g_test->send_request(string("GET"), rest_req);
 635   EXPECT_EQ(200U, g_test->get_resp_code());
 636   EXPECT_EQ(get_opstate_list(entries), 0);
 637   EXPECT_EQ(entries.size(), 1U);
 638
 639   ss.str("");
 640   entries.clear();
 641   ss << "/admin/opstate?client-id=" << cid_2 << "&op-id=" << oid_2 << "&object=" << obj_2;
 642   rest_req = ss.str();
 643   g_test->send_request(string("GET"), rest_req);
 644   EXPECT_EQ(200U, g_test->get_resp_code());
 645   EXPECT_EQ(get_opstate_list(entries), 0);
 646   EXPECT_EQ(entries.size(), 1U);
 647
 648   ss.str("");
 649   entries.clear();
 650   ss << "/admin/opstate?client-id=" << cid_2;
 651   rest_req = ss.str();
 652   g_test->send_request(string("GET"), rest_req);
 653   EXPECT_EQ(200U, g_test->get_resp_code());
 654   EXPECT_EQ(get_opstate_list(entries), 0);
 655   EXPECT_EQ(entries.size(), 1U);
 656
 657   ss.str("");
 658   entries.clear();
 659   ss << "/admin/opstate?op-id=" << oid_2;
 660   rest_req = ss.str();
 661   g_test->send_request(string("GET"), rest_req);
 662   EXPECT_EQ(200U, g_test->get_resp_code());
 663   EXPECT_EQ(get_opstate_list(entries), 0);
 664   EXPECT_EQ(entries.size(), 2U);
 665
 666   ss.str("");
 667   entries.clear();
 668   ss << "/admin/opstate?op-id=" << oid_2 << "&object=" << obj_1 << "&client-id=" << cid_2 ;
 669   rest_req = ss.str();
 670   g_test->send_request(string("GET"), rest_req);
 671   EXPECT_EQ(200U, g_test->get_resp_code());
 672   EXPECT_EQ(get_opstate_list(entries), 0);
 673   EXPECT_EQ(entries.size(), 0U);
 674
 675   rest_req = "/admin/opstate?client-id=1&op-id=1";
 676   g_test->send_request(string("DELETE"), rest_req);
 677   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing object*/
 678
 679   rest_req = "/admin/opstate?client-id=1&object=1";
 680   g_test->send_request(string("DELETE"), rest_req);
 681   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing op-id*/
 682
 683   rest_req = "/admin/opstate?object=1&op-id=1";
 684   g_test->send_request(string("DELETE"), rest_req);
 685   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing client-id*/
 686
 687   rest_req = "/admin/opstate?object=1&op-id=1&client-id=1";
 688   g_test->send_request(string("DELETE"), rest_req);
 689   EXPECT_EQ(404U, g_test->get_resp_code());
 690
 691   ss.str("");
 692   ss << "/admin/opstate?client-id=" << cid_1 << "&op-id=" << oid_1
 693     << "&object=" << obj_1;
 694   rest_req = ss.str();
 695   g_test->send_request(string("DELETE"), rest_req);
 696   EXPECT_EQ(200U, g_test->get_resp_code());
 697
 698   ss.str("");
 699   entries.clear();
 700   ss << "/admin/opstate";
 701   rest_req = ss.str();
 702   g_test->send_request(string("GET"), rest_req);
 703   EXPECT_EQ(200U, g_test->get_resp_code());
 704   EXPECT_EQ(get_opstate_list(entries), 0);
 705   EXPECT_EQ(entries.size(), 1U);
 706
 707   ss.str("");
 708   ss << "/admin/opstate?client-id=" << cid_2 << "&op-id=" << oid_2
 709     << "&object=" << obj_2;
 710   rest_req = ss.str();
 711   g_test->send_request(string("DELETE"), rest_req);
 712   EXPECT_EQ(200U, g_test->get_resp_code());
 713
 714   ss.str("");
 715   entries.clear();
 716   ss << "/admin/opstate";
 717   rest_req = ss.str();
 718   g_test->send_request(string("GET"), rest_req);
 719   EXPECT_EQ(200U, g_test->get_resp_code());
 720   EXPECT_EQ(get_opstate_list(entries), 0);
 721   EXPECT_EQ(entries.size(), 0U);
 722
 723   ASSERT_EQ(caps_rm(cname, perm), 0);
 724   ASSERT_EQ(user_rm(uid, display_name), 0);
 725 }
 726
 727 TEST(TestRGWAdmin, opstate_renew) {
 728   const char *cname = "opstate",
 729              *perm = "*";
 730   string rest_req;
 731   stringstream ss;
 732   string cid_1 = "cid_1";
 733   string oid_1 = "operation";
 734   string obj_1 = "obj1";
 735   string state;
 736
 737   ASSERT_EQ(user_create(uid, display_name), 0);
 738   ASSERT_EQ(0, caps_add(cname, perm));
 739
 740   rest_req = "/admin/opstate?renew&client-id=1&op-id=1&object=o";
 741   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 742   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing state*/
 743
 744   rest_req = "/admin/opstate?renew&client-id=1&op-id=1&state=in-progress";
 745   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 746   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing object*/
 747
 748   rest_req = "/admin/opstate?renew&client-id=1&state=in-progress&object=o";
 749   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 750   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing op-id*/
 751
 752   rest_req = "/admin/opstate?renew&state=in-progress&op-id=1&object=o";
 753   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 754   EXPECT_EQ(400U, g_test->get_resp_code()); /*Missing client-id*/
 755
 756   rest_req = "/admin/opstate?&renew&state=invalid&op-id=1&object=o&client-id=1";
 757   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 758   EXPECT_EQ(400U, g_test->get_resp_code()); /*Invalid state*/
 759
 760   state = "complete";
 761   ss.str("");
 762   ss << "/admin/opstate?client-id=" << cid_1 << "&op-id=" << oid_1
 763     << "&object=" << obj_1 << "&state=" << state;
 764   rest_req = ss.str();
 765   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 766   EXPECT_EQ(200U, g_test->get_resp_code());
 767
 768   rest_req = "/admin/opstate";
 769   g_test->send_request(string("GET"), rest_req);
 770   EXPECT_EQ(200U, g_test->get_resp_code());
 771
 772   ss.str("");
 773   ss << "/admin/opstate?renew&client-id=" << cid_1 << "&op-id=1"
 774     << "&object=" << obj_1 << "&state=" << state;
 775   rest_req = ss.str();
 776   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 777   EXPECT_EQ(404U, g_test->get_resp_code());
 778
 779   ss.str("");
 780   ss << "/admin/opstate?renew&client-id=" << cid_1 << "&op-id=" << oid_1
 781     << "&object=" << obj_1 << "&state=" << state;
 782   rest_req = ss.str();
 783   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 784   EXPECT_EQ(200U, g_test->get_resp_code());
 785
 786   ss.str("");
 787   ss << "/admin/opstate?renew&client-id=" << cid_1 << "&op-id=" << oid_1
 788     << "&object=" << obj_1 << "&state=in-progress";
 789   rest_req = ss.str();
 790   g_test->send_request(string("POST"), rest_req, read_dummy_post, NULL, sizeof(int));
 791   EXPECT_EQ(500U, g_test->get_resp_code());
 792
 793   ss.str("");
 794   ss << "/admin/opstate?client-id=" << cid_1 << "&op-id=" << oid_1
 795     << "&object=" << obj_1;
 796   rest_req = ss.str();
 797   g_test->send_request(string("DELETE"), rest_req);
 798   EXPECT_EQ(200U, g_test->get_resp_code());
 799
 800   ASSERT_EQ(caps_rm(cname, perm), 0);
 801   ASSERT_EQ(user_rm(uid, display_name), 0);
 802 }
 803
 804 int main(int argc, char *argv[]){
 805   vector<const char*> args;
 806   argv_to_vec(argc, (const char **)argv, args);
 807
 808   auto cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT,
 809                          CODE_ENVIRONMENT_UTILITY, 0);
 810   common_init_finish(g_ceph_context);
 811   store = RGWStoreManager::get_storage(g_ceph_context, false, false, false, false, false);
 812   g_test = new admin_log::test_helper();
 813   finisher = new Finisher(g_ceph_context);
 814 #ifdef GTEST
 815   ::testing::InitGoogleTest(&argc, argv);
 816 #endif
 817   finisher->start();
 818
 819   if(g_test->extract_input(argc, argv) < 0){
 820     print_usage(argv[0]);
 821     return -1;
 822   }
 823 #ifdef GTEST
 824   int r = RUN_ALL_TESTS();
 825   if (r >= 0) {
 826     cout << "There are no failures in the test case\n";
 827   } else {
 828     cout << "There are some failures\n";
 829   }
 830 #endif
 831   finisher->stop();
 832   return 0;
 833 }