]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | |
2 | #include "cls/rgw/cls_rgw_ops.h" | |
3 | ||
4 | #include "common/Formatter.h" | |
5 | #include "common/ceph_json.h" | |
6 | #include "include/utime.h" | |
7 | ||
8 | void rgw_cls_tag_timeout_op::dump(Formatter *f) const | |
9 | { | |
10 | f->dump_int("tag_timeout", tag_timeout); | |
11 | } | |
12 | ||
13 | void rgw_cls_tag_timeout_op::generate_test_instances(list<rgw_cls_tag_timeout_op*>& ls) | |
14 | { | |
15 | ls.push_back(new rgw_cls_tag_timeout_op); | |
16 | ls.push_back(new rgw_cls_tag_timeout_op); | |
17 | ls.back()->tag_timeout = 23323; | |
18 | } | |
19 | ||
20 | void cls_rgw_gc_set_entry_op::dump(Formatter *f) const | |
21 | { | |
22 | f->dump_unsigned("expiration_secs", expiration_secs); | |
23 | f->open_object_section("obj_info"); | |
24 | info.dump(f); | |
25 | f->close_section(); | |
26 | } | |
27 | ||
28 | void cls_rgw_gc_set_entry_op::generate_test_instances(list<cls_rgw_gc_set_entry_op*>& ls) | |
29 | { | |
30 | ls.push_back(new cls_rgw_gc_set_entry_op); | |
31 | ls.push_back(new cls_rgw_gc_set_entry_op); | |
32 | ls.back()->expiration_secs = 123; | |
33 | } | |
34 | ||
35 | void cls_rgw_gc_defer_entry_op::dump(Formatter *f) const | |
36 | { | |
37 | f->dump_unsigned("expiration_secs", expiration_secs); | |
38 | f->dump_string("tag", tag); | |
39 | } | |
40 | ||
41 | void cls_rgw_gc_defer_entry_op::generate_test_instances(list<cls_rgw_gc_defer_entry_op*>& ls) | |
42 | { | |
43 | ls.push_back(new cls_rgw_gc_defer_entry_op); | |
44 | ls.push_back(new cls_rgw_gc_defer_entry_op); | |
45 | ls.back()->expiration_secs = 123; | |
46 | ls.back()->tag = "footag"; | |
47 | } | |
48 | ||
49 | void cls_rgw_gc_list_op::dump(Formatter *f) const | |
50 | { | |
51 | f->dump_string("marker", marker); | |
52 | f->dump_unsigned("max", max); | |
53 | f->dump_bool("expired_only", expired_only); | |
54 | } | |
55 | ||
56 | void cls_rgw_gc_list_op::generate_test_instances(list<cls_rgw_gc_list_op*>& ls) | |
57 | { | |
58 | ls.push_back(new cls_rgw_gc_list_op); | |
59 | ls.push_back(new cls_rgw_gc_list_op); | |
60 | ls.back()->marker = "mymarker"; | |
61 | ls.back()->max = 2312; | |
62 | } | |
63 | ||
64 | void cls_rgw_gc_list_ret::dump(Formatter *f) const | |
65 | { | |
66 | encode_json("entries", entries, f); | |
31f18b77 | 67 | f->dump_string("next_marker", next_marker); |
7c673cae FG |
68 | f->dump_int("truncated", (int)truncated); |
69 | } | |
70 | ||
71 | void cls_rgw_gc_list_ret::generate_test_instances(list<cls_rgw_gc_list_ret*>& ls) | |
72 | { | |
73 | ls.push_back(new cls_rgw_gc_list_ret); | |
74 | ls.push_back(new cls_rgw_gc_list_ret); | |
75 | ls.back()->entries.push_back(cls_rgw_gc_obj_info()); | |
76 | ls.back()->truncated = true; | |
77 | } | |
78 | ||
79 | ||
80 | void cls_rgw_gc_remove_op::dump(Formatter *f) const | |
81 | { | |
82 | encode_json("tags", tags, f); | |
83 | } | |
84 | ||
85 | void cls_rgw_gc_remove_op::generate_test_instances(list<cls_rgw_gc_remove_op*>& ls) | |
86 | { | |
87 | ls.push_back(new cls_rgw_gc_remove_op); | |
88 | ls.push_back(new cls_rgw_gc_remove_op); | |
89 | ls.back()->tags.push_back("tag1"); | |
90 | ls.back()->tags.push_back("tag2"); | |
91 | } | |
92 | ||
93 | void rgw_cls_obj_prepare_op::generate_test_instances(list<rgw_cls_obj_prepare_op*>& o) | |
94 | { | |
95 | rgw_cls_obj_prepare_op *op = new rgw_cls_obj_prepare_op; | |
96 | op->op = CLS_RGW_OP_ADD; | |
97 | op->key.name = "name"; | |
98 | op->tag = "tag"; | |
99 | op->locator = "locator"; | |
100 | o.push_back(op); | |
101 | o.push_back(new rgw_cls_obj_prepare_op); | |
102 | } | |
103 | ||
104 | void rgw_cls_obj_prepare_op::dump(Formatter *f) const | |
105 | { | |
106 | f->dump_int("op", op); | |
107 | f->dump_string("name", key.name); | |
108 | f->dump_string("tag", tag); | |
109 | f->dump_string("locator", locator); | |
110 | f->dump_bool("log_op", log_op); | |
111 | f->dump_int("bilog_flags", bilog_flags); | |
31f18b77 | 112 | ::encode_json("zones_trace", zones_trace, f); |
7c673cae FG |
113 | } |
114 | ||
115 | void rgw_cls_obj_complete_op::generate_test_instances(list<rgw_cls_obj_complete_op*>& o) | |
116 | { | |
117 | rgw_cls_obj_complete_op *op = new rgw_cls_obj_complete_op; | |
118 | op->op = CLS_RGW_OP_DEL; | |
119 | op->key.name = "name"; | |
120 | op->locator = "locator"; | |
121 | op->ver.pool = 2; | |
122 | op->ver.epoch = 100; | |
123 | op->tag = "tag"; | |
124 | ||
125 | list<rgw_bucket_dir_entry_meta *> l; | |
126 | rgw_bucket_dir_entry_meta::generate_test_instances(l); | |
127 | list<rgw_bucket_dir_entry_meta *>::iterator iter = l.begin(); | |
128 | op->meta = *(*iter); | |
129 | ||
130 | o.push_back(op); | |
131 | ||
132 | o.push_back(new rgw_cls_obj_complete_op); | |
133 | } | |
134 | ||
135 | void rgw_cls_obj_complete_op::dump(Formatter *f) const | |
136 | { | |
137 | f->dump_int("op", (int)op); | |
138 | f->dump_string("name", key.name); | |
139 | f->dump_string("instance", key.instance); | |
140 | f->dump_string("locator", locator); | |
141 | f->open_object_section("ver"); | |
142 | ver.dump(f); | |
143 | f->close_section(); | |
144 | f->open_object_section("meta"); | |
145 | meta.dump(f); | |
146 | f->close_section(); | |
147 | f->dump_string("tag", tag); | |
148 | f->dump_bool("log_op", log_op); | |
149 | f->dump_int("bilog_flags", bilog_flags); | |
31f18b77 | 150 | ::encode_json("zones_trace", zones_trace, f); |
7c673cae FG |
151 | } |
152 | ||
153 | void rgw_cls_link_olh_op::generate_test_instances(list<rgw_cls_link_olh_op*>& o) | |
154 | { | |
155 | rgw_cls_link_olh_op *op = new rgw_cls_link_olh_op; | |
156 | op->key.name = "name"; | |
157 | op->olh_tag = "olh_tag"; | |
158 | op->delete_marker = true; | |
159 | op->op_tag = "op_tag"; | |
160 | op->olh_epoch = 123; | |
161 | list<rgw_bucket_dir_entry_meta *> l; | |
162 | rgw_bucket_dir_entry_meta::generate_test_instances(l); | |
163 | list<rgw_bucket_dir_entry_meta *>::iterator iter = l.begin(); | |
164 | op->meta = *(*iter); | |
165 | op->log_op = true; | |
166 | ||
167 | o.push_back(op); | |
168 | ||
169 | o.push_back(new rgw_cls_link_olh_op); | |
170 | } | |
171 | ||
172 | void rgw_cls_link_olh_op::dump(Formatter *f) const | |
173 | { | |
174 | ::encode_json("key", key, f); | |
175 | ::encode_json("olh_tag", olh_tag, f); | |
176 | ::encode_json("delete_marker", delete_marker, f); | |
177 | ::encode_json("op_tag", op_tag, f); | |
178 | ::encode_json("meta", meta, f); | |
179 | ::encode_json("olh_epoch", olh_epoch, f); | |
180 | ::encode_json("log_op", log_op, f); | |
181 | ::encode_json("bilog_flags", (uint32_t)bilog_flags, f); | |
182 | utime_t ut(unmod_since); | |
183 | ::encode_json("unmod_since", ut, f); | |
184 | ::encode_json("high_precision_time", high_precision_time, f); | |
31f18b77 | 185 | ::encode_json("zones_trace", zones_trace, f); |
7c673cae FG |
186 | } |
187 | ||
188 | void rgw_cls_unlink_instance_op::generate_test_instances(list<rgw_cls_unlink_instance_op*>& o) | |
189 | { | |
190 | rgw_cls_unlink_instance_op *op = new rgw_cls_unlink_instance_op; | |
191 | op->key.name = "name"; | |
192 | op->op_tag = "op_tag"; | |
193 | op->olh_epoch = 124; | |
194 | op->log_op = true; | |
195 | ||
196 | o.push_back(op); | |
197 | ||
198 | o.push_back(new rgw_cls_unlink_instance_op); | |
199 | } | |
200 | ||
201 | void rgw_cls_unlink_instance_op::dump(Formatter *f) const | |
202 | { | |
203 | ::encode_json("key", key, f); | |
204 | ::encode_json("op_tag", op_tag, f); | |
205 | ::encode_json("olh_epoch", olh_epoch, f); | |
206 | ::encode_json("log_op", log_op, f); | |
207 | ::encode_json("bilog_flags", (uint32_t)bilog_flags, f); | |
31f18b77 | 208 | ::encode_json("zones_trace", zones_trace, f); |
7c673cae FG |
209 | } |
210 | ||
211 | void rgw_cls_read_olh_log_op::generate_test_instances(list<rgw_cls_read_olh_log_op*>& o) | |
212 | { | |
213 | rgw_cls_read_olh_log_op *op = new rgw_cls_read_olh_log_op; | |
214 | op->olh.name = "name"; | |
215 | op->ver_marker = 123; | |
216 | op->olh_tag = "olh_tag"; | |
217 | ||
218 | o.push_back(op); | |
219 | ||
220 | o.push_back(new rgw_cls_read_olh_log_op); | |
221 | } | |
222 | ||
223 | void rgw_cls_read_olh_log_op::dump(Formatter *f) const | |
224 | { | |
225 | ::encode_json("olh", olh, f); | |
226 | ::encode_json("ver_marker", ver_marker, f); | |
227 | ::encode_json("olh_tag", olh_tag, f); | |
228 | } | |
229 | ||
230 | void rgw_cls_read_olh_log_ret::generate_test_instances(list<rgw_cls_read_olh_log_ret*>& o) | |
231 | { | |
232 | rgw_cls_read_olh_log_ret *r = new rgw_cls_read_olh_log_ret; | |
233 | r->is_truncated = true; | |
234 | list<rgw_bucket_olh_log_entry *> l; | |
235 | rgw_bucket_olh_log_entry::generate_test_instances(l); | |
236 | list<rgw_bucket_olh_log_entry *>::iterator iter = l.begin(); | |
237 | r->log[1].push_back(*(*iter)); | |
238 | ||
239 | o.push_back(r); | |
240 | ||
241 | o.push_back(new rgw_cls_read_olh_log_ret); | |
242 | } | |
243 | ||
244 | void rgw_cls_read_olh_log_ret::dump(Formatter *f) const | |
245 | { | |
246 | ::encode_json("log", log, f); | |
247 | ::encode_json("is_truncated", is_truncated, f); | |
248 | } | |
249 | ||
250 | void rgw_cls_trim_olh_log_op::generate_test_instances(list<rgw_cls_trim_olh_log_op*>& o) | |
251 | { | |
252 | rgw_cls_trim_olh_log_op *op = new rgw_cls_trim_olh_log_op; | |
253 | op->olh.name = "olh.name"; | |
254 | op->ver = 100; | |
255 | op->olh_tag = "olh_tag"; | |
256 | ||
257 | o.push_back(op); | |
258 | ||
259 | o.push_back(new rgw_cls_trim_olh_log_op); | |
260 | } | |
261 | ||
262 | void rgw_cls_trim_olh_log_op::dump(Formatter *f) const | |
263 | { | |
264 | ::encode_json("olh", olh, f); | |
265 | ::encode_json("ver", ver, f); | |
266 | ::encode_json("olh_tag", olh_tag, f); | |
267 | } | |
268 | ||
269 | void rgw_cls_bucket_clear_olh_op::generate_test_instances(list<rgw_cls_bucket_clear_olh_op *>& o) | |
270 | { | |
271 | ||
272 | rgw_cls_bucket_clear_olh_op *op = new rgw_cls_bucket_clear_olh_op; | |
273 | op->key.name = "key.name"; | |
274 | op->olh_tag = "olh_tag"; | |
275 | ||
276 | o.push_back(op); | |
277 | o.push_back(new rgw_cls_bucket_clear_olh_op); | |
278 | } | |
279 | ||
280 | void rgw_cls_bucket_clear_olh_op::dump(Formatter *f) const | |
281 | { | |
282 | ::encode_json("key", key, f); | |
283 | ::encode_json("olh_tag", olh_tag, f); | |
284 | } | |
285 | ||
286 | void rgw_cls_list_op::generate_test_instances(list<rgw_cls_list_op*>& o) | |
287 | { | |
288 | rgw_cls_list_op *op = new rgw_cls_list_op; | |
289 | op->start_obj.name = "start_obj"; | |
290 | op->num_entries = 100; | |
291 | op->filter_prefix = "filter_prefix"; | |
292 | o.push_back(op); | |
293 | o.push_back(new rgw_cls_list_op); | |
294 | } | |
295 | ||
296 | void rgw_cls_list_op::dump(Formatter *f) const | |
297 | { | |
298 | f->dump_string("start_obj", start_obj.name); | |
299 | f->dump_unsigned("num_entries", num_entries); | |
300 | } | |
301 | ||
302 | void rgw_cls_list_ret::generate_test_instances(list<rgw_cls_list_ret*>& o) | |
303 | { | |
304 | list<rgw_bucket_dir *> l; | |
305 | rgw_bucket_dir::generate_test_instances(l); | |
306 | list<rgw_bucket_dir *>::iterator iter; | |
307 | for (iter = l.begin(); iter != l.end(); ++iter) { | |
308 | rgw_bucket_dir *d = *iter; | |
309 | ||
310 | rgw_cls_list_ret *ret = new rgw_cls_list_ret; | |
311 | ret->dir = *d; | |
312 | ret->is_truncated = true; | |
313 | ||
314 | o.push_back(ret); | |
315 | ||
316 | delete d; | |
317 | } | |
318 | ||
319 | o.push_back(new rgw_cls_list_ret); | |
320 | } | |
321 | ||
322 | void rgw_cls_list_ret::dump(Formatter *f) const | |
323 | { | |
324 | f->open_object_section("dir"); | |
325 | dir.dump(f); | |
326 | f->close_section(); | |
327 | f->dump_int("is_truncated", (int)is_truncated); | |
328 | } | |
329 | ||
330 | void rgw_cls_check_index_ret::generate_test_instances(list<rgw_cls_check_index_ret*>& o) | |
331 | { | |
332 | list<rgw_bucket_dir_header *> h; | |
333 | rgw_bucket_dir_header::generate_test_instances(h); | |
334 | rgw_cls_check_index_ret *r = new rgw_cls_check_index_ret; | |
335 | r->existing_header = *(h.front()); | |
336 | r->calculated_header = *(h.front()); | |
337 | o.push_back(r); | |
338 | ||
339 | for (list<rgw_bucket_dir_header *>::iterator iter = h.begin(); iter != h.end(); ++iter) { | |
340 | delete *iter; | |
341 | } | |
342 | o.push_back(new rgw_cls_check_index_ret); | |
343 | } | |
344 | ||
345 | void rgw_cls_check_index_ret::dump(Formatter *f) const | |
346 | { | |
347 | ::encode_json("existing_header", existing_header, f); | |
348 | ::encode_json("calculated_header", calculated_header, f); | |
349 | } | |
350 | ||
351 | void rgw_cls_bucket_update_stats_op::generate_test_instances(list<rgw_cls_bucket_update_stats_op*>& o) | |
352 | { | |
353 | rgw_cls_bucket_update_stats_op *r = new rgw_cls_bucket_update_stats_op; | |
354 | r->absolute = true; | |
355 | rgw_bucket_category_stats& s = r->stats[0]; | |
356 | s.total_size = 1; | |
357 | s.total_size_rounded = 4096; | |
358 | s.num_entries = 1; | |
359 | o.push_back(r); | |
360 | ||
361 | o.push_back(new rgw_cls_bucket_update_stats_op); | |
362 | } | |
363 | ||
364 | void rgw_cls_bucket_update_stats_op::dump(Formatter *f) const | |
365 | { | |
366 | ::encode_json("absolute", absolute, f); | |
367 | map<int, rgw_bucket_category_stats> s; | |
368 | for (auto& entry : stats) { | |
369 | s[(int)entry.first] = entry.second; | |
370 | } | |
371 | ::encode_json("stats", s, f); | |
372 | } | |
373 | ||
374 | void cls_rgw_bi_log_list_op::dump(Formatter *f) const | |
375 | { | |
376 | f->dump_string("marker", marker); | |
377 | f->dump_unsigned("max", max); | |
378 | } | |
379 | ||
380 | void cls_rgw_bi_log_list_op::generate_test_instances(list<cls_rgw_bi_log_list_op*>& ls) | |
381 | { | |
382 | ls.push_back(new cls_rgw_bi_log_list_op); | |
383 | ls.push_back(new cls_rgw_bi_log_list_op); | |
384 | ls.back()->marker = "mark"; | |
385 | ls.back()->max = 123; | |
386 | } | |
387 | ||
388 | void cls_rgw_bi_log_trim_op::dump(Formatter *f) const | |
389 | { | |
390 | f->dump_string("start_marker", start_marker); | |
391 | f->dump_string("end_marker", end_marker); | |
392 | } | |
393 | ||
394 | void cls_rgw_bi_log_trim_op::generate_test_instances(list<cls_rgw_bi_log_trim_op*>& ls) | |
395 | { | |
396 | ls.push_back(new cls_rgw_bi_log_trim_op); | |
397 | ls.push_back(new cls_rgw_bi_log_trim_op); | |
398 | ls.back()->start_marker = "foo"; | |
399 | ls.back()->end_marker = "bar"; | |
400 | } | |
401 | ||
402 | void cls_rgw_bi_log_list_ret::dump(Formatter *f) const | |
403 | { | |
404 | encode_json("entries", entries, f); | |
405 | f->dump_unsigned("truncated", (int)truncated); | |
406 | } | |
407 | ||
408 | void cls_rgw_bi_log_list_ret::generate_test_instances(list<cls_rgw_bi_log_list_ret*>& ls) | |
409 | { | |
410 | ls.push_back(new cls_rgw_bi_log_list_ret); | |
411 | ls.push_back(new cls_rgw_bi_log_list_ret); | |
412 | ls.back()->entries.push_back(rgw_bi_log_entry()); | |
413 | ls.back()->truncated = true; | |
414 | } | |
31f18b77 FG |
415 | |
416 | void cls_rgw_reshard_add_op::generate_test_instances(list<cls_rgw_reshard_add_op*>& ls) | |
417 | { | |
418 | ls.push_back(new cls_rgw_reshard_add_op); | |
419 | ls.push_back(new cls_rgw_reshard_add_op); | |
420 | list<cls_rgw_reshard_entry *> l; | |
421 | cls_rgw_reshard_entry::generate_test_instances(l); | |
422 | list<cls_rgw_reshard_entry *>::iterator iter = l.begin(); | |
423 | ls.back()->entry = *(*iter); | |
424 | } | |
425 | ||
426 | void cls_rgw_reshard_add_op::dump(Formatter *f) const | |
427 | { | |
428 | ::encode_json("entry", entry, f); | |
429 | } | |
430 | ||
431 | void cls_rgw_reshard_list_op::generate_test_instances(list<cls_rgw_reshard_list_op*>& ls) | |
432 | { | |
433 | ls.push_back(new cls_rgw_reshard_list_op); | |
434 | ls.push_back(new cls_rgw_reshard_list_op); | |
435 | ls.back()->max = 1000; | |
436 | ls.back()->marker = "foo"; | |
437 | } | |
438 | ||
439 | void cls_rgw_reshard_list_op::dump(Formatter *f) const | |
440 | { | |
441 | ::encode_json("max", max, f); | |
442 | ::encode_json("marker", marker, f); | |
443 | } | |
444 | ||
445 | void cls_rgw_reshard_list_ret::generate_test_instances(list<cls_rgw_reshard_list_ret*>& ls) | |
446 | { | |
447 | ls.push_back(new cls_rgw_reshard_list_ret); | |
448 | ls.push_back(new cls_rgw_reshard_list_ret); | |
449 | ls.back()->entries.push_back(cls_rgw_reshard_entry()); | |
450 | ls.back()->is_truncated = true; | |
451 | } | |
452 | ||
453 | void cls_rgw_reshard_list_ret::dump(Formatter *f) const | |
454 | { | |
455 | ::encode_json("entries", entries, f); | |
456 | ::encode_json("is_truncated", is_truncated, f); | |
457 | } | |
458 | ||
459 | void cls_rgw_reshard_get_op::generate_test_instances(list<cls_rgw_reshard_get_op*>& ls) | |
460 | { | |
461 | ls.push_back(new cls_rgw_reshard_get_op); | |
462 | ls.push_back(new cls_rgw_reshard_get_op); | |
463 | } | |
464 | ||
465 | void cls_rgw_reshard_get_op::dump(Formatter *f) const | |
466 | { | |
467 | ::encode_json("entry", entry, f); | |
468 | } | |
469 | ||
470 | void cls_rgw_reshard_get_ret::generate_test_instances(list<cls_rgw_reshard_get_ret*>& ls) | |
471 | { | |
472 | ls.push_back(new cls_rgw_reshard_get_ret); | |
473 | ls.push_back(new cls_rgw_reshard_get_ret); | |
474 | } | |
475 | ||
476 | void cls_rgw_reshard_get_ret::dump(Formatter *f) const | |
477 | { | |
478 | ::encode_json("entry", entry, f); | |
479 | } | |
480 | ||
481 | void cls_rgw_reshard_remove_op::generate_test_instances(list<cls_rgw_reshard_remove_op*>& ls) | |
482 | { | |
483 | ls.push_back(new cls_rgw_reshard_remove_op); | |
484 | ls.push_back(new cls_rgw_reshard_remove_op); | |
485 | ls.back()->bucket_name = "foo"; | |
486 | ls.back()->bucket_id = "bucket_id"; | |
487 | } | |
488 | ||
489 | void cls_rgw_reshard_remove_op::dump(Formatter *f) const | |
490 | { | |
491 | ::encode_json("bucket_name", bucket_name, f); | |
492 | ::encode_json("bucket_id", bucket_name, f); | |
493 | } | |
494 | ||
495 | ||
496 | void cls_rgw_set_bucket_resharding_op::generate_test_instances( | |
497 | list<cls_rgw_set_bucket_resharding_op*>& ls) | |
498 | { | |
499 | ls.push_back(new cls_rgw_set_bucket_resharding_op); | |
500 | ls.push_back(new cls_rgw_set_bucket_resharding_op); | |
501 | } | |
502 | ||
503 | void cls_rgw_set_bucket_resharding_op::dump(Formatter *f) const | |
504 | { | |
505 | ::encode_json("entry", entry, f); | |
506 | } | |
507 | ||
508 | void cls_rgw_clear_bucket_resharding_op::generate_test_instances( | |
509 | list<cls_rgw_clear_bucket_resharding_op*>& ls) | |
510 | { | |
511 | ls.push_back(new cls_rgw_clear_bucket_resharding_op); | |
512 | ls.push_back(new cls_rgw_clear_bucket_resharding_op); | |
513 | } | |
514 | ||
515 | void cls_rgw_clear_bucket_resharding_op::dump(Formatter *f) const | |
516 | { | |
517 | } | |
518 | ||
519 | void cls_rgw_guard_bucket_resharding_op::generate_test_instances( | |
520 | list<cls_rgw_guard_bucket_resharding_op*>& ls) | |
521 | { | |
522 | ls.push_back(new cls_rgw_guard_bucket_resharding_op); | |
523 | ls.push_back(new cls_rgw_guard_bucket_resharding_op); | |
524 | } | |
525 | ||
526 | void cls_rgw_guard_bucket_resharding_op::dump(Formatter *f) const | |
527 | { | |
528 | ::encode_json("ret_err", ret_err, f); | |
529 | } | |
530 | ||
531 | ||
532 | void cls_rgw_get_bucket_resharding_op::generate_test_instances( | |
533 | list<cls_rgw_get_bucket_resharding_op*>& ls) | |
534 | { | |
535 | ls.push_back(new cls_rgw_get_bucket_resharding_op); | |
536 | ls.push_back(new cls_rgw_get_bucket_resharding_op); | |
537 | } | |
538 | ||
539 | void cls_rgw_get_bucket_resharding_op::dump(Formatter *f) const | |
540 | { | |
541 | } | |
542 | ||
543 | ||
544 | ||
545 | ||
546 |