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