]>
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); | |
67 | f->dump_int("truncated", (int)truncated); | |
68 | } | |
69 | ||
70 | void cls_rgw_gc_list_ret::generate_test_instances(list<cls_rgw_gc_list_ret*>& ls) | |
71 | { | |
72 | ls.push_back(new cls_rgw_gc_list_ret); | |
73 | ls.push_back(new cls_rgw_gc_list_ret); | |
74 | ls.back()->entries.push_back(cls_rgw_gc_obj_info()); | |
75 | ls.back()->truncated = true; | |
76 | } | |
77 | ||
78 | ||
79 | void cls_rgw_gc_remove_op::dump(Formatter *f) const | |
80 | { | |
81 | encode_json("tags", tags, f); | |
82 | } | |
83 | ||
84 | void cls_rgw_gc_remove_op::generate_test_instances(list<cls_rgw_gc_remove_op*>& ls) | |
85 | { | |
86 | ls.push_back(new cls_rgw_gc_remove_op); | |
87 | ls.push_back(new cls_rgw_gc_remove_op); | |
88 | ls.back()->tags.push_back("tag1"); | |
89 | ls.back()->tags.push_back("tag2"); | |
90 | } | |
91 | ||
92 | void rgw_cls_obj_prepare_op::generate_test_instances(list<rgw_cls_obj_prepare_op*>& o) | |
93 | { | |
94 | rgw_cls_obj_prepare_op *op = new rgw_cls_obj_prepare_op; | |
95 | op->op = CLS_RGW_OP_ADD; | |
96 | op->key.name = "name"; | |
97 | op->tag = "tag"; | |
98 | op->locator = "locator"; | |
99 | o.push_back(op); | |
100 | o.push_back(new rgw_cls_obj_prepare_op); | |
101 | } | |
102 | ||
103 | void rgw_cls_obj_prepare_op::dump(Formatter *f) const | |
104 | { | |
105 | f->dump_int("op", op); | |
106 | f->dump_string("name", key.name); | |
107 | f->dump_string("tag", tag); | |
108 | f->dump_string("locator", locator); | |
109 | f->dump_bool("log_op", log_op); | |
110 | f->dump_int("bilog_flags", bilog_flags); | |
111 | } | |
112 | ||
113 | void rgw_cls_obj_complete_op::generate_test_instances(list<rgw_cls_obj_complete_op*>& o) | |
114 | { | |
115 | rgw_cls_obj_complete_op *op = new rgw_cls_obj_complete_op; | |
116 | op->op = CLS_RGW_OP_DEL; | |
117 | op->key.name = "name"; | |
118 | op->locator = "locator"; | |
119 | op->ver.pool = 2; | |
120 | op->ver.epoch = 100; | |
121 | op->tag = "tag"; | |
122 | ||
123 | list<rgw_bucket_dir_entry_meta *> l; | |
124 | rgw_bucket_dir_entry_meta::generate_test_instances(l); | |
125 | list<rgw_bucket_dir_entry_meta *>::iterator iter = l.begin(); | |
126 | op->meta = *(*iter); | |
127 | ||
128 | o.push_back(op); | |
129 | ||
130 | o.push_back(new rgw_cls_obj_complete_op); | |
131 | } | |
132 | ||
133 | void rgw_cls_obj_complete_op::dump(Formatter *f) const | |
134 | { | |
135 | f->dump_int("op", (int)op); | |
136 | f->dump_string("name", key.name); | |
137 | f->dump_string("instance", key.instance); | |
138 | f->dump_string("locator", locator); | |
139 | f->open_object_section("ver"); | |
140 | ver.dump(f); | |
141 | f->close_section(); | |
142 | f->open_object_section("meta"); | |
143 | meta.dump(f); | |
144 | f->close_section(); | |
145 | f->dump_string("tag", tag); | |
146 | f->dump_bool("log_op", log_op); | |
147 | f->dump_int("bilog_flags", bilog_flags); | |
148 | } | |
149 | ||
150 | void rgw_cls_link_olh_op::generate_test_instances(list<rgw_cls_link_olh_op*>& o) | |
151 | { | |
152 | rgw_cls_link_olh_op *op = new rgw_cls_link_olh_op; | |
153 | op->key.name = "name"; | |
154 | op->olh_tag = "olh_tag"; | |
155 | op->delete_marker = true; | |
156 | op->op_tag = "op_tag"; | |
157 | op->olh_epoch = 123; | |
158 | list<rgw_bucket_dir_entry_meta *> l; | |
159 | rgw_bucket_dir_entry_meta::generate_test_instances(l); | |
160 | list<rgw_bucket_dir_entry_meta *>::iterator iter = l.begin(); | |
161 | op->meta = *(*iter); | |
162 | op->log_op = true; | |
163 | ||
164 | o.push_back(op); | |
165 | ||
166 | o.push_back(new rgw_cls_link_olh_op); | |
167 | } | |
168 | ||
169 | void rgw_cls_link_olh_op::dump(Formatter *f) const | |
170 | { | |
171 | ::encode_json("key", key, f); | |
172 | ::encode_json("olh_tag", olh_tag, f); | |
173 | ::encode_json("delete_marker", delete_marker, f); | |
174 | ::encode_json("op_tag", op_tag, f); | |
175 | ::encode_json("meta", meta, f); | |
176 | ::encode_json("olh_epoch", olh_epoch, f); | |
177 | ::encode_json("log_op", log_op, f); | |
178 | ::encode_json("bilog_flags", (uint32_t)bilog_flags, f); | |
179 | utime_t ut(unmod_since); | |
180 | ::encode_json("unmod_since", ut, f); | |
181 | ::encode_json("high_precision_time", high_precision_time, f); | |
182 | } | |
183 | ||
184 | void rgw_cls_unlink_instance_op::generate_test_instances(list<rgw_cls_unlink_instance_op*>& o) | |
185 | { | |
186 | rgw_cls_unlink_instance_op *op = new rgw_cls_unlink_instance_op; | |
187 | op->key.name = "name"; | |
188 | op->op_tag = "op_tag"; | |
189 | op->olh_epoch = 124; | |
190 | op->log_op = true; | |
191 | ||
192 | o.push_back(op); | |
193 | ||
194 | o.push_back(new rgw_cls_unlink_instance_op); | |
195 | } | |
196 | ||
197 | void rgw_cls_unlink_instance_op::dump(Formatter *f) const | |
198 | { | |
199 | ::encode_json("key", key, f); | |
200 | ::encode_json("op_tag", op_tag, f); | |
201 | ::encode_json("olh_epoch", olh_epoch, f); | |
202 | ::encode_json("log_op", log_op, f); | |
203 | ::encode_json("bilog_flags", (uint32_t)bilog_flags, f); | |
204 | } | |
205 | ||
206 | void rgw_cls_read_olh_log_op::generate_test_instances(list<rgw_cls_read_olh_log_op*>& o) | |
207 | { | |
208 | rgw_cls_read_olh_log_op *op = new rgw_cls_read_olh_log_op; | |
209 | op->olh.name = "name"; | |
210 | op->ver_marker = 123; | |
211 | op->olh_tag = "olh_tag"; | |
212 | ||
213 | o.push_back(op); | |
214 | ||
215 | o.push_back(new rgw_cls_read_olh_log_op); | |
216 | } | |
217 | ||
218 | void rgw_cls_read_olh_log_op::dump(Formatter *f) const | |
219 | { | |
220 | ::encode_json("olh", olh, f); | |
221 | ::encode_json("ver_marker", ver_marker, f); | |
222 | ::encode_json("olh_tag", olh_tag, f); | |
223 | } | |
224 | ||
225 | void rgw_cls_read_olh_log_ret::generate_test_instances(list<rgw_cls_read_olh_log_ret*>& o) | |
226 | { | |
227 | rgw_cls_read_olh_log_ret *r = new rgw_cls_read_olh_log_ret; | |
228 | r->is_truncated = true; | |
229 | list<rgw_bucket_olh_log_entry *> l; | |
230 | rgw_bucket_olh_log_entry::generate_test_instances(l); | |
231 | list<rgw_bucket_olh_log_entry *>::iterator iter = l.begin(); | |
232 | r->log[1].push_back(*(*iter)); | |
233 | ||
234 | o.push_back(r); | |
235 | ||
236 | o.push_back(new rgw_cls_read_olh_log_ret); | |
237 | } | |
238 | ||
239 | void rgw_cls_read_olh_log_ret::dump(Formatter *f) const | |
240 | { | |
241 | ::encode_json("log", log, f); | |
242 | ::encode_json("is_truncated", is_truncated, f); | |
243 | } | |
244 | ||
245 | void rgw_cls_trim_olh_log_op::generate_test_instances(list<rgw_cls_trim_olh_log_op*>& o) | |
246 | { | |
247 | rgw_cls_trim_olh_log_op *op = new rgw_cls_trim_olh_log_op; | |
248 | op->olh.name = "olh.name"; | |
249 | op->ver = 100; | |
250 | op->olh_tag = "olh_tag"; | |
251 | ||
252 | o.push_back(op); | |
253 | ||
254 | o.push_back(new rgw_cls_trim_olh_log_op); | |
255 | } | |
256 | ||
257 | void rgw_cls_trim_olh_log_op::dump(Formatter *f) const | |
258 | { | |
259 | ::encode_json("olh", olh, f); | |
260 | ::encode_json("ver", ver, f); | |
261 | ::encode_json("olh_tag", olh_tag, f); | |
262 | } | |
263 | ||
264 | void rgw_cls_bucket_clear_olh_op::generate_test_instances(list<rgw_cls_bucket_clear_olh_op *>& o) | |
265 | { | |
266 | ||
267 | rgw_cls_bucket_clear_olh_op *op = new rgw_cls_bucket_clear_olh_op; | |
268 | op->key.name = "key.name"; | |
269 | op->olh_tag = "olh_tag"; | |
270 | ||
271 | o.push_back(op); | |
272 | o.push_back(new rgw_cls_bucket_clear_olh_op); | |
273 | } | |
274 | ||
275 | void rgw_cls_bucket_clear_olh_op::dump(Formatter *f) const | |
276 | { | |
277 | ::encode_json("key", key, f); | |
278 | ::encode_json("olh_tag", olh_tag, f); | |
279 | } | |
280 | ||
281 | void rgw_cls_list_op::generate_test_instances(list<rgw_cls_list_op*>& o) | |
282 | { | |
283 | rgw_cls_list_op *op = new rgw_cls_list_op; | |
284 | op->start_obj.name = "start_obj"; | |
285 | op->num_entries = 100; | |
286 | op->filter_prefix = "filter_prefix"; | |
287 | o.push_back(op); | |
288 | o.push_back(new rgw_cls_list_op); | |
289 | } | |
290 | ||
291 | void rgw_cls_list_op::dump(Formatter *f) const | |
292 | { | |
293 | f->dump_string("start_obj", start_obj.name); | |
294 | f->dump_unsigned("num_entries", num_entries); | |
295 | } | |
296 | ||
297 | void rgw_cls_list_ret::generate_test_instances(list<rgw_cls_list_ret*>& o) | |
298 | { | |
299 | list<rgw_bucket_dir *> l; | |
300 | rgw_bucket_dir::generate_test_instances(l); | |
301 | list<rgw_bucket_dir *>::iterator iter; | |
302 | for (iter = l.begin(); iter != l.end(); ++iter) { | |
303 | rgw_bucket_dir *d = *iter; | |
304 | ||
305 | rgw_cls_list_ret *ret = new rgw_cls_list_ret; | |
306 | ret->dir = *d; | |
307 | ret->is_truncated = true; | |
308 | ||
309 | o.push_back(ret); | |
310 | ||
311 | delete d; | |
312 | } | |
313 | ||
314 | o.push_back(new rgw_cls_list_ret); | |
315 | } | |
316 | ||
317 | void rgw_cls_list_ret::dump(Formatter *f) const | |
318 | { | |
319 | f->open_object_section("dir"); | |
320 | dir.dump(f); | |
321 | f->close_section(); | |
322 | f->dump_int("is_truncated", (int)is_truncated); | |
323 | } | |
324 | ||
325 | void rgw_cls_check_index_ret::generate_test_instances(list<rgw_cls_check_index_ret*>& o) | |
326 | { | |
327 | list<rgw_bucket_dir_header *> h; | |
328 | rgw_bucket_dir_header::generate_test_instances(h); | |
329 | rgw_cls_check_index_ret *r = new rgw_cls_check_index_ret; | |
330 | r->existing_header = *(h.front()); | |
331 | r->calculated_header = *(h.front()); | |
332 | o.push_back(r); | |
333 | ||
334 | for (list<rgw_bucket_dir_header *>::iterator iter = h.begin(); iter != h.end(); ++iter) { | |
335 | delete *iter; | |
336 | } | |
337 | o.push_back(new rgw_cls_check_index_ret); | |
338 | } | |
339 | ||
340 | void rgw_cls_check_index_ret::dump(Formatter *f) const | |
341 | { | |
342 | ::encode_json("existing_header", existing_header, f); | |
343 | ::encode_json("calculated_header", calculated_header, f); | |
344 | } | |
345 | ||
346 | void rgw_cls_bucket_update_stats_op::generate_test_instances(list<rgw_cls_bucket_update_stats_op*>& o) | |
347 | { | |
348 | rgw_cls_bucket_update_stats_op *r = new rgw_cls_bucket_update_stats_op; | |
349 | r->absolute = true; | |
350 | rgw_bucket_category_stats& s = r->stats[0]; | |
351 | s.total_size = 1; | |
352 | s.total_size_rounded = 4096; | |
353 | s.num_entries = 1; | |
354 | o.push_back(r); | |
355 | ||
356 | o.push_back(new rgw_cls_bucket_update_stats_op); | |
357 | } | |
358 | ||
359 | void rgw_cls_bucket_update_stats_op::dump(Formatter *f) const | |
360 | { | |
361 | ::encode_json("absolute", absolute, f); | |
362 | map<int, rgw_bucket_category_stats> s; | |
363 | for (auto& entry : stats) { | |
364 | s[(int)entry.first] = entry.second; | |
365 | } | |
366 | ::encode_json("stats", s, f); | |
367 | } | |
368 | ||
369 | void cls_rgw_bi_log_list_op::dump(Formatter *f) const | |
370 | { | |
371 | f->dump_string("marker", marker); | |
372 | f->dump_unsigned("max", max); | |
373 | } | |
374 | ||
375 | void cls_rgw_bi_log_list_op::generate_test_instances(list<cls_rgw_bi_log_list_op*>& ls) | |
376 | { | |
377 | ls.push_back(new cls_rgw_bi_log_list_op); | |
378 | ls.push_back(new cls_rgw_bi_log_list_op); | |
379 | ls.back()->marker = "mark"; | |
380 | ls.back()->max = 123; | |
381 | } | |
382 | ||
383 | void cls_rgw_bi_log_trim_op::dump(Formatter *f) const | |
384 | { | |
385 | f->dump_string("start_marker", start_marker); | |
386 | f->dump_string("end_marker", end_marker); | |
387 | } | |
388 | ||
389 | void cls_rgw_bi_log_trim_op::generate_test_instances(list<cls_rgw_bi_log_trim_op*>& ls) | |
390 | { | |
391 | ls.push_back(new cls_rgw_bi_log_trim_op); | |
392 | ls.push_back(new cls_rgw_bi_log_trim_op); | |
393 | ls.back()->start_marker = "foo"; | |
394 | ls.back()->end_marker = "bar"; | |
395 | } | |
396 | ||
397 | void cls_rgw_bi_log_list_ret::dump(Formatter *f) const | |
398 | { | |
399 | encode_json("entries", entries, f); | |
400 | f->dump_unsigned("truncated", (int)truncated); | |
401 | } | |
402 | ||
403 | void cls_rgw_bi_log_list_ret::generate_test_instances(list<cls_rgw_bi_log_list_ret*>& ls) | |
404 | { | |
405 | ls.push_back(new cls_rgw_bi_log_list_ret); | |
406 | ls.push_back(new cls_rgw_bi_log_list_ret); | |
407 | ls.back()->entries.push_back(rgw_bi_log_entry()); | |
408 | ls.back()->truncated = true; | |
409 | } |