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