ceph/src/cls/rgw/cls_rgw_types.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_types.h"
   5 #include "common/ceph_json.h"
   6 #include "include/utime.h"
   7
   8
   9 void rgw_zone_set_entry::from_str(const string& s)
  10 {
  11   auto pos = s.find(':');
  12   if (pos == string::npos) {
  13     zone = s;
  14     location_key.reset();
  15   } else {
  16     zone = s.substr(0, pos);
  17     location_key = s.substr(pos + 1);
  18   }
  19 }
  20
  21 string rgw_zone_set_entry::to_str() const
  22 {
  23   string s = zone;
  24   if (location_key) {
  25     s = s + ":" + *location_key;
  26   }
  27   return s;
  28 }
  29
  30 void rgw_zone_set_entry::encode(bufferlist &bl) const
  31 {
  32   /* no ENCODE_START, ENCODE_END for backward compatibility */
  33   ceph::encode(to_str(), bl);
  34 }
  35
  36 void rgw_zone_set_entry::decode(bufferlist::const_iterator &bl)
  37 {
  38   /* no DECODE_START, DECODE_END for backward compatibility */
  39   string s;
  40   ceph::decode(s, bl);
  41   from_str(s);
  42 }
  43
  44 void rgw_zone_set_entry::dump(Formatter *f) const
  45 {
  46   encode_json("entry", to_str(), f);
  47 }
  48
  49 void rgw_zone_set_entry::decode_json(JSONObj *obj) {
  50   string s;
  51   JSONDecoder::decode_json("entry", s, obj);
  52   from_str(s);
  53 }
  54
  55 void rgw_zone_set::insert(const string& zone, std::optional<string> location_key)
  56 {
  57   entries.insert(rgw_zone_set_entry(zone, location_key));
  58 }
  59
  60 bool rgw_zone_set::exists(const string& zone, std::optional<string> location_key) const
  61 {
  62   return entries.find(rgw_zone_set_entry(zone, location_key)) != entries.end();
  63 }
  64
  65 void encode_json(const char *name, const rgw_zone_set& zs, ceph::Formatter *f)
  66 {
  67   encode_json(name, zs.entries, f);
  68 }
  69
  70 void decode_json_obj(rgw_zone_set& zs, JSONObj *obj)
  71 {
  72   decode_json_obj(zs.entries, obj);
  73 }
  74
  75 void rgw_bucket_pending_info::generate_test_instances(list<rgw_bucket_pending_info*>& o)
  76 {
  77   rgw_bucket_pending_info *i = new rgw_bucket_pending_info;
  78   i->state = CLS_RGW_STATE_COMPLETE;
  79   i->op = CLS_RGW_OP_DEL;
  80   o.push_back(i);
  81   o.push_back(new rgw_bucket_pending_info);
  82 }
  83
  84 void rgw_bucket_pending_info::dump(Formatter *f) const
  85 {
  86   encode_json("state", (int)state, f);
  87   utime_t ut(timestamp);
  88   encode_json("timestamp", ut, f);
  89   encode_json("op", (int)op, f);
  90 }
  91
  92 void rgw_bucket_pending_info::decode_json(JSONObj *obj) {
  93   int val;
  94   JSONDecoder::decode_json("state", val, obj);
  95   state = (RGWPendingState)val;
  96   utime_t ut(timestamp);
  97   JSONDecoder::decode_json("timestamp", ut, obj);
  98   JSONDecoder::decode_json("op", val, obj);
  99   op = (uint8_t)val;
 100 }
 101
 102 void cls_rgw_obj_key::decode_json(JSONObj *obj) {
 103   JSONDecoder::decode_json("name", name, obj);
 104   JSONDecoder::decode_json("instance", instance, obj);
 105 }
 106
 107 void rgw_bucket_dir_entry_meta::generate_test_instances(list<rgw_bucket_dir_entry_meta*>& o)
 108 {
 109   rgw_bucket_dir_entry_meta *m = new rgw_bucket_dir_entry_meta;
 110   m->category = RGWObjCategory::Main;
 111   m->size = 100;
 112   m->etag = "etag";
 113   m->owner = "owner";
 114   m->owner_display_name = "display name";
 115   m->content_type = "content/type";
 116   o.push_back(m);
 117   o.push_back(new rgw_bucket_dir_entry_meta);
 118 }
 119
 120 void rgw_bucket_dir_entry_meta::dump(Formatter *f) const
 121 {
 122   encode_json("category", (int)category, f);
 123   encode_json("size", size, f);
 124   utime_t ut(mtime);
 125   encode_json("mtime", ut, f);
 126   encode_json("etag", etag, f);
 127   encode_json("storage_class", storage_class, f);
 128   encode_json("owner", owner, f);
 129   encode_json("owner_display_name", owner_display_name, f);
 130   encode_json("content_type", content_type, f);
 131   encode_json("accounted_size", accounted_size, f);
 132   encode_json("user_data", user_data, f);
 133   encode_json("appendable", appendable, f);
 134 }
 135
 136 void rgw_bucket_dir_entry_meta::decode_json(JSONObj *obj) {
 137   int val;
 138   JSONDecoder::decode_json("category", val, obj);
 139   category = static_cast<RGWObjCategory>(val);
 140   JSONDecoder::decode_json("size", size, obj);
 141   utime_t ut;
 142   JSONDecoder::decode_json("mtime", ut, obj);
 143   mtime = ut.to_real_time();
 144   JSONDecoder::decode_json("etag", etag, obj);
 145   JSONDecoder::decode_json("storage_class", storage_class, obj);
 146   JSONDecoder::decode_json("owner", owner, obj);
 147   JSONDecoder::decode_json("owner_display_name", owner_display_name, obj);
 148   JSONDecoder::decode_json("content_type", content_type, obj);
 149   JSONDecoder::decode_json("accounted_size", accounted_size, obj);
 150   JSONDecoder::decode_json("user_data", user_data, obj);
 151   JSONDecoder::decode_json("appendable", appendable, obj);
 152 }
 153
 154 void rgw_bucket_dir_entry::generate_test_instances(list<rgw_bucket_dir_entry*>& o)
 155 {
 156   list<rgw_bucket_dir_entry_meta *> l;
 157   rgw_bucket_dir_entry_meta::generate_test_instances(l);
 158
 159   list<rgw_bucket_dir_entry_meta *>::iterator iter;
 160   for (iter = l.begin(); iter != l.end(); ++iter) {
 161     rgw_bucket_dir_entry_meta *m = *iter;
 162     rgw_bucket_dir_entry *e = new rgw_bucket_dir_entry;
 163     e->key.name = "name";
 164     e->ver.pool = 1;
 165     e->ver.epoch = 1234;
 166     e->locator = "locator";
 167     e->exists = true;
 168     e->meta = *m;
 169     e->tag = "tag";
 170
 171     o.push_back(e);
 172
 173     delete m;
 174   }
 175   o.push_back(new rgw_bucket_dir_entry);
 176 }
 177
 178 void rgw_bucket_entry_ver::dump(Formatter *f) const
 179 {
 180   encode_json("pool", pool, f);
 181   encode_json("epoch", epoch, f);
 182 }
 183
 184 void rgw_bucket_entry_ver::decode_json(JSONObj *obj) {
 185   JSONDecoder::decode_json("pool", pool, obj);
 186   JSONDecoder::decode_json("epoch", epoch, obj);
 187 }
 188
 189 void rgw_bucket_entry_ver::generate_test_instances(list<rgw_bucket_entry_ver*>& ls)
 190 {
 191   ls.push_back(new rgw_bucket_entry_ver);
 192   ls.push_back(new rgw_bucket_entry_ver);
 193   ls.back()->pool = 123;
 194   ls.back()->epoch = 12322;
 195 }
 196
 197
 198 void rgw_bucket_dir_entry::dump(Formatter *f) const
 199 {
 200   encode_json("name", key.name, f);
 201   encode_json("instance", key.instance , f);
 202   encode_json("ver", ver , f);
 203   encode_json("locator", locator , f);
 204   encode_json("exists", exists , f);
 205   encode_json("meta", meta , f);
 206   encode_json("tag", tag , f);
 207   encode_json("flags", (int)flags , f);
 208   encode_json("pending_map", pending_map, f);
 209   encode_json("versioned_epoch", versioned_epoch , f);
 210 }
 211
 212 void rgw_bucket_dir_entry::decode_json(JSONObj *obj) {
 213   JSONDecoder::decode_json("name", key.name, obj);
 214   JSONDecoder::decode_json("instance", key.instance , obj);
 215   JSONDecoder::decode_json("ver", ver , obj);
 216   JSONDecoder::decode_json("locator", locator , obj);
 217   JSONDecoder::decode_json("exists", exists , obj);
 218   JSONDecoder::decode_json("meta", meta , obj);
 219   JSONDecoder::decode_json("tag", tag , obj);
 220   int val;
 221   JSONDecoder::decode_json("flags", val , obj);
 222   flags = (uint16_t)val;
 223   JSONDecoder::decode_json("pending_map", pending_map, obj);
 224   JSONDecoder::decode_json("versioned_epoch", versioned_epoch, obj);
 225 }
 226
 227 static void dump_bi_entry(bufferlist bl, BIIndexType index_type, Formatter *formatter)
 228 {
 229   auto iter = bl.cbegin();
 230   switch (index_type) {
 231     case BIIndexType::Plain:
 232     case BIIndexType::Instance:
 233       {
 234         rgw_bucket_dir_entry entry;
 235         decode(entry, iter);
 236         encode_json("entry", entry, formatter);
 237       }
 238       break;
 239     case BIIndexType::OLH:
 240       {
 241         rgw_bucket_olh_entry entry;
 242         decode(entry, iter);
 243         encode_json("entry", entry, formatter);
 244       }
 245       break;
 246     default:
 247       break;
 248   }
 249 }
 250
 251 void rgw_cls_bi_entry::decode_json(JSONObj *obj, cls_rgw_obj_key *effective_key) {
 252   JSONDecoder::decode_json("idx", idx, obj);
 253   string s;
 254   JSONDecoder::decode_json("type", s, obj);
 255   if (s == "plain") {
 256     type = BIIndexType::Plain;
 257   } else if (s == "instance") {
 258     type = BIIndexType::Instance;
 259   } else if (s == "olh") {
 260     type = BIIndexType::OLH;
 261   } else {
 262     type = BIIndexType::Invalid;
 263   }
 264   using ceph::encode;
 265   switch (type) {
 266     case BIIndexType::Plain:
 267     case BIIndexType::Instance:
 268       {
 269         rgw_bucket_dir_entry entry;
 270         JSONDecoder::decode_json("entry", entry, obj);
 271         encode(entry, data);
 272
 273         if (effective_key) {
 274           *effective_key = entry.key;
 275         }
 276       }
 277       break;
 278     case BIIndexType::OLH:
 279       {
 280         rgw_bucket_olh_entry entry;
 281         JSONDecoder::decode_json("entry", entry, obj);
 282         encode(entry, data);
 283
 284         if (effective_key) {
 285           *effective_key = entry.key;
 286         }
 287       }
 288       break;
 289     default:
 290       break;
 291   }
 292 }
 293
 294 void rgw_cls_bi_entry::dump(Formatter *f) const
 295 {
 296   string type_str;
 297   switch (type) {
 298   case BIIndexType::Plain:
 299     type_str = "plain";
 300     break;
 301   case BIIndexType::Instance:
 302     type_str = "instance";
 303     break;
 304   case BIIndexType::OLH:
 305     type_str = "olh";
 306     break;
 307   default:
 308     type_str = "invalid";
 309   }
 310   encode_json("type", type_str, f);
 311   encode_json("idx", idx, f);
 312   dump_bi_entry(data, type, f);
 313 }
 314
 315 bool rgw_cls_bi_entry::get_info(cls_rgw_obj_key *key,
 316                                 RGWObjCategory *category,
 317                                 rgw_bucket_category_stats *accounted_stats)
 318 {
 319   bool account = false;
 320   auto iter = data.cbegin();
 321   using ceph::decode;
 322   switch (type) {
 323     case BIIndexType::Plain:
 324         account = true;
 325         // NO BREAK; falls through to case InstanceIdx:
 326     case BIIndexType::Instance:
 327       {
 328         rgw_bucket_dir_entry entry;
 329         decode(entry, iter);
 330         account = (account && entry.exists);
 331         *key = entry.key;
 332         *category = entry.meta.category;
 333         accounted_stats->num_entries++;
 334         accounted_stats->total_size += entry.meta.accounted_size;
 335         accounted_stats->total_size_rounded += cls_rgw_get_rounded_size(entry.meta.accounted_size);
 336         accounted_stats->actual_size += entry.meta.size;
 337       }
 338       break;
 339     case BIIndexType::OLH:
 340       {
 341         rgw_bucket_olh_entry entry;
 342         decode(entry, iter);
 343         *key = entry.key;
 344       }
 345       break;
 346     default:
 347       break;
 348   }
 349
 350   return account;
 351 }
 352
 353 void rgw_bucket_olh_entry::dump(Formatter *f) const
 354 {
 355   encode_json("key", key, f);
 356   encode_json("delete_marker", delete_marker, f);
 357   encode_json("epoch", epoch, f);
 358   encode_json("pending_log", pending_log, f);
 359   encode_json("tag", tag, f);
 360   encode_json("exists", exists, f);
 361   encode_json("pending_removal", pending_removal, f);
 362 }
 363
 364 void rgw_bucket_olh_entry::decode_json(JSONObj *obj)
 365 {
 366   JSONDecoder::decode_json("key", key, obj);
 367   JSONDecoder::decode_json("delete_marker", delete_marker, obj);
 368   JSONDecoder::decode_json("epoch", epoch, obj);
 369   JSONDecoder::decode_json("pending_log", pending_log, obj);
 370   JSONDecoder::decode_json("tag", tag, obj);
 371   JSONDecoder::decode_json("exists", exists, obj);
 372   JSONDecoder::decode_json("pending_removal", pending_removal, obj);
 373 }
 374
 375 void rgw_bucket_olh_log_entry::generate_test_instances(list<rgw_bucket_olh_log_entry*>& o)
 376 {
 377   rgw_bucket_olh_log_entry *entry = new rgw_bucket_olh_log_entry;
 378   entry->epoch = 1234;
 379   entry->op = CLS_RGW_OLH_OP_LINK_OLH;
 380   entry->op_tag = "op_tag";
 381   entry->key.name = "key.name";
 382   entry->key.instance = "key.instance";
 383   entry->delete_marker = true;
 384   o.push_back(entry);
 385   o.push_back(new rgw_bucket_olh_log_entry);
 386 }
 387
 388 void rgw_bucket_olh_log_entry::dump(Formatter *f) const
 389 {
 390   encode_json("epoch", epoch, f);
 391   const char *op_str;
 392   switch (op) {
 393     case CLS_RGW_OLH_OP_LINK_OLH:
 394       op_str = "link_olh";
 395       break;
 396     case CLS_RGW_OLH_OP_UNLINK_OLH:
 397       op_str = "unlink_olh";
 398       break;
 399     case CLS_RGW_OLH_OP_REMOVE_INSTANCE:
 400       op_str = "remove_instance";
 401       break;
 402     default:
 403       op_str = "unknown";
 404   }
 405   encode_json("op", op_str, f);
 406   encode_json("op_tag", op_tag, f);
 407   encode_json("key", key, f);
 408   encode_json("delete_marker", delete_marker, f);
 409 }
 410
 411 void rgw_bucket_olh_log_entry::decode_json(JSONObj *obj)
 412 {
 413   JSONDecoder::decode_json("epoch", epoch, obj);
 414   string op_str;
 415   JSONDecoder::decode_json("op", op_str, obj);
 416   if (op_str == "link_olh") {
 417     op = CLS_RGW_OLH_OP_LINK_OLH;
 418   } else if (op_str == "unlink_olh") {
 419     op = CLS_RGW_OLH_OP_UNLINK_OLH;
 420   } else if (op_str == "remove_instance") {
 421     op = CLS_RGW_OLH_OP_REMOVE_INSTANCE;
 422   } else {
 423     op = CLS_RGW_OLH_OP_UNKNOWN;
 424   }
 425   JSONDecoder::decode_json("op_tag", op_tag, obj);
 426   JSONDecoder::decode_json("key", key, obj);
 427   JSONDecoder::decode_json("delete_marker", delete_marker, obj);
 428 }
 429 void rgw_bi_log_entry::decode_json(JSONObj *obj)
 430 {
 431   JSONDecoder::decode_json("op_id", id, obj);
 432   JSONDecoder::decode_json("op_tag", tag, obj);
 433   string op_str;
 434   JSONDecoder::decode_json("op", op_str, obj);
 435   if (op_str == "write") {
 436     op = CLS_RGW_OP_ADD;
 437   } else if (op_str == "del") {
 438     op = CLS_RGW_OP_DEL;
 439   } else if (op_str == "cancel") {
 440     op = CLS_RGW_OP_CANCEL;
 441   } else if (op_str == "unknown") {
 442     op = CLS_RGW_OP_UNKNOWN;
 443   } else if (op_str == "link_olh") {
 444     op = CLS_RGW_OP_LINK_OLH;
 445   } else if (op_str == "link_olh_del") {
 446     op = CLS_RGW_OP_LINK_OLH_DM;
 447   } else if (op_str == "unlink_instance") {
 448     op = CLS_RGW_OP_UNLINK_INSTANCE;
 449   } else if (op_str == "syncstop") {
 450     op = CLS_RGW_OP_SYNCSTOP;
 451   } else if (op_str == "resync") {
 452     op = CLS_RGW_OP_RESYNC;
 453   } else {
 454     op = CLS_RGW_OP_UNKNOWN;
 455   }
 456   JSONDecoder::decode_json("object", object, obj);
 457   JSONDecoder::decode_json("instance", instance, obj);
 458   string state_str;
 459   JSONDecoder::decode_json("state", state_str, obj);
 460   if (state_str == "pending") {
 461     state = CLS_RGW_STATE_PENDING_MODIFY;
 462   } else if (state_str == "complete") {
 463     state = CLS_RGW_STATE_COMPLETE;
 464   } else {
 465     state = CLS_RGW_STATE_UNKNOWN;
 466   }
 467   JSONDecoder::decode_json("index_ver", index_ver, obj);
 468   utime_t ut;
 469   JSONDecoder::decode_json("timestamp", ut, obj);
 470   timestamp = ut.to_real_time();
 471   uint32_t f;
 472   JSONDecoder::decode_json("bilog_flags", f, obj);
 473   JSONDecoder::decode_json("ver", ver, obj);
 474   bilog_flags = (uint16_t)f;
 475   JSONDecoder::decode_json("owner", owner, obj);
 476   JSONDecoder::decode_json("owner_display_name", owner_display_name, obj);
 477   JSONDecoder::decode_json("zones_trace", zones_trace, obj);
 478 }
 479
 480 void rgw_bi_log_entry::dump(Formatter *f) const
 481 {
 482   f->dump_string("op_id", id);
 483   f->dump_string("op_tag", tag);
 484   switch (op) {
 485     case CLS_RGW_OP_ADD:
 486       f->dump_string("op", "write");
 487       break;
 488     case CLS_RGW_OP_DEL:
 489       f->dump_string("op", "del");
 490       break;
 491     case CLS_RGW_OP_CANCEL:
 492       f->dump_string("op", "cancel");
 493       break;
 494     case CLS_RGW_OP_UNKNOWN:
 495       f->dump_string("op", "unknown");
 496       break;
 497     case CLS_RGW_OP_LINK_OLH:
 498       f->dump_string("op", "link_olh");
 499       break;
 500     case CLS_RGW_OP_LINK_OLH_DM:
 501       f->dump_string("op", "link_olh_del");
 502       break;
 503     case CLS_RGW_OP_UNLINK_INSTANCE:
 504       f->dump_string("op", "unlink_instance");
 505       break;
 506     case CLS_RGW_OP_SYNCSTOP:
 507       f->dump_string("op", "syncstop");
 508       break;
 509     case CLS_RGW_OP_RESYNC:
 510       f->dump_string("op", "resync");
 511       break;
 512     default:
 513       f->dump_string("op", "invalid");
 514       break;
 515   }
 516
 517   f->dump_string("object", object);
 518   f->dump_string("instance", instance);
 519
 520   switch (state) {
 521     case CLS_RGW_STATE_PENDING_MODIFY:
 522       f->dump_string("state", "pending");
 523       break;
 524     case CLS_RGW_STATE_COMPLETE:
 525       f->dump_string("state", "complete");
 526       break;
 527     default:
 528       f->dump_string("state", "invalid");
 529       break;
 530   }
 531
 532   f->dump_int("index_ver", index_ver);
 533   utime_t ut(timestamp);
 534   ut.gmtime_nsec(f->dump_stream("timestamp"));
 535   f->open_object_section("ver");
 536   ver.dump(f);
 537   f->close_section();
 538   f->dump_int("bilog_flags", bilog_flags);
 539   f->dump_bool("versioned", (bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0);
 540   f->dump_string("owner", owner);
 541   f->dump_string("owner_display_name", owner_display_name);
 542   encode_json("zones_trace", zones_trace, f);
 543 }
 544
 545 void rgw_bi_log_entry::generate_test_instances(list<rgw_bi_log_entry*>& ls)
 546 {
 547   ls.push_back(new rgw_bi_log_entry);
 548   ls.push_back(new rgw_bi_log_entry);
 549   ls.back()->id = "midf";
 550   ls.back()->object = "obj";
 551   ls.back()->timestamp = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)});
 552   ls.back()->index_ver = 4323;
 553   ls.back()->tag = "tagasdfds";
 554   ls.back()->op = CLS_RGW_OP_DEL;
 555   ls.back()->state = CLS_RGW_STATE_PENDING_MODIFY;
 556 }
 557
 558 void rgw_bucket_category_stats::generate_test_instances(list<rgw_bucket_category_stats*>& o)
 559 {
 560   rgw_bucket_category_stats *s = new rgw_bucket_category_stats;
 561   s->total_size = 1024;
 562   s->total_size_rounded = 4096;
 563   s->num_entries = 2;
 564   s->actual_size = 1024;
 565   o.push_back(s);
 566   o.push_back(new rgw_bucket_category_stats);
 567 }
 568
 569 void rgw_bucket_category_stats::dump(Formatter *f) const
 570 {
 571   f->dump_unsigned("total_size", total_size);
 572   f->dump_unsigned("total_size_rounded", total_size_rounded);
 573   f->dump_unsigned("num_entries", num_entries);
 574   f->dump_unsigned("actual_size", actual_size);
 575 }
 576
 577 void rgw_bucket_dir_header::generate_test_instances(list<rgw_bucket_dir_header*>& o)
 578 {
 579   list<rgw_bucket_category_stats *> l;
 580   list<rgw_bucket_category_stats *>::iterator iter;
 581   rgw_bucket_category_stats::generate_test_instances(l);
 582
 583   uint8_t i;
 584   for (i = 0, iter = l.begin(); iter != l.end(); ++iter, ++i) {
 585     RGWObjCategory c = static_cast<RGWObjCategory>(i);
 586     rgw_bucket_dir_header *h = new rgw_bucket_dir_header;
 587     rgw_bucket_category_stats *s = *iter;
 588     h->stats[c] = *s;
 589
 590     o.push_back(h);
 591
 592     delete s;
 593   }
 594
 595   o.push_back(new rgw_bucket_dir_header);
 596 }
 597
 598 void rgw_bucket_dir_header::dump(Formatter *f) const
 599 {
 600   f->dump_int("ver", ver);
 601   f->dump_int("master_ver", master_ver);
 602   f->open_array_section("stats");
 603   for (auto iter = stats.begin(); iter != stats.end(); ++iter) {
 604     f->dump_int("category", int(iter->first));
 605     f->open_object_section("category_stats");
 606     iter->second.dump(f);
 607     f->close_section();
 608   }
 609   f->close_section();
 610   ::encode_json("new_instance", new_instance, f);
 611 }
 612
 613 void rgw_bucket_dir::generate_test_instances(list<rgw_bucket_dir*>& o)
 614 {
 615   list<rgw_bucket_dir_header *> l;
 616   list<rgw_bucket_dir_header *>::iterator iter;
 617   rgw_bucket_dir_header::generate_test_instances(l);
 618
 619   uint8_t i;
 620   for (i = 0, iter = l.begin(); iter != l.end(); ++iter, ++i) {
 621     rgw_bucket_dir *d = new rgw_bucket_dir;
 622     rgw_bucket_dir_header *h = *iter;
 623     d->header = *h;
 624
 625     list<rgw_bucket_dir_entry *> el;
 626     list<rgw_bucket_dir_entry *>::iterator eiter;
 627     for (eiter = el.begin(); eiter != el.end(); ++eiter) {
 628       rgw_bucket_dir_entry *e = *eiter;
 629       d->m[e->key.name] = *e;
 630
 631       delete e;
 632     }
 633
 634     o.push_back(d);
 635
 636     delete h;
 637   }
 638
 639   o.push_back(new rgw_bucket_dir);
 640 }
 641
 642 void rgw_bucket_dir::dump(Formatter *f) const
 643 {
 644   f->open_object_section("header");
 645   header.dump(f);
 646   f->close_section();
 647   auto iter = m.cbegin();
 648   f->open_array_section("map");
 649   for (; iter != m.cend(); ++iter) {
 650     f->dump_string("key", iter->first);
 651     f->open_object_section("dir_entry");
 652     iter->second.dump(f);
 653     f->close_section();
 654   }
 655   f->close_section();
 656 }
 657
 658 void rgw_usage_log_entry::dump(Formatter *f) const
 659 {
 660   f->dump_string("owner", owner.to_str());
 661   f->dump_string("payer", payer.to_str());
 662   f->dump_string("bucket", bucket);
 663   f->dump_unsigned("epoch", epoch);
 664
 665   f->open_object_section("total_usage");
 666   f->dump_unsigned("bytes_sent", total_usage.bytes_sent);
 667   f->dump_unsigned("bytes_received", total_usage.bytes_received);
 668   f->dump_unsigned("ops", total_usage.ops);
 669   f->dump_unsigned("successful_ops", total_usage.successful_ops);
 670   f->close_section();
 671
 672   f->open_array_section("categories");
 673   if (usage_map.size() > 0) {
 674     map<string, rgw_usage_data>::const_iterator it;
 675     for (it = usage_map.begin(); it != usage_map.end(); it++) {
 676       const rgw_usage_data& total_usage = it->second;
 677       f->open_object_section("entry");
 678       f->dump_string("category", it->first.c_str());
 679       f->dump_unsigned("bytes_sent", total_usage.bytes_sent);
 680       f->dump_unsigned("bytes_received", total_usage.bytes_received);
 681       f->dump_unsigned("ops", total_usage.ops);
 682       f->dump_unsigned("successful_ops", total_usage.successful_ops);
 683       f->close_section();
 684     }
 685   }
 686   f->close_section();
 687 }
 688
 689 void rgw_usage_log_entry::generate_test_instances(list<rgw_usage_log_entry *> &o)
 690 {
 691   rgw_usage_log_entry *entry = new rgw_usage_log_entry;
 692   rgw_usage_data usage_data{1024, 2048};
 693   entry->owner = rgw_user("owner");
 694   entry->payer = rgw_user("payer");
 695   entry->bucket = "bucket";
 696   entry->epoch = 1234;
 697   entry->total_usage.bytes_sent = usage_data.bytes_sent;
 698   entry->total_usage.bytes_received = usage_data.bytes_received;
 699   entry->total_usage.ops = usage_data.ops;
 700   entry->total_usage.successful_ops = usage_data.successful_ops;
 701   entry->usage_map["get_obj"] = usage_data;
 702   o.push_back(entry);
 703   o.push_back(new rgw_usage_log_entry);
 704 }
 705
 706 void cls_rgw_reshard_entry::generate_key(const string& tenant, const string& bucket_name, string *key)
 707 {
 708   *key = tenant + ":" + bucket_name;
 709 }
 710
 711 void cls_rgw_reshard_entry::get_key(string *key) const
 712 {
 713   generate_key(tenant, bucket_name, key);
 714 }
 715
 716 void cls_rgw_reshard_entry::dump(Formatter *f) const
 717 {
 718   utime_t ut(time);
 719   encode_json("time",ut, f);
 720   encode_json("tenant", tenant, f);
 721   encode_json("bucket_name", bucket_name, f);
 722   encode_json("bucket_id", bucket_id, f);
 723   encode_json("new_instance_id", new_instance_id, f);
 724   encode_json("old_num_shards", old_num_shards, f);
 725   encode_json("new_num_shards", new_num_shards, f);
 726
 727 }
 728
 729 void cls_rgw_reshard_entry::generate_test_instances(list<cls_rgw_reshard_entry*>& ls)
 730 {
 731   ls.push_back(new cls_rgw_reshard_entry);
 732   ls.push_back(new cls_rgw_reshard_entry);
 733   ls.back()->time = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)});
 734   ls.back()->tenant = "tenant";
 735   ls.back()->bucket_name = "bucket1""";
 736   ls.back()->bucket_id = "bucket_id";
 737   ls.back()->new_instance_id = "new_instance_id";
 738   ls.back()->old_num_shards = 8;
 739   ls.back()->new_num_shards = 64;
 740 }
 741
 742 void cls_rgw_bucket_instance_entry::dump(Formatter *f) const
 743 {
 744   encode_json("reshard_status", to_string(reshard_status), f);
 745   encode_json("new_bucket_instance_id", new_bucket_instance_id, f);
 746   encode_json("num_shards", num_shards, f);
 747
 748 }
 749
 750 void cls_rgw_bucket_instance_entry::generate_test_instances(
 751   list<cls_rgw_bucket_instance_entry*>& ls)
 752 {
 753   ls.push_back(new cls_rgw_bucket_instance_entry);
 754   ls.push_back(new cls_rgw_bucket_instance_entry);
 755   ls.back()->reshard_status = RESHARD_STATUS::IN_PROGRESS;
 756   ls.back()->new_bucket_instance_id = "new_instance_id";
 757 }
 758
 759 void cls_rgw_lc_obj_head::dump(Formatter *f) const
 760 {
 761   encode_json("start_date", start_date, f);
 762   encode_json("marker", marker, f);
 763 }
 764
 765 void cls_rgw_lc_obj_head::generate_test_instances(list<cls_rgw_lc_obj_head*>& ls)
 766 {
 767 }