]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
7c673cae FG |
3 | |
4 | #include "cls/rgw/cls_rgw_types.h" | |
7c673cae FG |
5 | #include "common/ceph_json.h" |
6 | #include "include/utime.h" | |
7 | ||
8 | ||
9f95a23c TL |
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 | ||
7c673cae FG |
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; | |
11fdf7f2 | 110 | m->category = RGWObjCategory::Main; |
7c673cae FG |
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); | |
11fdf7f2 | 127 | encode_json("storage_class", storage_class, f); |
7c673cae FG |
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); | |
11fdf7f2 | 133 | encode_json("appendable", appendable, f); |
7c673cae FG |
134 | } |
135 | ||
136 | void rgw_bucket_dir_entry_meta::decode_json(JSONObj *obj) { | |
137 | int val; | |
138 | JSONDecoder::decode_json("category", val, obj); | |
11fdf7f2 | 139 | category = static_cast<RGWObjCategory>(val); |
7c673cae | 140 | JSONDecoder::decode_json("size", size, obj); |
11fdf7f2 | 141 | utime_t ut; |
7c673cae | 142 | JSONDecoder::decode_json("mtime", ut, obj); |
11fdf7f2 | 143 | mtime = ut.to_real_time(); |
7c673cae | 144 | JSONDecoder::decode_json("etag", etag, obj); |
11fdf7f2 | 145 | JSONDecoder::decode_json("storage_class", storage_class, obj); |
7c673cae FG |
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); | |
11fdf7f2 | 151 | JSONDecoder::decode_json("appendable", appendable, obj); |
7c673cae FG |
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 | { | |
11fdf7f2 | 229 | auto iter = bl.cbegin(); |
7c673cae | 230 | switch (index_type) { |
11fdf7f2 TL |
231 | case BIIndexType::Plain: |
232 | case BIIndexType::Instance: | |
7c673cae FG |
233 | { |
234 | rgw_bucket_dir_entry entry; | |
11fdf7f2 | 235 | decode(entry, iter); |
7c673cae FG |
236 | encode_json("entry", entry, formatter); |
237 | } | |
238 | break; | |
11fdf7f2 | 239 | case BIIndexType::OLH: |
7c673cae FG |
240 | { |
241 | rgw_bucket_olh_entry entry; | |
11fdf7f2 | 242 | decode(entry, iter); |
7c673cae FG |
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") { | |
11fdf7f2 | 256 | type = BIIndexType::Plain; |
7c673cae | 257 | } else if (s == "instance") { |
11fdf7f2 | 258 | type = BIIndexType::Instance; |
7c673cae | 259 | } else if (s == "olh") { |
11fdf7f2 | 260 | type = BIIndexType::OLH; |
7c673cae | 261 | } else { |
11fdf7f2 | 262 | type = BIIndexType::Invalid; |
7c673cae | 263 | } |
11fdf7f2 | 264 | using ceph::encode; |
7c673cae | 265 | switch (type) { |
11fdf7f2 TL |
266 | case BIIndexType::Plain: |
267 | case BIIndexType::Instance: | |
7c673cae FG |
268 | { |
269 | rgw_bucket_dir_entry entry; | |
270 | JSONDecoder::decode_json("entry", entry, obj); | |
11fdf7f2 | 271 | encode(entry, data); |
7c673cae FG |
272 | |
273 | if (effective_key) { | |
274 | *effective_key = entry.key; | |
275 | } | |
276 | } | |
277 | break; | |
11fdf7f2 | 278 | case BIIndexType::OLH: |
7c673cae FG |
279 | { |
280 | rgw_bucket_olh_entry entry; | |
281 | JSONDecoder::decode_json("entry", entry, obj); | |
11fdf7f2 | 282 | encode(entry, data); |
7c673cae FG |
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) { | |
11fdf7f2 TL |
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"; | |
7c673cae FG |
309 | } |
310 | encode_json("type", type_str, f); | |
311 | encode_json("idx", idx, f); | |
312 | dump_bi_entry(data, type, f); | |
313 | } | |
314 | ||
11fdf7f2 TL |
315 | bool rgw_cls_bi_entry::get_info(cls_rgw_obj_key *key, |
316 | RGWObjCategory *category, | |
317 | rgw_bucket_category_stats *accounted_stats) | |
7c673cae FG |
318 | { |
319 | bool account = false; | |
11fdf7f2 TL |
320 | auto iter = data.cbegin(); |
321 | using ceph::decode; | |
7c673cae | 322 | switch (type) { |
11fdf7f2 TL |
323 | case BIIndexType::Plain: |
324 | account = true; | |
325 | // NO BREAK; falls through to case InstanceIdx: | |
326 | case BIIndexType::Instance: | |
7c673cae FG |
327 | { |
328 | rgw_bucket_dir_entry entry; | |
11fdf7f2 | 329 | decode(entry, iter); |
7c673cae FG |
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); | |
91327a77 | 335 | accounted_stats->actual_size += entry.meta.size; |
7c673cae FG |
336 | } |
337 | break; | |
11fdf7f2 | 338 | case BIIndexType::OLH: |
7c673cae FG |
339 | { |
340 | rgw_bucket_olh_entry entry; | |
11fdf7f2 | 341 | decode(entry, iter); |
7c673cae FG |
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; | |
c07f9fc5 FG |
448 | } else if (op_str == "syncstop") { |
449 | op = CLS_RGW_OP_SYNCSTOP; | |
450 | } else if (op_str == "resync") { | |
451 | op = CLS_RGW_OP_RESYNC; | |
7c673cae FG |
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); | |
31f18b77 | 476 | JSONDecoder::decode_json("zones_trace", zones_trace, obj); |
7c673cae FG |
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; | |
c07f9fc5 FG |
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; | |
7c673cae FG |
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); | |
31f18b77 | 541 | encode_json("zones_trace", zones_trace, f); |
7c673cae FG |
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"; | |
eafe8130 | 550 | ls.back()->timestamp = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)}); |
7c673cae FG |
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) { | |
11fdf7f2 | 584 | RGWObjCategory c = static_cast<RGWObjCategory>(i); |
7c673cae FG |
585 | rgw_bucket_dir_header *h = new rgw_bucket_dir_header; |
586 | rgw_bucket_category_stats *s = *iter; | |
11fdf7f2 | 587 | h->stats[c] = *s; |
7c673cae FG |
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); | |
7c673cae | 601 | f->open_array_section("stats"); |
11fdf7f2 TL |
602 | for (auto iter = stats.begin(); iter != stats.end(); ++iter) { |
603 | f->dump_int("category", int(iter->first)); | |
7c673cae FG |
604 | f->open_object_section("category_stats"); |
605 | iter->second.dump(f); | |
606 | f->close_section(); | |
607 | } | |
608 | f->close_section(); | |
11fdf7f2 | 609 | ::encode_json("new_instance", new_instance, f); |
7c673cae FG |
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(); | |
9f95a23c | 646 | auto iter = m.cbegin(); |
7c673cae | 647 | f->open_array_section("map"); |
9f95a23c | 648 | for (; iter != m.cend(); ++iter) { |
7c673cae FG |
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 | ||
91327a77 AA |
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 | ||
31f18b77 FG |
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); | |
eafe8130 | 732 | ls.back()->time = ceph::real_clock::from_ceph_timespec({init_le32(2), init_le32(3)}); |
31f18b77 FG |
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 | { | |
494da23a | 743 | encode_json("reshard_status", to_string(reshard_status), f); |
31f18b77 FG |
744 | encode_json("new_bucket_instance_id", new_bucket_instance_id, f); |
745 | encode_json("num_shards", num_shards, f); | |
746 | ||
747 | } | |
748 | ||
9f95a23c TL |
749 | void cls_rgw_bucket_instance_entry::generate_test_instances( |
750 | list<cls_rgw_bucket_instance_entry*>& ls) | |
31f18b77 FG |
751 | { |
752 | ls.push_back(new cls_rgw_bucket_instance_entry); | |
753 | ls.push_back(new cls_rgw_bucket_instance_entry); | |
9f95a23c | 754 | ls.back()->reshard_status = RESHARD_STATUS::IN_PROGRESS; |
31f18b77 FG |
755 | ls.back()->new_bucket_instance_id = "new_instance_id"; |
756 | } | |
11fdf7f2 TL |
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 | } |