ceph/src/cls/rgw/cls_rgw_ops.cc

   1
   2 #include "cls/rgw/cls_rgw_ops.h"
   3
   4 #include "common/Formatter.h"
   5 #include "common/ceph_json.h"
   6 #include "include/utime.h"
   7
   8 void rgw_cls_tag_timeout_op::dump(Formatter *f) const
   9 {
  10   f->dump_int("tag_timeout", tag_timeout);
  11 }
  12
  13 void rgw_cls_tag_timeout_op::generate_test_instances(list<rgw_cls_tag_timeout_op*>& ls)
  14 {
  15   ls.push_back(new rgw_cls_tag_timeout_op);
  16   ls.push_back(new rgw_cls_tag_timeout_op);
  17   ls.back()->tag_timeout = 23323;
  18 }
  19
  20 void cls_rgw_gc_set_entry_op::dump(Formatter *f) const
  21 {
  22   f->dump_unsigned("expiration_secs", expiration_secs);
  23   f->open_object_section("obj_info");
  24   info.dump(f);
  25   f->close_section();
  26 }
  27
  28 void cls_rgw_gc_set_entry_op::generate_test_instances(list<cls_rgw_gc_set_entry_op*>& ls)
  29 {
  30   ls.push_back(new cls_rgw_gc_set_entry_op);
  31   ls.push_back(new cls_rgw_gc_set_entry_op);
  32   ls.back()->expiration_secs = 123;
  33 }
  34
  35 void cls_rgw_gc_defer_entry_op::dump(Formatter *f) const
  36 {
  37   f->dump_unsigned("expiration_secs", expiration_secs);
  38   f->dump_string("tag", tag);
  39 }
  40
  41 void cls_rgw_gc_defer_entry_op::generate_test_instances(list<cls_rgw_gc_defer_entry_op*>& ls)
  42 {
  43   ls.push_back(new cls_rgw_gc_defer_entry_op);
  44   ls.push_back(new cls_rgw_gc_defer_entry_op);
  45   ls.back()->expiration_secs = 123;
  46   ls.back()->tag = "footag";
  47 }
  48
  49 void cls_rgw_gc_list_op::dump(Formatter *f) const
  50 {
  51   f->dump_string("marker", marker);
  52   f->dump_unsigned("max", max);
  53   f->dump_bool("expired_only", expired_only);
  54 }
  55
  56 void cls_rgw_gc_list_op::generate_test_instances(list<cls_rgw_gc_list_op*>& ls)
  57 {
  58   ls.push_back(new cls_rgw_gc_list_op);
  59   ls.push_back(new cls_rgw_gc_list_op);
  60   ls.back()->marker = "mymarker";
  61   ls.back()->max = 2312;
  62 }
  63
  64 void cls_rgw_gc_list_ret::dump(Formatter *f) const
  65 {
  66   encode_json("entries", entries, f);
  67   f->dump_string("next_marker", next_marker);
  68   f->dump_int("truncated", (int)truncated);
  69 }
  70
  71 void cls_rgw_gc_list_ret::generate_test_instances(list<cls_rgw_gc_list_ret*>& ls)
  72 {
  73   ls.push_back(new cls_rgw_gc_list_ret);
  74   ls.push_back(new cls_rgw_gc_list_ret);
  75   ls.back()->entries.push_back(cls_rgw_gc_obj_info());
  76   ls.back()->truncated = true;
  77 }
  78
  79
  80 void cls_rgw_gc_remove_op::dump(Formatter *f) const
  81 {
  82   encode_json("tags", tags, f);
  83 }
  84
  85 void cls_rgw_gc_remove_op::generate_test_instances(list<cls_rgw_gc_remove_op*>& ls)
  86 {
  87   ls.push_back(new cls_rgw_gc_remove_op);
  88   ls.push_back(new cls_rgw_gc_remove_op);
  89   ls.back()->tags.push_back("tag1");
  90   ls.back()->tags.push_back("tag2");
  91 }
  92
  93 void rgw_cls_obj_prepare_op::generate_test_instances(list<rgw_cls_obj_prepare_op*>& o)
  94 {
  95   rgw_cls_obj_prepare_op *op = new rgw_cls_obj_prepare_op;
  96   op->op = CLS_RGW_OP_ADD;
  97   op->key.name = "name";
  98   op->tag = "tag";
  99   op->locator = "locator";
 100   o.push_back(op);
 101   o.push_back(new rgw_cls_obj_prepare_op);
 102 }
 103
 104 void rgw_cls_obj_prepare_op::dump(Formatter *f) const
 105 {
 106   f->dump_int("op", op);
 107   f->dump_string("name", key.name);
 108   f->dump_string("tag", tag);
 109   f->dump_string("locator", locator);
 110   f->dump_bool("log_op", log_op);
 111   f->dump_int("bilog_flags", bilog_flags);
 112   ::encode_json("zones_trace", zones_trace, f);
 113 }
 114
 115 void rgw_cls_obj_complete_op::generate_test_instances(list<rgw_cls_obj_complete_op*>& o)
 116 {
 117   rgw_cls_obj_complete_op *op = new rgw_cls_obj_complete_op;
 118   op->op = CLS_RGW_OP_DEL;
 119   op->key.name = "name";
 120   op->locator = "locator";
 121   op->ver.pool = 2;
 122   op->ver.epoch = 100;
 123   op->tag = "tag";
 124
 125   list<rgw_bucket_dir_entry_meta *> l;
 126   rgw_bucket_dir_entry_meta::generate_test_instances(l);
 127   list<rgw_bucket_dir_entry_meta *>::iterator iter = l.begin();
 128   op->meta = *(*iter);
 129
 130   o.push_back(op);
 131
 132   o.push_back(new rgw_cls_obj_complete_op);
 133 }
 134
 135 void rgw_cls_obj_complete_op::dump(Formatter *f) const
 136 {
 137   f->dump_int("op", (int)op);
 138   f->dump_string("name", key.name);
 139   f->dump_string("instance", key.instance);
 140   f->dump_string("locator", locator);
 141   f->open_object_section("ver");
 142   ver.dump(f);
 143   f->close_section();
 144   f->open_object_section("meta");
 145   meta.dump(f);
 146   f->close_section();
 147   f->dump_string("tag", tag);
 148   f->dump_bool("log_op", log_op);
 149   f->dump_int("bilog_flags", bilog_flags);
 150   ::encode_json("zones_trace", zones_trace, f);
 151 }
 152
 153 void rgw_cls_link_olh_op::generate_test_instances(list<rgw_cls_link_olh_op*>& o)
 154 {
 155   rgw_cls_link_olh_op *op = new rgw_cls_link_olh_op;
 156   op->key.name = "name";
 157   op->olh_tag = "olh_tag";
 158   op->delete_marker = true;
 159   op->op_tag = "op_tag";
 160   op->olh_epoch = 123;
 161   list<rgw_bucket_dir_entry_meta *> l;
 162   rgw_bucket_dir_entry_meta::generate_test_instances(l);
 163   list<rgw_bucket_dir_entry_meta *>::iterator iter = l.begin();
 164   op->meta = *(*iter);
 165   op->log_op = true;
 166
 167   o.push_back(op);
 168
 169   o.push_back(new rgw_cls_link_olh_op);
 170 }
 171
 172 void rgw_cls_link_olh_op::dump(Formatter *f) const
 173 {
 174   ::encode_json("key", key, f);
 175   ::encode_json("olh_tag", olh_tag, f);
 176   ::encode_json("delete_marker", delete_marker, f);
 177   ::encode_json("op_tag", op_tag, f);
 178   ::encode_json("meta", meta, f);
 179   ::encode_json("olh_epoch", olh_epoch, f);
 180   ::encode_json("log_op", log_op, f);
 181   ::encode_json("bilog_flags", (uint32_t)bilog_flags, f);
 182   utime_t ut(unmod_since);
 183   ::encode_json("unmod_since", ut, f);
 184   ::encode_json("high_precision_time", high_precision_time, f);
 185   ::encode_json("zones_trace", zones_trace, f);
 186 }
 187
 188 void rgw_cls_unlink_instance_op::generate_test_instances(list<rgw_cls_unlink_instance_op*>& o)
 189 {
 190   rgw_cls_unlink_instance_op *op = new rgw_cls_unlink_instance_op;
 191   op->key.name = "name";
 192   op->op_tag = "op_tag";
 193   op->olh_epoch = 124;
 194   op->log_op = true;
 195
 196   o.push_back(op);
 197
 198   o.push_back(new rgw_cls_unlink_instance_op);
 199 }
 200
 201 void rgw_cls_unlink_instance_op::dump(Formatter *f) const
 202 {
 203   ::encode_json("key", key, f);
 204   ::encode_json("op_tag", op_tag, f);
 205   ::encode_json("olh_epoch", olh_epoch, f);
 206   ::encode_json("log_op", log_op, f);
 207   ::encode_json("bilog_flags", (uint32_t)bilog_flags, f);
 208   ::encode_json("zones_trace", zones_trace, f);
 209 }
 210
 211 void rgw_cls_read_olh_log_op::generate_test_instances(list<rgw_cls_read_olh_log_op*>& o)
 212 {
 213   rgw_cls_read_olh_log_op *op = new rgw_cls_read_olh_log_op;
 214   op->olh.name = "name";
 215   op->ver_marker = 123;
 216   op->olh_tag = "olh_tag";
 217
 218   o.push_back(op);
 219
 220   o.push_back(new rgw_cls_read_olh_log_op);
 221 }
 222
 223 void rgw_cls_read_olh_log_op::dump(Formatter *f) const
 224 {
 225   ::encode_json("olh", olh, f);
 226   ::encode_json("ver_marker", ver_marker, f);
 227   ::encode_json("olh_tag", olh_tag, f);
 228 }
 229
 230 void rgw_cls_read_olh_log_ret::generate_test_instances(list<rgw_cls_read_olh_log_ret*>& o)
 231 {
 232   rgw_cls_read_olh_log_ret *r = new rgw_cls_read_olh_log_ret;
 233   r->is_truncated = true;
 234   list<rgw_bucket_olh_log_entry *> l;
 235   rgw_bucket_olh_log_entry::generate_test_instances(l);
 236   list<rgw_bucket_olh_log_entry *>::iterator iter = l.begin();
 237   r->log[1].push_back(*(*iter));
 238
 239   o.push_back(r);
 240
 241   o.push_back(new rgw_cls_read_olh_log_ret);
 242 }
 243
 244 void rgw_cls_read_olh_log_ret::dump(Formatter *f) const
 245 {
 246   ::encode_json("log", log, f);
 247   ::encode_json("is_truncated", is_truncated, f);
 248 }
 249
 250 void rgw_cls_trim_olh_log_op::generate_test_instances(list<rgw_cls_trim_olh_log_op*>& o)
 251 {
 252   rgw_cls_trim_olh_log_op *op = new rgw_cls_trim_olh_log_op;
 253   op->olh.name = "olh.name";
 254   op->ver = 100;
 255   op->olh_tag = "olh_tag";
 256
 257   o.push_back(op);
 258
 259   o.push_back(new rgw_cls_trim_olh_log_op);
 260 }
 261
 262 void rgw_cls_trim_olh_log_op::dump(Formatter *f) const
 263 {
 264   ::encode_json("olh", olh, f);
 265   ::encode_json("ver", ver, f);
 266   ::encode_json("olh_tag", olh_tag, f);
 267 }
 268
 269 void rgw_cls_bucket_clear_olh_op::generate_test_instances(list<rgw_cls_bucket_clear_olh_op *>& o)
 270 {
 271
 272   rgw_cls_bucket_clear_olh_op *op = new rgw_cls_bucket_clear_olh_op;
 273   op->key.name = "key.name";
 274   op->olh_tag = "olh_tag";
 275
 276   o.push_back(op);
 277   o.push_back(new rgw_cls_bucket_clear_olh_op);
 278 }
 279
 280 void rgw_cls_bucket_clear_olh_op::dump(Formatter *f) const
 281 {
 282   ::encode_json("key", key, f);
 283   ::encode_json("olh_tag", olh_tag, f);
 284 }
 285
 286 void rgw_cls_list_op::generate_test_instances(list<rgw_cls_list_op*>& o)
 287 {
 288   rgw_cls_list_op *op = new rgw_cls_list_op;
 289   op->start_obj.name = "start_obj";
 290   op->num_entries = 100;
 291   op->filter_prefix = "filter_prefix";
 292   o.push_back(op);
 293   o.push_back(new rgw_cls_list_op);
 294 }
 295
 296 void rgw_cls_list_op::dump(Formatter *f) const
 297 {
 298   f->dump_string("start_obj", start_obj.name);
 299   f->dump_unsigned("num_entries", num_entries);
 300 }
 301
 302 void rgw_cls_list_ret::generate_test_instances(list<rgw_cls_list_ret*>& o)
 303 {
 304  list<rgw_bucket_dir *> l;
 305   rgw_bucket_dir::generate_test_instances(l);
 306   list<rgw_bucket_dir *>::iterator iter;
 307   for (iter = l.begin(); iter != l.end(); ++iter) {
 308     rgw_bucket_dir *d = *iter;
 309
 310     rgw_cls_list_ret *ret = new rgw_cls_list_ret;
 311     ret->dir = *d;
 312     ret->is_truncated = true;
 313
 314     o.push_back(ret);
 315
 316     delete d;
 317   }
 318
 319   o.push_back(new rgw_cls_list_ret);
 320 }
 321
 322 void rgw_cls_list_ret::dump(Formatter *f) const
 323 {
 324   f->open_object_section("dir");
 325   dir.dump(f);
 326   f->close_section();
 327   f->dump_int("is_truncated", (int)is_truncated);
 328 }
 329
 330 void rgw_cls_check_index_ret::generate_test_instances(list<rgw_cls_check_index_ret*>& o)
 331 {
 332   list<rgw_bucket_dir_header *> h;
 333   rgw_bucket_dir_header::generate_test_instances(h);
 334   rgw_cls_check_index_ret *r = new rgw_cls_check_index_ret;
 335   r->existing_header = *(h.front());
 336   r->calculated_header = *(h.front());
 337   o.push_back(r);
 338
 339   for (list<rgw_bucket_dir_header *>::iterator iter = h.begin(); iter != h.end(); ++iter) {
 340     delete *iter;
 341   }
 342   o.push_back(new rgw_cls_check_index_ret);
 343 }
 344
 345 void rgw_cls_check_index_ret::dump(Formatter *f) const
 346 {
 347   ::encode_json("existing_header", existing_header, f);
 348   ::encode_json("calculated_header", calculated_header, f);
 349 }
 350
 351 void rgw_cls_bucket_update_stats_op::generate_test_instances(list<rgw_cls_bucket_update_stats_op*>& o)
 352 {
 353   rgw_cls_bucket_update_stats_op *r = new rgw_cls_bucket_update_stats_op;
 354   r->absolute = true;
 355   rgw_bucket_category_stats& s = r->stats[0];
 356   s.total_size = 1;
 357   s.total_size_rounded = 4096;
 358   s.num_entries = 1;
 359   o.push_back(r);
 360
 361   o.push_back(new rgw_cls_bucket_update_stats_op);
 362 }
 363
 364 void rgw_cls_bucket_update_stats_op::dump(Formatter *f) const
 365 {
 366   ::encode_json("absolute", absolute, f);
 367   map<int, rgw_bucket_category_stats> s;
 368   for (auto& entry : stats) {
 369     s[(int)entry.first] = entry.second;
 370   }
 371   ::encode_json("stats", s, f);
 372 }
 373
 374 void cls_rgw_bi_log_list_op::dump(Formatter *f) const
 375 {
 376   f->dump_string("marker", marker);
 377   f->dump_unsigned("max", max);
 378 }
 379
 380 void cls_rgw_bi_log_list_op::generate_test_instances(list<cls_rgw_bi_log_list_op*>& ls)
 381 {
 382   ls.push_back(new cls_rgw_bi_log_list_op);
 383   ls.push_back(new cls_rgw_bi_log_list_op);
 384   ls.back()->marker = "mark";
 385   ls.back()->max = 123;
 386 }
 387
 388 void cls_rgw_bi_log_trim_op::dump(Formatter *f) const
 389 {
 390   f->dump_string("start_marker", start_marker);
 391   f->dump_string("end_marker", end_marker);
 392 }
 393
 394 void cls_rgw_bi_log_trim_op::generate_test_instances(list<cls_rgw_bi_log_trim_op*>& ls)
 395 {
 396   ls.push_back(new cls_rgw_bi_log_trim_op);
 397   ls.push_back(new cls_rgw_bi_log_trim_op);
 398   ls.back()->start_marker = "foo";
 399   ls.back()->end_marker = "bar";
 400 }
 401
 402 void cls_rgw_bi_log_list_ret::dump(Formatter *f) const
 403 {
 404   encode_json("entries", entries, f);
 405   f->dump_unsigned("truncated", (int)truncated);
 406 }
 407
 408 void cls_rgw_bi_log_list_ret::generate_test_instances(list<cls_rgw_bi_log_list_ret*>& ls)
 409 {
 410   ls.push_back(new cls_rgw_bi_log_list_ret);
 411   ls.push_back(new cls_rgw_bi_log_list_ret);
 412   ls.back()->entries.push_back(rgw_bi_log_entry());
 413   ls.back()->truncated = true;
 414 }
 415
 416 void cls_rgw_reshard_add_op::generate_test_instances(list<cls_rgw_reshard_add_op*>& ls)
 417 {
 418   ls.push_back(new cls_rgw_reshard_add_op);
 419   ls.push_back(new cls_rgw_reshard_add_op);
 420   list<cls_rgw_reshard_entry *> l;
 421   cls_rgw_reshard_entry::generate_test_instances(l);
 422   list<cls_rgw_reshard_entry *>::iterator iter = l.begin();
 423   ls.back()->entry = *(*iter);
 424 }
 425
 426 void cls_rgw_reshard_add_op::dump(Formatter *f) const
 427 {
 428   ::encode_json("entry", entry, f);
 429 }
 430
 431 void cls_rgw_reshard_list_op::generate_test_instances(list<cls_rgw_reshard_list_op*>& ls)
 432 {
 433   ls.push_back(new cls_rgw_reshard_list_op);
 434   ls.push_back(new cls_rgw_reshard_list_op);
 435   ls.back()->max = 1000;
 436   ls.back()->marker = "foo";
 437 }
 438
 439 void cls_rgw_reshard_list_op::dump(Formatter *f) const
 440 {
 441   ::encode_json("max", max, f);
 442   ::encode_json("marker", marker, f);
 443 }
 444
 445 void cls_rgw_reshard_list_ret::generate_test_instances(list<cls_rgw_reshard_list_ret*>& ls)
 446 {
 447   ls.push_back(new cls_rgw_reshard_list_ret);
 448   ls.push_back(new cls_rgw_reshard_list_ret);
 449   ls.back()->entries.push_back(cls_rgw_reshard_entry());
 450   ls.back()->is_truncated = true;
 451 }
 452
 453 void cls_rgw_reshard_list_ret::dump(Formatter *f) const
 454 {
 455   ::encode_json("entries", entries, f);
 456   ::encode_json("is_truncated", is_truncated, f);
 457 }
 458
 459 void cls_rgw_reshard_get_op::generate_test_instances(list<cls_rgw_reshard_get_op*>& ls)
 460 {
 461   ls.push_back(new cls_rgw_reshard_get_op);
 462   ls.push_back(new cls_rgw_reshard_get_op);
 463 }
 464
 465 void cls_rgw_reshard_get_op::dump(Formatter *f) const
 466 {
 467   ::encode_json("entry", entry, f);
 468 }
 469
 470 void cls_rgw_reshard_get_ret::generate_test_instances(list<cls_rgw_reshard_get_ret*>& ls)
 471 {
 472   ls.push_back(new cls_rgw_reshard_get_ret);
 473   ls.push_back(new cls_rgw_reshard_get_ret);
 474 }
 475
 476 void cls_rgw_reshard_get_ret::dump(Formatter *f) const
 477 {
 478   ::encode_json("entry", entry, f);
 479 }
 480
 481 void cls_rgw_reshard_remove_op::generate_test_instances(list<cls_rgw_reshard_remove_op*>& ls)
 482 {
 483   ls.push_back(new cls_rgw_reshard_remove_op);
 484   ls.push_back(new cls_rgw_reshard_remove_op);
 485   ls.back()->bucket_name = "foo";
 486   ls.back()->bucket_id = "bucket_id";
 487 }
 488
 489 void cls_rgw_reshard_remove_op::dump(Formatter *f) const
 490 {
 491   ::encode_json("bucket_name", bucket_name, f);
 492   ::encode_json("bucket_id", bucket_name, f);
 493 }
 494
 495
 496 void cls_rgw_set_bucket_resharding_op::generate_test_instances(
 497   list<cls_rgw_set_bucket_resharding_op*>& ls)
 498 {
 499   ls.push_back(new cls_rgw_set_bucket_resharding_op);
 500   ls.push_back(new cls_rgw_set_bucket_resharding_op);
 501 }
 502
 503 void cls_rgw_set_bucket_resharding_op::dump(Formatter *f) const
 504 {
 505   ::encode_json("entry", entry, f);
 506 }
 507
 508 void cls_rgw_clear_bucket_resharding_op::generate_test_instances(
 509   list<cls_rgw_clear_bucket_resharding_op*>& ls)
 510 {
 511   ls.push_back(new cls_rgw_clear_bucket_resharding_op);
 512   ls.push_back(new cls_rgw_clear_bucket_resharding_op);
 513 }
 514
 515 void cls_rgw_clear_bucket_resharding_op::dump(Formatter *f) const
 516 {
 517 }
 518
 519 void cls_rgw_guard_bucket_resharding_op::generate_test_instances(
 520   list<cls_rgw_guard_bucket_resharding_op*>& ls)
 521 {
 522   ls.push_back(new cls_rgw_guard_bucket_resharding_op);
 523   ls.push_back(new cls_rgw_guard_bucket_resharding_op);
 524 }
 525
 526 void cls_rgw_guard_bucket_resharding_op::dump(Formatter *f) const
 527 {
 528   ::encode_json("ret_err", ret_err, f);
 529 }
 530
 531
 532 void cls_rgw_get_bucket_resharding_op::generate_test_instances(
 533   list<cls_rgw_get_bucket_resharding_op*>& ls)
 534 {
 535   ls.push_back(new cls_rgw_get_bucket_resharding_op);
 536   ls.push_back(new cls_rgw_get_bucket_resharding_op);
 537 }
 538
 539 void cls_rgw_get_bucket_resharding_op::dump(Formatter *f) const
 540 {
 541 }
 542
 543
 544
 545
 546