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