ceph/src/cls/rgw/cls_rgw_ops.cc

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