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