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         *key = entry.key;
 331         *category = entry.meta.category;
 332         accounted_stats->num_entries++;
 333         accounted_stats->total_size += entry.meta.accounted_size;
 334         accounted_stats->total_size_rounded += cls_rgw_get_rounded_size(entry.meta.accounted_size);
 335         accounted_stats->actual_size += entry.meta.size;
 336       }
 337       break;
 338     case BIIndexType::OLH:
 339       {
 340         rgw_bucket_olh_entry entry;
 341         decode(entry, iter);
 342         *key = entry.key;
 343       }
 344       break;
 345     default:
 346       break;
 347   }
 348
 349   return account;
 350 }
 351
 352 void rgw_bucket_olh_entry::dump(Formatter *f) const
 353 {
 354   encode_json("key", key, f);
 355   encode_json("delete_marker", delete_marker, f);
 356   encode_json("epoch", epoch, f);
 357   encode_json("pending_log", pending_log, f);
 358   encode_json("tag", tag, f);
 359   encode_json("exists", exists, f);
 360   encode_json("pending_removal", pending_removal, f);
 361 }
 362
 363 void rgw_bucket_olh_entry::decode_json(JSONObj *obj)
 364 {
 365   JSONDecoder::decode_json("key", key, obj);
 366   JSONDecoder::decode_json("delete_marker", delete_marker, obj);
 367   JSONDecoder::decode_json("epoch", epoch, obj);
 368   JSONDecoder::decode_json("pending_log", pending_log, obj);
 369   JSONDecoder::decode_json("tag", tag, obj);
 370   JSONDecoder::decode_json("exists", exists, obj);
 371   JSONDecoder::decode_json("pending_removal", pending_removal, obj);
 372 }
 373
 374 void rgw_bucket_olh_log_entry::generate_test_instances(list<rgw_bucket_olh_log_entry*>& o)
 375 {
 376   rgw_bucket_olh_log_entry *entry = new rgw_bucket_olh_log_entry;
 377   entry->epoch = 1234;
 378   entry->op = CLS_RGW_OLH_OP_LINK_OLH;
 379   entry->op_tag = "op_tag";
 380   entry->key.name = "key.name";
 381   entry->key.instance = "key.instance";
 382   entry->delete_marker = true;
 383   o.push_back(entry);
 384   o.push_back(new rgw_bucket_olh_log_entry);
 385 }
 386
 387 void rgw_bucket_olh_log_entry::dump(Formatter *f) const
 388 {
 389   encode_json("epoch", epoch, f);
 390   const char *op_str;
 391   switch (op) {
 392     case CLS_RGW_OLH_OP_LINK_OLH:
 393       op_str = "link_olh";
 394       break;
 395     case CLS_RGW_OLH_OP_UNLINK_OLH:
 396       op_str = "unlink_olh";
 397       break;
 398     case CLS_RGW_OLH_OP_REMOVE_INSTANCE:
 399       op_str = "remove_instance";
 400       break;
 401     default:
 402       op_str = "unknown";
 403   }
 404   encode_json("op", op_str, f);
 405   encode_json("op_tag", op_tag, f);
 406   encode_json("key", key, f);
 407   encode_json("delete_marker", delete_marker, f);
 408 }
 409
 410 void rgw_bucket_olh_log_entry::decode_json(JSONObj *obj)
 411 {
 412   JSONDecoder::decode_json("epoch", epoch, obj);
 413   string op_str;
 414   JSONDecoder::decode_json("op", op_str, obj);
 415   if (op_str == "link_olh") {
 416     op = CLS_RGW_OLH_OP_LINK_OLH;
 417   } else if (op_str == "unlink_olh") {
 418     op = CLS_RGW_OLH_OP_UNLINK_OLH;
 419   } else if (op_str == "remove_instance") {
 420     op = CLS_RGW_OLH_OP_REMOVE_INSTANCE;
 421   } else {
 422     op = CLS_RGW_OLH_OP_UNKNOWN;
 423   }
 424   JSONDecoder::decode_json("op_tag", op_tag, obj);
 425   JSONDecoder::decode_json("key", key, obj);
 426   JSONDecoder::decode_json("delete_marker", delete_marker, obj);
 427 }
 428 void rgw_bi_log_entry::decode_json(JSONObj *obj)
 429 {
 430   JSONDecoder::decode_json("op_id", id, obj);
 431   JSONDecoder::decode_json("op_tag", tag, obj);
 432   string op_str;
 433   JSONDecoder::decode_json("op", op_str, obj);
 434   if (op_str == "write") {
 435     op = CLS_RGW_OP_ADD;
 436   } else if (op_str == "del") {
 437     op = CLS_RGW_OP_DEL;
 438   } else if (op_str == "cancel") {
 439     op = CLS_RGW_OP_CANCEL;
 440   } else if (op_str == "unknown") {
 441     op = CLS_RGW_OP_UNKNOWN;
 442   } else if (op_str == "link_olh") {
 443     op = CLS_RGW_OP_LINK_OLH;
 444   } else if (op_str == "link_olh_del") {
 445     op = CLS_RGW_OP_LINK_OLH_DM;
 446   } else if (op_str == "unlink_instance") {
 447     op = CLS_RGW_OP_UNLINK_INSTANCE;
 448   } else if (op_str == "syncstop") {
 449     op = CLS_RGW_OP_SYNCSTOP;
 450   } else if (op_str == "resync") {
 451     op = CLS_RGW_OP_RESYNC;
 452   } else {
 453     op = CLS_RGW_OP_UNKNOWN;
 454   }
 455   JSONDecoder::decode_json("object", object, obj);
 456   JSONDecoder::decode_json("instance", instance, obj);
 457   string state_str;
 458   JSONDecoder::decode_json("state", state_str, obj);
 459   if (state_str == "pending") {
 460     state = CLS_RGW_STATE_PENDING_MODIFY;
 461   } else if (state_str == "complete") {
 462     state = CLS_RGW_STATE_COMPLETE;
 463   } else {
 464     state = CLS_RGW_STATE_UNKNOWN;
 465   }
 466   JSONDecoder::decode_json("index_ver", index_ver, obj);
 467   utime_t ut;
 468   JSONDecoder::decode_json("timestamp", ut, obj);
 469   timestamp = ut.to_real_time();
 470   uint32_t f;
 471   JSONDecoder::decode_json("bilog_flags", f, obj);
 472   JSONDecoder::decode_json("ver", ver, obj);
 473   bilog_flags = (uint16_t)f;
 474   JSONDecoder::decode_json("owner", owner, obj);
 475   JSONDecoder::decode_json("owner_display_name", owner_display_name, obj);
 476   JSONDecoder::decode_json("zones_trace", zones_trace, obj);
 477 }
 478
 479 void rgw_bi_log_entry::dump(Formatter *f) const
 480 {
 481   f->dump_string("op_id", id);
 482   f->dump_string("op_tag", tag);
 483   switch (op) {
 484     case CLS_RGW_OP_ADD:
 485       f->dump_string("op", "write");
 486       break;
 487     case CLS_RGW_OP_DEL:
 488       f->dump_string("op", "del");
 489       break;
 490     case CLS_RGW_OP_CANCEL:
 491       f->dump_string("op", "cancel");
 492       break;
 493     case CLS_RGW_OP_UNKNOWN:
 494       f->dump_string("op", "unknown");
 495       break;
 496     case CLS_RGW_OP_LINK_OLH:
 497       f->dump_string("op", "link_olh");
 498       break;
 499     case CLS_RGW_OP_LINK_OLH_DM:
 500       f->dump_string("op", "link_olh_del");
 501       break;
 502     case CLS_RGW_OP_UNLINK_INSTANCE:
 503       f->dump_string("op", "unlink_instance");
 504       break;
 505     case CLS_RGW_OP_SYNCSTOP:
 506       f->dump_string("op", "syncstop");
 507       break;
 508     case CLS_RGW_OP_RESYNC:
 509       f->dump_string("op", "resync");
 510       break;
 511     default:
 512       f->dump_string("op", "invalid");
 513       break;
 514   }
 515
 516   f->dump_string("object", object);
 517   f->dump_string("instance", instance);
 518
 519   switch (state) {
 520     case CLS_RGW_STATE_PENDING_MODIFY:
 521       f->dump_string("state", "pending");
 522       break;
 523     case CLS_RGW_STATE_COMPLETE:
 524       f->dump_string("state", "complete");
 525       break;
 526     default:
 527       f->dump_string("state", "invalid");
 528       break;
 529   }
 530
 531   f->dump_int("index_ver", index_ver);
 532   utime_t ut(timestamp);
 533   ut.gmtime_nsec(f->dump_stream("timestamp"));
 534   f->open_object_section("ver");
 535   ver.dump(f);
 536   f->close_section();
 537   f->dump_int("bilog_flags", bilog_flags);
 538   f->dump_bool("versioned", (bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0);
 539   f->dump_string("owner", owner);
 540   f->dump_string("owner_display_name", owner_display_name);
 541   encode_json("zones_trace", zones_trace, f);
 542 }
 543
 544 void rgw_bi_log_entry::generate_test_instances(list<rgw_bi_log_entry*>& ls)
 545 {
 546   ls.push_back(new rgw_bi_log_entry);
 547   ls.push_back(new rgw_bi_log_entry);
 548   ls.back()->id = "midf";
 549   ls.back()->object = "obj";
 550   ls.back()->timestamp = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)});
 551   ls.back()->index_ver = 4323;
 552   ls.back()->tag = "tagasdfds";
 553   ls.back()->op = CLS_RGW_OP_DEL;
 554   ls.back()->state = CLS_RGW_STATE_PENDING_MODIFY;
 555 }
 556
 557 void rgw_bucket_category_stats::generate_test_instances(list<rgw_bucket_category_stats*>& o)
 558 {
 559   rgw_bucket_category_stats *s = new rgw_bucket_category_stats;
 560   s->total_size = 1024;
 561   s->total_size_rounded = 4096;
 562   s->num_entries = 2;
 563   s->actual_size = 1024;
 564   o.push_back(s);
 565   o.push_back(new rgw_bucket_category_stats);
 566 }
 567
 568 void rgw_bucket_category_stats::dump(Formatter *f) const
 569 {
 570   f->dump_unsigned("total_size", total_size);
 571   f->dump_unsigned("total_size_rounded", total_size_rounded);
 572   f->dump_unsigned("num_entries", num_entries);
 573   f->dump_unsigned("actual_size", actual_size);
 574 }
 575
 576 void rgw_bucket_dir_header::generate_test_instances(list<rgw_bucket_dir_header*>& o)
 577 {
 578   list<rgw_bucket_category_stats *> l;
 579   list<rgw_bucket_category_stats *>::iterator iter;
 580   rgw_bucket_category_stats::generate_test_instances(l);
 581
 582   uint8_t i;
 583   for (i = 0, iter = l.begin(); iter != l.end(); ++iter, ++i) {
 584     RGWObjCategory c = static_cast<RGWObjCategory>(i);
 585     rgw_bucket_dir_header *h = new rgw_bucket_dir_header;
 586     rgw_bucket_category_stats *s = *iter;
 587     h->stats[c] = *s;
 588
 589     o.push_back(h);
 590
 591     delete s;
 592   }
 593
 594   o.push_back(new rgw_bucket_dir_header);
 595 }
 596
 597 void rgw_bucket_dir_header::dump(Formatter *f) const
 598 {
 599   f->dump_int("ver", ver);
 600   f->dump_int("master_ver", master_ver);
 601   f->open_array_section("stats");
 602   for (auto iter = stats.begin(); iter != stats.end(); ++iter) {
 603     f->dump_int("category", int(iter->first));
 604     f->open_object_section("category_stats");
 605     iter->second.dump(f);
 606     f->close_section();
 607   }
 608   f->close_section();
 609   ::encode_json("new_instance", new_instance, f);
 610 }
 611
 612 void rgw_bucket_dir::generate_test_instances(list<rgw_bucket_dir*>& o)
 613 {
 614   list<rgw_bucket_dir_header *> l;
 615   list<rgw_bucket_dir_header *>::iterator iter;
 616   rgw_bucket_dir_header::generate_test_instances(l);
 617
 618   uint8_t i;
 619   for (i = 0, iter = l.begin(); iter != l.end(); ++iter, ++i) {
 620     rgw_bucket_dir *d = new rgw_bucket_dir;
 621     rgw_bucket_dir_header *h = *iter;
 622     d->header = *h;
 623
 624     list<rgw_bucket_dir_entry *> el;
 625     list<rgw_bucket_dir_entry *>::iterator eiter;
 626     for (eiter = el.begin(); eiter != el.end(); ++eiter) {
 627       rgw_bucket_dir_entry *e = *eiter;
 628       d->m[e->key.name] = *e;
 629
 630       delete e;
 631     }
 632
 633     o.push_back(d);
 634
 635     delete h;
 636   }
 637
 638   o.push_back(new rgw_bucket_dir);
 639 }
 640
 641 void rgw_bucket_dir::dump(Formatter *f) const
 642 {
 643   f->open_object_section("header");
 644   header.dump(f);
 645   f->close_section();
 646   auto iter = m.cbegin();
 647   f->open_array_section("map");
 648   for (; iter != m.cend(); ++iter) {
 649     f->dump_string("key", iter->first);
 650     f->open_object_section("dir_entry");
 651     iter->second.dump(f);
 652     f->close_section();
 653   }
 654   f->close_section();
 655 }
 656
 657 void rgw_usage_log_entry::dump(Formatter *f) const
 658 {
 659   f->dump_string("owner", owner.to_str());
 660   f->dump_string("payer", payer.to_str());
 661   f->dump_string("bucket", bucket);
 662   f->dump_unsigned("epoch", epoch);
 663
 664   f->open_object_section("total_usage");
 665   f->dump_unsigned("bytes_sent", total_usage.bytes_sent);
 666   f->dump_unsigned("bytes_received", total_usage.bytes_received);
 667   f->dump_unsigned("ops", total_usage.ops);
 668   f->dump_unsigned("successful_ops", total_usage.successful_ops);
 669   f->close_section();
 670
 671   f->open_array_section("categories");
 672   if (usage_map.size() > 0) {
 673     map<string, rgw_usage_data>::const_iterator it;
 674     for (it = usage_map.begin(); it != usage_map.end(); it++) {
 675       const rgw_usage_data& total_usage = it->second;
 676       f->open_object_section("entry");
 677       f->dump_string("category", it->first.c_str());
 678       f->dump_unsigned("bytes_sent", total_usage.bytes_sent);
 679       f->dump_unsigned("bytes_received", total_usage.bytes_received);
 680       f->dump_unsigned("ops", total_usage.ops);
 681       f->dump_unsigned("successful_ops", total_usage.successful_ops);
 682       f->close_section();
 683     }
 684   }
 685   f->close_section();
 686 }
 687
 688 void rgw_usage_log_entry::generate_test_instances(list<rgw_usage_log_entry *> &o)
 689 {
 690   rgw_usage_log_entry *entry = new rgw_usage_log_entry;
 691   rgw_usage_data usage_data{1024, 2048};
 692   entry->owner = rgw_user("owner");
 693   entry->payer = rgw_user("payer");
 694   entry->bucket = "bucket";
 695   entry->epoch = 1234;
 696   entry->total_usage.bytes_sent = usage_data.bytes_sent;
 697   entry->total_usage.bytes_received = usage_data.bytes_received;
 698   entry->total_usage.ops = usage_data.ops;
 699   entry->total_usage.successful_ops = usage_data.successful_ops;
 700   entry->usage_map["get_obj"] = usage_data;
 701   o.push_back(entry);
 702   o.push_back(new rgw_usage_log_entry);
 703 }
 704
 705 void cls_rgw_reshard_entry::generate_key(const string& tenant, const string& bucket_name, string *key)
 706 {
 707   *key = tenant + ":" + bucket_name;
 708 }
 709
 710 void cls_rgw_reshard_entry::get_key(string *key) const
 711 {
 712   generate_key(tenant, bucket_name, key);
 713 }
 714
 715 void cls_rgw_reshard_entry::dump(Formatter *f) const
 716 {
 717   utime_t ut(time);
 718   encode_json("time",ut, f);
 719   encode_json("tenant", tenant, f);
 720   encode_json("bucket_name", bucket_name, f);
 721   encode_json("bucket_id", bucket_id, f);
 722   encode_json("new_instance_id", new_instance_id, f);
 723   encode_json("old_num_shards", old_num_shards, f);
 724   encode_json("new_num_shards", new_num_shards, f);
 725
 726 }
 727
 728 void cls_rgw_reshard_entry::generate_test_instances(list<cls_rgw_reshard_entry*>& ls)
 729 {
 730   ls.push_back(new cls_rgw_reshard_entry);
 731   ls.push_back(new cls_rgw_reshard_entry);
 732   ls.back()->time = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)});
 733   ls.back()->tenant = "tenant";
 734   ls.back()->bucket_name = "bucket1""";
 735   ls.back()->bucket_id = "bucket_id";
 736   ls.back()->new_instance_id = "new_instance_id";
 737   ls.back()->old_num_shards = 8;
 738   ls.back()->new_num_shards = 64;
 739 }
 740
 741 void cls_rgw_bucket_instance_entry::dump(Formatter *f) const
 742 {
 743   encode_json("reshard_status", to_string(reshard_status), f);
 744   encode_json("new_bucket_instance_id", new_bucket_instance_id, f);
 745   encode_json("num_shards", num_shards, f);
 746
 747 }
 748
 749 void cls_rgw_bucket_instance_entry::generate_test_instances(
 750   list<cls_rgw_bucket_instance_entry*>& ls)
 751 {
 752   ls.push_back(new cls_rgw_bucket_instance_entry);
 753   ls.push_back(new cls_rgw_bucket_instance_entry);
 754   ls.back()->reshard_status = RESHARD_STATUS::IN_PROGRESS;
 755   ls.back()->new_bucket_instance_id = "new_instance_id";
 756 }
 757
 758 void cls_rgw_lc_obj_head::dump(Formatter *f) const
 759 {
 760   encode_json("start_date", start_date, f);
 761   encode_json("marker", marker, f);
 762 }
 763
 764 void cls_rgw_lc_obj_head::generate_test_instances(list<cls_rgw_lc_obj_head*>& ls)
 765 {
 766 }