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