ceph/src/cls/rgw/cls_rgw_types.cc

   1
   2 #include "cls/rgw/cls_rgw_types.h"
   3 #include "common/Formatter.h"
   4 #include "common/ceph_json.h"
   5 #include "include/utime.h"
   6
   7
   8 void rgw_bucket_pending_info::generate_test_instances(list<rgw_bucket_pending_info*>& o)
   9 {
  10   rgw_bucket_pending_info *i = new rgw_bucket_pending_info;
  11   i->state = CLS_RGW_STATE_COMPLETE;
  12   i->op = CLS_RGW_OP_DEL;
  13   o.push_back(i);
  14   o.push_back(new rgw_bucket_pending_info);
  15 }
  16
  17 void rgw_bucket_pending_info::dump(Formatter *f) const
  18 {
  19   encode_json("state", (int)state, f);
  20   utime_t ut(timestamp);
  21   encode_json("timestamp", ut, f);
  22   encode_json("op", (int)op, f);
  23 }
  24
  25 void rgw_bucket_pending_info::decode_json(JSONObj *obj) {
  26   int val;
  27   JSONDecoder::decode_json("state", val, obj);
  28   state = (RGWPendingState)val;
  29   utime_t ut(timestamp);
  30   JSONDecoder::decode_json("timestamp", ut, obj);
  31   JSONDecoder::decode_json("op", val, obj);
  32   op = (uint8_t)val;
  33 }
  34
  35 void cls_rgw_obj_key::decode_json(JSONObj *obj) {
  36   JSONDecoder::decode_json("name", name, obj);
  37   JSONDecoder::decode_json("instance", instance, obj);
  38 }
  39
  40 void rgw_bucket_dir_entry_meta::generate_test_instances(list<rgw_bucket_dir_entry_meta*>& o)
  41 {
  42   rgw_bucket_dir_entry_meta *m = new rgw_bucket_dir_entry_meta;
  43   m->category = 1;
  44   m->size = 100;
  45   m->etag = "etag";
  46   m->owner = "owner";
  47   m->owner_display_name = "display name";
  48   m->content_type = "content/type";
  49   o.push_back(m);
  50   o.push_back(new rgw_bucket_dir_entry_meta);
  51 }
  52
  53 void rgw_bucket_dir_entry_meta::dump(Formatter *f) const
  54 {
  55   encode_json("category", (int)category, f);
  56   encode_json("size", size, f);
  57   utime_t ut(mtime);
  58   encode_json("mtime", ut, f);
  59   encode_json("etag", etag, f);
  60   encode_json("owner", owner, f);
  61   encode_json("owner_display_name", owner_display_name, f);
  62   encode_json("content_type", content_type, f);
  63   encode_json("accounted_size", accounted_size, f);
  64   encode_json("user_data", user_data, f);
  65 }
  66
  67 void rgw_bucket_dir_entry_meta::decode_json(JSONObj *obj) {
  68   int val;
  69   JSONDecoder::decode_json("category", val, obj);
  70   category = (uint8_t)val;
  71   JSONDecoder::decode_json("size", size, obj);
  72   utime_t ut(mtime);
  73   JSONDecoder::decode_json("mtime", ut, obj);
  74   JSONDecoder::decode_json("etag", etag, obj);
  75   JSONDecoder::decode_json("owner", owner, obj);
  76   JSONDecoder::decode_json("owner_display_name", owner_display_name, obj);
  77   JSONDecoder::decode_json("content_type", content_type, obj);
  78   JSONDecoder::decode_json("accounted_size", accounted_size, obj);
  79   JSONDecoder::decode_json("user_data", user_data, obj);
  80 }
  81
  82 void rgw_bucket_dir_entry::generate_test_instances(list<rgw_bucket_dir_entry*>& o)
  83 {
  84   list<rgw_bucket_dir_entry_meta *> l;
  85   rgw_bucket_dir_entry_meta::generate_test_instances(l);
  86
  87   list<rgw_bucket_dir_entry_meta *>::iterator iter;
  88   for (iter = l.begin(); iter != l.end(); ++iter) {
  89     rgw_bucket_dir_entry_meta *m = *iter;
  90     rgw_bucket_dir_entry *e = new rgw_bucket_dir_entry;
  91     e->key.name = "name";
  92     e->ver.pool = 1;
  93     e->ver.epoch = 1234;
  94     e->locator = "locator";
  95     e->exists = true;
  96     e->meta = *m;
  97     e->tag = "tag";
  98
  99     o.push_back(e);
 100
 101     delete m;
 102   }
 103   o.push_back(new rgw_bucket_dir_entry);
 104 }
 105
 106 void rgw_bucket_entry_ver::dump(Formatter *f) const
 107 {
 108   encode_json("pool", pool, f);
 109   encode_json("epoch", epoch, f);
 110 }
 111
 112 void rgw_bucket_entry_ver::decode_json(JSONObj *obj) {
 113   JSONDecoder::decode_json("pool", pool, obj);
 114   JSONDecoder::decode_json("epoch", epoch, obj);
 115 }
 116
 117 void rgw_bucket_entry_ver::generate_test_instances(list<rgw_bucket_entry_ver*>& ls)
 118 {
 119   ls.push_back(new rgw_bucket_entry_ver);
 120   ls.push_back(new rgw_bucket_entry_ver);
 121   ls.back()->pool = 123;
 122   ls.back()->epoch = 12322;
 123 }
 124
 125
 126 void rgw_bucket_dir_entry::dump(Formatter *f) const
 127 {
 128   encode_json("name", key.name, f);
 129   encode_json("instance", key.instance , f);
 130   encode_json("ver", ver , f);
 131   encode_json("locator", locator , f);
 132   encode_json("exists", exists , f);
 133   encode_json("meta", meta , f);
 134   encode_json("tag", tag , f);
 135   encode_json("flags", (int)flags , f);
 136   encode_json("pending_map", pending_map, f);
 137   encode_json("versioned_epoch", versioned_epoch , f);
 138 }
 139
 140 void rgw_bucket_dir_entry::decode_json(JSONObj *obj) {
 141   JSONDecoder::decode_json("name", key.name, obj);
 142   JSONDecoder::decode_json("instance", key.instance , obj);
 143   JSONDecoder::decode_json("ver", ver , obj);
 144   JSONDecoder::decode_json("locator", locator , obj);
 145   JSONDecoder::decode_json("exists", exists , obj);
 146   JSONDecoder::decode_json("meta", meta , obj);
 147   JSONDecoder::decode_json("tag", tag , obj);
 148   int val;
 149   JSONDecoder::decode_json("flags", val , obj);
 150   flags = (uint16_t)val;
 151   JSONDecoder::decode_json("pending_map", pending_map, obj);
 152   JSONDecoder::decode_json("versioned_epoch", versioned_epoch, obj);
 153 }
 154
 155 static void dump_bi_entry(bufferlist bl, BIIndexType index_type, Formatter *formatter)
 156 {
 157   bufferlist::iterator iter = bl.begin();
 158   switch (index_type) {
 159     case PlainIdx:
 160     case InstanceIdx:
 161       {
 162         rgw_bucket_dir_entry entry;
 163         ::decode(entry, iter);
 164         encode_json("entry", entry, formatter);
 165       }
 166       break;
 167     case OLHIdx:
 168       {
 169         rgw_bucket_olh_entry entry;
 170         ::decode(entry, iter);
 171         encode_json("entry", entry, formatter);
 172       }
 173       break;
 174     default:
 175       break;
 176   }
 177 }
 178
 179 void rgw_cls_bi_entry::decode_json(JSONObj *obj, cls_rgw_obj_key *effective_key) {
 180   JSONDecoder::decode_json("idx", idx, obj);
 181   string s;
 182   JSONDecoder::decode_json("type", s, obj);
 183   if (s == "plain") {
 184     type = PlainIdx;
 185   } else if (s == "instance") {
 186     type = InstanceIdx;
 187   } else if (s == "olh") {
 188     type = OLHIdx;
 189   } else {
 190     type = InvalidIdx;
 191   }
 192   switch (type) {
 193     case PlainIdx:
 194     case InstanceIdx:
 195       {
 196         rgw_bucket_dir_entry entry;
 197         JSONDecoder::decode_json("entry", entry, obj);
 198         ::encode(entry, data);
 199
 200         if (effective_key) {
 201           *effective_key = entry.key;
 202         }
 203       }
 204       break;
 205     case OLHIdx:
 206       {
 207         rgw_bucket_olh_entry entry;
 208         JSONDecoder::decode_json("entry", entry, obj);
 209         ::encode(entry, data);
 210
 211         if (effective_key) {
 212           *effective_key = entry.key;
 213         }
 214       }
 215       break;
 216     default:
 217       break;
 218   }
 219 }
 220
 221 void rgw_cls_bi_entry::dump(Formatter *f) const
 222 {
 223   string type_str;
 224   switch (type) {
 225     case PlainIdx:
 226       type_str = "plain";
 227       break;
 228     case InstanceIdx:
 229       type_str = "instance";
 230       break;
 231     case OLHIdx:
 232       type_str = "olh";
 233       break;
 234     default:
 235       type_str = "invalid";
 236   }
 237   encode_json("type", type_str, f);
 238   encode_json("idx", idx, f);
 239   dump_bi_entry(data, type, f);
 240 }
 241
 242 bool rgw_cls_bi_entry::get_info(cls_rgw_obj_key *key, uint8_t *category, rgw_bucket_category_stats *accounted_stats)
 243 {
 244   bool account = false;
 245   bufferlist::iterator iter = data.begin();
 246   switch (type) {
 247     case PlainIdx:
 248     case InstanceIdx:
 249       {
 250         rgw_bucket_dir_entry entry;
 251         ::decode(entry, iter);
 252         *key = entry.key;
 253         *category = entry.meta.category;
 254         accounted_stats->num_entries++;
 255         accounted_stats->total_size += entry.meta.accounted_size;
 256         accounted_stats->total_size_rounded += cls_rgw_get_rounded_size(entry.meta.accounted_size);
 257         account = true;
 258       }
 259       break;
 260     case OLHIdx:
 261       {
 262         rgw_bucket_olh_entry entry;
 263         ::decode(entry, iter);
 264         *key = entry.key;
 265       }
 266       break;
 267     default:
 268       break;
 269   }
 270
 271   return account;
 272 }
 273
 274 void rgw_bucket_olh_entry::dump(Formatter *f) const
 275 {
 276   encode_json("key", key, f);
 277   encode_json("delete_marker", delete_marker, f);
 278   encode_json("epoch", epoch, f);
 279   encode_json("pending_log", pending_log, f);
 280   encode_json("tag", tag, f);
 281   encode_json("exists", exists, f);
 282   encode_json("pending_removal", pending_removal, f);
 283 }
 284
 285 void rgw_bucket_olh_entry::decode_json(JSONObj *obj)
 286 {
 287   JSONDecoder::decode_json("key", key, obj);
 288   JSONDecoder::decode_json("delete_marker", delete_marker, obj);
 289   JSONDecoder::decode_json("epoch", epoch, obj);
 290   JSONDecoder::decode_json("pending_log", pending_log, obj);
 291   JSONDecoder::decode_json("tag", tag, obj);
 292   JSONDecoder::decode_json("exists", exists, obj);
 293   JSONDecoder::decode_json("pending_removal", pending_removal, obj);
 294 }
 295
 296 void rgw_bucket_olh_log_entry::generate_test_instances(list<rgw_bucket_olh_log_entry*>& o)
 297 {
 298   rgw_bucket_olh_log_entry *entry = new rgw_bucket_olh_log_entry;
 299   entry->epoch = 1234;
 300   entry->op = CLS_RGW_OLH_OP_LINK_OLH;
 301   entry->op_tag = "op_tag";
 302   entry->key.name = "key.name";
 303   entry->key.instance = "key.instance";
 304   entry->delete_marker = true;
 305   o.push_back(entry);
 306   o.push_back(new rgw_bucket_olh_log_entry);
 307 }
 308
 309 void rgw_bucket_olh_log_entry::dump(Formatter *f) const
 310 {
 311   encode_json("epoch", epoch, f);
 312   const char *op_str;
 313   switch (op) {
 314     case CLS_RGW_OLH_OP_LINK_OLH:
 315       op_str = "link_olh";
 316       break;
 317     case CLS_RGW_OLH_OP_UNLINK_OLH:
 318       op_str = "unlink_olh";
 319       break;
 320     case CLS_RGW_OLH_OP_REMOVE_INSTANCE:
 321       op_str = "remove_instance";
 322       break;
 323     default:
 324       op_str = "unknown";
 325   }
 326   encode_json("op", op_str, f);
 327   encode_json("op_tag", op_tag, f);
 328   encode_json("key", key, f);
 329   encode_json("delete_marker", delete_marker, f);
 330 }
 331
 332 void rgw_bucket_olh_log_entry::decode_json(JSONObj *obj)
 333 {
 334   JSONDecoder::decode_json("epoch", epoch, obj);
 335   string op_str;
 336   JSONDecoder::decode_json("op", op_str, obj);
 337   if (op_str == "link_olh") {
 338     op = CLS_RGW_OLH_OP_LINK_OLH;
 339   } else if (op_str == "unlink_olh") {
 340     op = CLS_RGW_OLH_OP_UNLINK_OLH;
 341   } else if (op_str == "remove_instance") {
 342     op = CLS_RGW_OLH_OP_REMOVE_INSTANCE;
 343   } else {
 344     op = CLS_RGW_OLH_OP_UNKNOWN;
 345   }
 346   JSONDecoder::decode_json("op_tag", op_tag, obj);
 347   JSONDecoder::decode_json("key", key, obj);
 348   JSONDecoder::decode_json("delete_marker", delete_marker, obj);
 349 }
 350 void rgw_bi_log_entry::decode_json(JSONObj *obj)
 351 {
 352   JSONDecoder::decode_json("op_id", id, obj);
 353   JSONDecoder::decode_json("op_tag", tag, obj);
 354   string op_str;
 355   JSONDecoder::decode_json("op", op_str, obj);
 356   if (op_str == "write") {
 357     op = CLS_RGW_OP_ADD;
 358   } else if (op_str == "del") {
 359     op = CLS_RGW_OP_DEL;
 360   } else if (op_str == "cancel") {
 361     op = CLS_RGW_OP_CANCEL;
 362   } else if (op_str == "unknown") {
 363     op = CLS_RGW_OP_UNKNOWN;
 364   } else if (op_str == "link_olh") {
 365     op = CLS_RGW_OP_LINK_OLH;
 366   } else if (op_str == "link_olh_del") {
 367     op = CLS_RGW_OP_LINK_OLH_DM;
 368   } else if (op_str == "unlink_instance") {
 369     op = CLS_RGW_OP_UNLINK_INSTANCE;
 370   } else {
 371     op = CLS_RGW_OP_UNKNOWN;
 372   }
 373   JSONDecoder::decode_json("object", object, obj);
 374   JSONDecoder::decode_json("instance", instance, obj);
 375   string state_str;
 376   JSONDecoder::decode_json("state", state_str, obj);
 377   if (state_str == "pending") {
 378     state = CLS_RGW_STATE_PENDING_MODIFY;
 379   } else if (state_str == "complete") {
 380     state = CLS_RGW_STATE_COMPLETE;
 381   } else {
 382     state = CLS_RGW_STATE_UNKNOWN;
 383   }
 384   JSONDecoder::decode_json("index_ver", index_ver, obj);
 385   utime_t ut;
 386   JSONDecoder::decode_json("timestamp", ut, obj);
 387   timestamp = ut.to_real_time();
 388   uint32_t f;
 389   JSONDecoder::decode_json("bilog_flags", f, obj);
 390   JSONDecoder::decode_json("ver", ver, obj);
 391   bilog_flags = (uint16_t)f;
 392   JSONDecoder::decode_json("owner", owner, obj);
 393   JSONDecoder::decode_json("owner_display_name", owner_display_name, obj);
 394 }
 395
 396 void rgw_bi_log_entry::dump(Formatter *f) const
 397 {
 398   f->dump_string("op_id", id);
 399   f->dump_string("op_tag", tag);
 400   switch (op) {
 401     case CLS_RGW_OP_ADD:
 402       f->dump_string("op", "write");
 403       break;
 404     case CLS_RGW_OP_DEL:
 405       f->dump_string("op", "del");
 406       break;
 407     case CLS_RGW_OP_CANCEL:
 408       f->dump_string("op", "cancel");
 409       break;
 410     case CLS_RGW_OP_UNKNOWN:
 411       f->dump_string("op", "unknown");
 412       break;
 413     case CLS_RGW_OP_LINK_OLH:
 414       f->dump_string("op", "link_olh");
 415       break;
 416     case CLS_RGW_OP_LINK_OLH_DM:
 417       f->dump_string("op", "link_olh_del");
 418       break;
 419     case CLS_RGW_OP_UNLINK_INSTANCE:
 420       f->dump_string("op", "unlink_instance");
 421       break;
 422     default:
 423       f->dump_string("op", "invalid");
 424       break;
 425   }
 426
 427   f->dump_string("object", object);
 428   f->dump_string("instance", instance);
 429
 430   switch (state) {
 431     case CLS_RGW_STATE_PENDING_MODIFY:
 432       f->dump_string("state", "pending");
 433       break;
 434     case CLS_RGW_STATE_COMPLETE:
 435       f->dump_string("state", "complete");
 436       break;
 437     default:
 438       f->dump_string("state", "invalid");
 439       break;
 440   }
 441
 442   f->dump_int("index_ver", index_ver);
 443   utime_t ut(timestamp);
 444   ut.gmtime_nsec(f->dump_stream("timestamp"));
 445   f->open_object_section("ver");
 446   ver.dump(f);
 447   f->close_section();
 448   f->dump_int("bilog_flags", bilog_flags);
 449   f->dump_bool("versioned", (bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0);
 450   f->dump_string("owner", owner);
 451   f->dump_string("owner_display_name", owner_display_name);
 452 }
 453
 454 void rgw_bi_log_entry::generate_test_instances(list<rgw_bi_log_entry*>& ls)
 455 {
 456   ls.push_back(new rgw_bi_log_entry);
 457   ls.push_back(new rgw_bi_log_entry);
 458   ls.back()->id = "midf";
 459   ls.back()->object = "obj";
 460   ls.back()->timestamp = ceph::real_clock::from_ceph_timespec({2, 3});
 461   ls.back()->index_ver = 4323;
 462   ls.back()->tag = "tagasdfds";
 463   ls.back()->op = CLS_RGW_OP_DEL;
 464   ls.back()->state = CLS_RGW_STATE_PENDING_MODIFY;
 465 }
 466
 467 void rgw_bucket_category_stats::generate_test_instances(list<rgw_bucket_category_stats*>& o)
 468 {
 469   rgw_bucket_category_stats *s = new rgw_bucket_category_stats;
 470   s->total_size = 1024;
 471   s->total_size_rounded = 4096;
 472   s->num_entries = 2;
 473   s->actual_size = 1024;
 474   o.push_back(s);
 475   o.push_back(new rgw_bucket_category_stats);
 476 }
 477
 478 void rgw_bucket_category_stats::dump(Formatter *f) const
 479 {
 480   f->dump_unsigned("total_size", total_size);
 481   f->dump_unsigned("total_size_rounded", total_size_rounded);
 482   f->dump_unsigned("num_entries", num_entries);
 483   f->dump_unsigned("actual_size", actual_size);
 484 }
 485
 486 void rgw_bucket_dir_header::generate_test_instances(list<rgw_bucket_dir_header*>& o)
 487 {
 488   list<rgw_bucket_category_stats *> l;
 489   list<rgw_bucket_category_stats *>::iterator iter;
 490   rgw_bucket_category_stats::generate_test_instances(l);
 491
 492   uint8_t i;
 493   for (i = 0, iter = l.begin(); iter != l.end(); ++iter, ++i) {
 494     rgw_bucket_dir_header *h = new rgw_bucket_dir_header;
 495     rgw_bucket_category_stats *s = *iter;
 496     h->stats[i] = *s;
 497
 498     o.push_back(h);
 499
 500     delete s;
 501   }
 502
 503   o.push_back(new rgw_bucket_dir_header);
 504 }
 505
 506 void rgw_bucket_dir_header::dump(Formatter *f) const
 507 {
 508   f->dump_int("ver", ver);
 509   f->dump_int("master_ver", master_ver);
 510   map<uint8_t, struct rgw_bucket_category_stats>::const_iterator iter = stats.begin();
 511   f->open_array_section("stats");
 512   for (; iter != stats.end(); ++iter) {
 513     f->dump_int("category", (int)iter->first);
 514     f->open_object_section("category_stats");
 515     iter->second.dump(f);
 516     f->close_section();
 517   }
 518   f->close_section();
 519 }
 520
 521 void rgw_bucket_dir::generate_test_instances(list<rgw_bucket_dir*>& o)
 522 {
 523   list<rgw_bucket_dir_header *> l;
 524   list<rgw_bucket_dir_header *>::iterator iter;
 525   rgw_bucket_dir_header::generate_test_instances(l);
 526
 527   uint8_t i;
 528   for (i = 0, iter = l.begin(); iter != l.end(); ++iter, ++i) {
 529     rgw_bucket_dir *d = new rgw_bucket_dir;
 530     rgw_bucket_dir_header *h = *iter;
 531     d->header = *h;
 532
 533     list<rgw_bucket_dir_entry *> el;
 534     list<rgw_bucket_dir_entry *>::iterator eiter;
 535     for (eiter = el.begin(); eiter != el.end(); ++eiter) {
 536       rgw_bucket_dir_entry *e = *eiter;
 537       d->m[e->key.name] = *e;
 538
 539       delete e;
 540     }
 541
 542     o.push_back(d);
 543
 544     delete h;
 545   }
 546
 547   o.push_back(new rgw_bucket_dir);
 548 }
 549
 550 void rgw_bucket_dir::dump(Formatter *f) const
 551 {
 552   f->open_object_section("header");
 553   header.dump(f);
 554   f->close_section();
 555   map<string, struct rgw_bucket_dir_entry>::const_iterator iter = m.begin();
 556   f->open_array_section("map");
 557   for (; iter != m.end(); ++iter) {
 558     f->dump_string("key", iter->first);
 559     f->open_object_section("dir_entry");
 560     iter->second.dump(f);
 561     f->close_section();
 562   }
 563   f->close_section();
 564 }
 565