1 #ifndef CEPH_CLS_RGW_OPS_H
2 #define CEPH_CLS_RGW_OPS_H
4 #include "cls/rgw/cls_rgw_types.h"
6 struct rgw_cls_tag_timeout_op
10 rgw_cls_tag_timeout_op() : tag_timeout(0) {}
12 void encode(bufferlist
&bl
) const {
13 ENCODE_START(1, 1, bl
);
14 ::encode(tag_timeout
, bl
);
17 void decode(bufferlist::iterator
&bl
) {
19 ::decode(tag_timeout
, bl
);
22 void dump(Formatter
*f
) const;
23 static void generate_test_instances(list
<rgw_cls_tag_timeout_op
*>& ls
);
25 WRITE_CLASS_ENCODER(rgw_cls_tag_timeout_op
)
27 struct rgw_cls_obj_prepare_op
35 rgw_zone_set zones_trace
;
37 rgw_cls_obj_prepare_op() : op(CLS_RGW_OP_UNKNOWN
), log_op(false), bilog_flags(0) {}
39 void encode(bufferlist
&bl
) const {
40 ENCODE_START(7, 5, bl
);
41 uint8_t c
= (uint8_t)op
;
44 ::encode(locator
, bl
);
47 ::encode(bilog_flags
, bl
);
48 ::encode(zones_trace
, bl
);
51 void decode(bufferlist::iterator
&bl
) {
52 DECODE_START_LEGACY_COMPAT_LEN(7, 3, 3, bl
);
57 ::decode(key
.name
, bl
);
61 ::decode(locator
, bl
);
70 ::decode(bilog_flags
, bl
);
73 ::decode(zones_trace
, bl
);
77 void dump(Formatter
*f
) const;
78 static void generate_test_instances(list
<rgw_cls_obj_prepare_op
*>& o
);
80 WRITE_CLASS_ENCODER(rgw_cls_obj_prepare_op
)
82 struct rgw_cls_obj_complete_op
87 rgw_bucket_entry_ver ver
;
88 struct rgw_bucket_dir_entry_meta meta
;
93 list
<cls_rgw_obj_key
> remove_objs
;
94 rgw_zone_set zones_trace
;
96 rgw_cls_obj_complete_op() : op(CLS_RGW_OP_ADD
), log_op(false), bilog_flags(0) {}
98 void encode(bufferlist
&bl
) const {
99 ENCODE_START(9, 7, bl
);
100 uint8_t c
= (uint8_t)op
;
102 ::encode(ver
.epoch
, bl
);
105 ::encode(locator
, bl
);
106 ::encode(remove_objs
, bl
);
108 ::encode(log_op
, bl
);
110 ::encode(bilog_flags
, bl
);
111 ::encode(zones_trace
, bl
);
114 void decode(bufferlist::iterator
&bl
) {
115 DECODE_START_LEGACY_COMPAT_LEN(9, 3, 3, bl
);
120 ::decode(key
.name
, bl
);
122 ::decode(ver
.epoch
, bl
);
126 ::decode(locator
, bl
);
128 if (struct_v
>= 4 && struct_v
< 7) {
129 list
<string
> old_remove_objs
;
130 ::decode(old_remove_objs
, bl
);
132 for (list
<string
>::iterator iter
= old_remove_objs
.begin();
133 iter
!= old_remove_objs
.end(); ++iter
) {
136 remove_objs
.push_back(k
);
139 ::decode(remove_objs
, bl
);
147 ::decode(log_op
, bl
);
153 ::decode(bilog_flags
, bl
);
156 ::decode(zones_trace
, bl
);
160 void dump(Formatter
*f
) const;
161 static void generate_test_instances(list
<rgw_cls_obj_complete_op
*>& o
);
163 WRITE_CLASS_ENCODER(rgw_cls_obj_complete_op
)
165 struct rgw_cls_link_olh_op
{
170 struct rgw_bucket_dir_entry_meta meta
;
173 uint16_t bilog_flags
;
174 real_time unmod_since
; /* only create delete marker if newer then this */
175 bool high_precision_time
;
176 rgw_zone_set zones_trace
;
178 rgw_cls_link_olh_op() : delete_marker(false), olh_epoch(0), log_op(false), bilog_flags(0), high_precision_time(false) {}
180 void encode(bufferlist
& bl
) const {
181 ENCODE_START(5, 1, bl
);
183 ::encode(olh_tag
, bl
);
184 ::encode(delete_marker
, bl
);
185 ::encode(op_tag
, bl
);
187 ::encode(olh_epoch
, bl
);
188 ::encode(log_op
, bl
);
189 ::encode(bilog_flags
, bl
);
190 uint64_t t
= ceph::real_clock::to_time_t(unmod_since
);
192 ::encode(unmod_since
, bl
);
193 ::encode(high_precision_time
, bl
);
194 ::encode(zones_trace
, bl
);
198 void decode(bufferlist::iterator
& bl
) {
201 ::decode(olh_tag
, bl
);
202 ::decode(delete_marker
, bl
);
203 ::decode(op_tag
, bl
);
205 ::decode(olh_epoch
, bl
);
206 ::decode(log_op
, bl
);
207 ::decode(bilog_flags
, bl
);
211 unmod_since
= ceph::real_clock::from_time_t(static_cast<time_t>(t
));
216 ::decode(unmod_since
, bl
);
219 ::decode(high_precision_time
, bl
);
222 ::decode(zones_trace
, bl
);
227 static void generate_test_instances(list
<rgw_cls_link_olh_op
*>& o
);
228 void dump(Formatter
*f
) const;
230 WRITE_CLASS_ENCODER(rgw_cls_link_olh_op
)
232 struct rgw_cls_unlink_instance_op
{
237 uint16_t bilog_flags
;
239 rgw_zone_set zones_trace
;
241 rgw_cls_unlink_instance_op() : olh_epoch(0), log_op(false), bilog_flags(0) {}
243 void encode(bufferlist
& bl
) const {
244 ENCODE_START(3, 1, bl
);
246 ::encode(op_tag
, bl
);
247 ::encode(olh_epoch
, bl
);
248 ::encode(log_op
, bl
);
249 ::encode(bilog_flags
, bl
);
250 ::encode(olh_tag
, bl
);
251 ::encode(zones_trace
, bl
);
255 void decode(bufferlist::iterator
& bl
) {
258 ::decode(op_tag
, bl
);
259 ::decode(olh_epoch
, bl
);
260 ::decode(log_op
, bl
);
261 ::decode(bilog_flags
, bl
);
263 ::decode(olh_tag
, bl
);
266 ::decode(zones_trace
, bl
);
271 static void generate_test_instances(list
<rgw_cls_unlink_instance_op
*>& o
);
272 void dump(Formatter
*f
) const;
274 WRITE_CLASS_ENCODER(rgw_cls_unlink_instance_op
)
276 struct rgw_cls_read_olh_log_op
282 rgw_cls_read_olh_log_op() : ver_marker(0) {}
284 void encode(bufferlist
&bl
) const {
285 ENCODE_START(1, 1, bl
);
287 ::encode(ver_marker
, bl
);
288 ::encode(olh_tag
, bl
);
291 void decode(bufferlist::iterator
&bl
) {
294 ::decode(ver_marker
, bl
);
295 ::decode(olh_tag
, bl
);
298 static void generate_test_instances(list
<rgw_cls_read_olh_log_op
*>& o
);
299 void dump(Formatter
*f
) const;
301 WRITE_CLASS_ENCODER(rgw_cls_read_olh_log_op
)
304 struct rgw_cls_read_olh_log_ret
306 map
<uint64_t, vector
<struct rgw_bucket_olh_log_entry
> > log
;
309 rgw_cls_read_olh_log_ret() : is_truncated(false) {}
311 void encode(bufferlist
&bl
) const {
312 ENCODE_START(1, 1, bl
);
314 ::encode(is_truncated
, bl
);
317 void decode(bufferlist::iterator
&bl
) {
320 ::decode(is_truncated
, bl
);
323 static void generate_test_instances(list
<rgw_cls_read_olh_log_ret
*>& o
);
324 void dump(Formatter
*f
) const;
326 WRITE_CLASS_ENCODER(rgw_cls_read_olh_log_ret
)
328 struct rgw_cls_trim_olh_log_op
334 rgw_cls_trim_olh_log_op() : ver(0) {}
336 void encode(bufferlist
&bl
) const {
337 ENCODE_START(1, 1, bl
);
340 ::encode(olh_tag
, bl
);
343 void decode(bufferlist::iterator
&bl
) {
347 ::decode(olh_tag
, bl
);
350 static void generate_test_instances(list
<rgw_cls_trim_olh_log_op
*>& o
);
351 void dump(Formatter
*f
) const;
353 WRITE_CLASS_ENCODER(rgw_cls_trim_olh_log_op
)
355 struct rgw_cls_bucket_clear_olh_op
{
359 rgw_cls_bucket_clear_olh_op() {}
361 void encode(bufferlist
& bl
) const {
362 ENCODE_START(1, 1, bl
);
364 ::encode(olh_tag
, bl
);
368 void decode(bufferlist::iterator
& bl
) {
371 ::decode(olh_tag
, bl
);
375 static void generate_test_instances(list
<rgw_cls_bucket_clear_olh_op
*>& o
);
376 void dump(Formatter
*f
) const;
378 WRITE_CLASS_ENCODER(rgw_cls_bucket_clear_olh_op
)
380 struct rgw_cls_list_op
382 cls_rgw_obj_key start_obj
;
383 uint32_t num_entries
;
384 string filter_prefix
;
387 rgw_cls_list_op() : num_entries(0), list_versions(false) {}
389 void encode(bufferlist
&bl
) const {
390 ENCODE_START(5, 4, bl
);
391 ::encode(num_entries
, bl
);
392 ::encode(filter_prefix
, bl
);
393 ::encode(start_obj
, bl
);
394 ::encode(list_versions
, bl
);
397 void decode(bufferlist::iterator
&bl
) {
398 DECODE_START_LEGACY_COMPAT_LEN(5, 2, 2, bl
);
400 ::decode(start_obj
.name
, bl
);
402 ::decode(num_entries
, bl
);
404 ::decode(filter_prefix
, bl
);
406 ::decode(start_obj
, bl
);
408 ::decode(list_versions
, bl
);
411 void dump(Formatter
*f
) const;
412 static void generate_test_instances(list
<rgw_cls_list_op
*>& o
);
414 WRITE_CLASS_ENCODER(rgw_cls_list_op
)
416 struct rgw_cls_list_ret
{
420 rgw_cls_list_ret() : is_truncated(false) {}
422 void encode(bufferlist
&bl
) const {
423 ENCODE_START(2, 2, bl
);
425 ::encode(is_truncated
, bl
);
428 void decode(bufferlist::iterator
&bl
) {
429 DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl
);
431 ::decode(is_truncated
, bl
);
434 void dump(Formatter
*f
) const;
435 static void generate_test_instances(list
<rgw_cls_list_ret
*>& o
);
437 WRITE_CLASS_ENCODER(rgw_cls_list_ret
)
439 struct rgw_cls_check_index_ret
441 rgw_bucket_dir_header existing_header
;
442 rgw_bucket_dir_header calculated_header
;
444 rgw_cls_check_index_ret() {}
446 void encode(bufferlist
&bl
) const {
447 ENCODE_START(1, 1, bl
);
448 ::encode(existing_header
, bl
);
449 ::encode(calculated_header
, bl
);
452 void decode(bufferlist::iterator
&bl
) {
454 ::decode(existing_header
, bl
);
455 ::decode(calculated_header
, bl
);
458 void dump(Formatter
*f
) const;
459 static void generate_test_instances(list
<rgw_cls_check_index_ret
*>& o
);
461 WRITE_CLASS_ENCODER(rgw_cls_check_index_ret
)
463 struct rgw_cls_bucket_update_stats_op
465 bool absolute
{false};
466 map
<uint8_t, rgw_bucket_category_stats
> stats
;
468 rgw_cls_bucket_update_stats_op() {}
470 void encode(bufferlist
&bl
) const {
471 ENCODE_START(1, 1, bl
);
472 ::encode(absolute
, bl
);
476 void decode(bufferlist::iterator
&bl
) {
478 ::decode(absolute
, bl
);
482 void dump(Formatter
*f
) const;
483 static void generate_test_instances(list
<rgw_cls_bucket_update_stats_op
*>& o
);
485 WRITE_CLASS_ENCODER(rgw_cls_bucket_update_stats_op
)
487 struct rgw_cls_obj_remove_op
{
488 list
<string
> keep_attr_prefixes
;
490 void encode(bufferlist
& bl
) const {
491 ENCODE_START(1, 1, bl
);
492 ::encode(keep_attr_prefixes
, bl
);
496 void decode(bufferlist::iterator
& bl
) {
498 ::decode(keep_attr_prefixes
, bl
);
502 WRITE_CLASS_ENCODER(rgw_cls_obj_remove_op
)
504 struct rgw_cls_obj_store_pg_ver_op
{
507 void encode(bufferlist
& bl
) const {
508 ENCODE_START(1, 1, bl
);
513 void decode(bufferlist::iterator
& bl
) {
519 WRITE_CLASS_ENCODER(rgw_cls_obj_store_pg_ver_op
)
521 struct rgw_cls_obj_check_attrs_prefix
{
525 rgw_cls_obj_check_attrs_prefix() : fail_if_exist(false) {}
527 void encode(bufferlist
& bl
) const {
528 ENCODE_START(1, 1, bl
);
529 ::encode(check_prefix
, bl
);
530 ::encode(fail_if_exist
, bl
);
534 void decode(bufferlist::iterator
& bl
) {
536 ::decode(check_prefix
, bl
);
537 ::decode(fail_if_exist
, bl
);
541 WRITE_CLASS_ENCODER(rgw_cls_obj_check_attrs_prefix
)
543 struct rgw_cls_obj_check_mtime
{
544 ceph::real_time mtime
;
545 RGWCheckMTimeType type
;
546 bool high_precision_time
;
548 rgw_cls_obj_check_mtime() : type(CLS_RGW_CHECK_TIME_MTIME_EQ
), high_precision_time(false) {}
550 void encode(bufferlist
& bl
) const {
551 ENCODE_START(2, 1, bl
);
553 ::encode((uint8_t)type
, bl
);
554 ::encode(high_precision_time
, bl
);
558 void decode(bufferlist::iterator
& bl
) {
563 type
= (RGWCheckMTimeType
)c
;
565 ::decode(high_precision_time
, bl
);
570 WRITE_CLASS_ENCODER(rgw_cls_obj_check_mtime
)
572 struct rgw_cls_usage_log_add_op
{
573 rgw_usage_log_info info
;
576 void encode(bufferlist
& bl
) const {
577 ENCODE_START(2, 1, bl
);
579 ::encode(user
.to_str(), bl
);
583 void decode(bufferlist::iterator
& bl
) {
594 WRITE_CLASS_ENCODER(rgw_cls_usage_log_add_op
)
596 struct rgw_cls_bi_get_op
{
598 BIIndexType type
; /* namespace: plain, instance, olh */
600 rgw_cls_bi_get_op() : type(PlainIdx
) {}
602 void encode(bufferlist
& bl
) const {
603 ENCODE_START(1, 1, bl
);
605 ::encode((uint8_t)type
, bl
);
609 void decode(bufferlist::iterator
& bl
) {
614 type
= (BIIndexType
)c
;
618 WRITE_CLASS_ENCODER(rgw_cls_bi_get_op
)
620 struct rgw_cls_bi_get_ret
{
621 rgw_cls_bi_entry entry
;
623 rgw_cls_bi_get_ret() {}
625 void encode(bufferlist
& bl
) const {
626 ENCODE_START(1, 1, bl
);
631 void decode(bufferlist::iterator
& bl
) {
637 WRITE_CLASS_ENCODER(rgw_cls_bi_get_ret
)
639 struct rgw_cls_bi_put_op
{
640 rgw_cls_bi_entry entry
;
642 rgw_cls_bi_put_op() {}
644 void encode(bufferlist
& bl
) const {
645 ENCODE_START(1, 1, bl
);
650 void decode(bufferlist::iterator
& bl
) {
656 WRITE_CLASS_ENCODER(rgw_cls_bi_put_op
)
658 struct rgw_cls_bi_list_op
{
663 rgw_cls_bi_list_op() : max(0) {}
665 void encode(bufferlist
& bl
) const {
666 ENCODE_START(1, 1, bl
);
669 ::encode(marker
, bl
);
673 void decode(bufferlist::iterator
& bl
) {
677 ::decode(marker
, bl
);
681 WRITE_CLASS_ENCODER(rgw_cls_bi_list_op
)
683 struct rgw_cls_bi_list_ret
{
684 list
<rgw_cls_bi_entry
> entries
;
687 rgw_cls_bi_list_ret() : is_truncated(false) {}
689 void encode(bufferlist
& bl
) const {
690 ENCODE_START(1, 1, bl
);
691 ::encode(entries
, bl
);
692 ::encode(is_truncated
, bl
);
696 void decode(bufferlist::iterator
& bl
) {
698 ::decode(entries
, bl
);
699 ::decode(is_truncated
, bl
);
703 WRITE_CLASS_ENCODER(rgw_cls_bi_list_ret
)
705 struct rgw_cls_usage_log_read_op
{
706 uint64_t start_epoch
;
710 string iter
; // should be empty for the first call, non empty for subsequent calls
711 uint32_t max_entries
;
713 void encode(bufferlist
& bl
) const {
714 ENCODE_START(1, 1, bl
);
715 ::encode(start_epoch
, bl
);
716 ::encode(end_epoch
, bl
);
719 ::encode(max_entries
, bl
);
723 void decode(bufferlist::iterator
& bl
) {
725 ::decode(start_epoch
, bl
);
726 ::decode(end_epoch
, bl
);
729 ::decode(max_entries
, bl
);
733 WRITE_CLASS_ENCODER(rgw_cls_usage_log_read_op
)
735 struct rgw_cls_usage_log_read_ret
{
736 map
<rgw_user_bucket
, rgw_usage_log_entry
> usage
;
740 void encode(bufferlist
& bl
) const {
741 ENCODE_START(1, 1, bl
);
743 ::encode(truncated
, bl
);
744 ::encode(next_iter
, bl
);
748 void decode(bufferlist::iterator
& bl
) {
751 ::decode(truncated
, bl
);
752 ::decode(next_iter
, bl
);
756 WRITE_CLASS_ENCODER(rgw_cls_usage_log_read_ret
)
758 struct rgw_cls_usage_log_trim_op
{
759 uint64_t start_epoch
;
763 void encode(bufferlist
& bl
) const {
764 ENCODE_START(2, 2, bl
);
765 ::encode(start_epoch
, bl
);
766 ::encode(end_epoch
, bl
);
771 void decode(bufferlist::iterator
& bl
) {
773 ::decode(start_epoch
, bl
);
774 ::decode(end_epoch
, bl
);
779 WRITE_CLASS_ENCODER(rgw_cls_usage_log_trim_op
)
781 struct cls_rgw_gc_set_entry_op
{
782 uint32_t expiration_secs
;
783 cls_rgw_gc_obj_info info
;
784 cls_rgw_gc_set_entry_op() : expiration_secs(0) {}
786 void encode(bufferlist
& bl
) const {
787 ENCODE_START(1, 1, bl
);
788 ::encode(expiration_secs
, bl
);
793 void decode(bufferlist::iterator
& bl
) {
795 ::decode(expiration_secs
, bl
);
800 void dump(Formatter
*f
) const;
801 static void generate_test_instances(list
<cls_rgw_gc_set_entry_op
*>& ls
);
803 WRITE_CLASS_ENCODER(cls_rgw_gc_set_entry_op
)
805 struct cls_rgw_gc_defer_entry_op
{
806 uint32_t expiration_secs
;
808 cls_rgw_gc_defer_entry_op() : expiration_secs(0) {}
810 void encode(bufferlist
& bl
) const {
811 ENCODE_START(1, 1, bl
);
812 ::encode(expiration_secs
, bl
);
817 void decode(bufferlist::iterator
& bl
) {
819 ::decode(expiration_secs
, bl
);
824 void dump(Formatter
*f
) const;
825 static void generate_test_instances(list
<cls_rgw_gc_defer_entry_op
*>& ls
);
827 WRITE_CLASS_ENCODER(cls_rgw_gc_defer_entry_op
)
829 struct cls_rgw_gc_list_op
{
834 cls_rgw_gc_list_op() : max(0), expired_only(true) {}
836 void encode(bufferlist
& bl
) const {
837 ENCODE_START(2, 1, bl
);
838 ::encode(marker
, bl
);
840 ::encode(expired_only
, bl
);
844 void decode(bufferlist::iterator
& bl
) {
846 ::decode(marker
, bl
);
849 ::decode(expired_only
, bl
);
854 void dump(Formatter
*f
) const;
855 static void generate_test_instances(list
<cls_rgw_gc_list_op
*>& ls
);
857 WRITE_CLASS_ENCODER(cls_rgw_gc_list_op
)
859 struct cls_rgw_gc_list_ret
{
860 list
<cls_rgw_gc_obj_info
> entries
;
864 cls_rgw_gc_list_ret() : truncated(false) {}
866 void encode(bufferlist
& bl
) const {
867 ENCODE_START(2, 1, bl
);
868 ::encode(entries
, bl
);
869 ::encode(next_marker
, bl
);
870 ::encode(truncated
, bl
);
874 void decode(bufferlist::iterator
& bl
) {
876 ::decode(entries
, bl
);
878 ::decode(next_marker
, bl
);
879 ::decode(truncated
, bl
);
883 void dump(Formatter
*f
) const;
884 static void generate_test_instances(list
<cls_rgw_gc_list_ret
*>& ls
);
886 WRITE_CLASS_ENCODER(cls_rgw_gc_list_ret
)
888 struct cls_rgw_gc_remove_op
{
891 cls_rgw_gc_remove_op() {}
893 void encode(bufferlist
& bl
) const {
894 ENCODE_START(1, 1, bl
);
899 void decode(bufferlist::iterator
& bl
) {
905 void dump(Formatter
*f
) const;
906 static void generate_test_instances(list
<cls_rgw_gc_remove_op
*>& ls
);
908 WRITE_CLASS_ENCODER(cls_rgw_gc_remove_op
)
910 struct cls_rgw_bi_log_list_op
{
914 cls_rgw_bi_log_list_op() : max(0) {}
916 void encode(bufferlist
& bl
) const {
917 ENCODE_START(1, 1, bl
);
918 ::encode(marker
, bl
);
923 void decode(bufferlist::iterator
& bl
) {
925 ::decode(marker
, bl
);
930 void dump(Formatter
*f
) const;
931 static void generate_test_instances(list
<cls_rgw_bi_log_list_op
*>& ls
);
933 WRITE_CLASS_ENCODER(cls_rgw_bi_log_list_op
)
935 struct cls_rgw_bi_log_trim_op
{
939 cls_rgw_bi_log_trim_op() {}
941 void encode(bufferlist
& bl
) const {
942 ENCODE_START(1, 1, bl
);
943 ::encode(start_marker
, bl
);
944 ::encode(end_marker
, bl
);
948 void decode(bufferlist::iterator
& bl
) {
950 ::decode(start_marker
, bl
);
951 ::decode(end_marker
, bl
);
955 void dump(Formatter
*f
) const;
956 static void generate_test_instances(list
<cls_rgw_bi_log_trim_op
*>& ls
);
958 WRITE_CLASS_ENCODER(cls_rgw_bi_log_trim_op
)
960 struct cls_rgw_bi_log_list_ret
{
961 list
<rgw_bi_log_entry
> entries
;
964 cls_rgw_bi_log_list_ret() : truncated(false) {}
966 void encode(bufferlist
& bl
) const {
967 ENCODE_START(1, 1, bl
);
968 ::encode(entries
, bl
);
969 ::encode(truncated
, bl
);
973 void decode(bufferlist::iterator
& bl
) {
975 ::decode(entries
, bl
);
976 ::decode(truncated
, bl
);
980 void dump(Formatter
*f
) const;
981 static void generate_test_instances(list
<cls_rgw_bi_log_list_ret
*>& ls
);
983 WRITE_CLASS_ENCODER(cls_rgw_bi_log_list_ret
)
985 struct cls_rgw_lc_get_next_entry_op
{
987 cls_rgw_lc_get_next_entry_op() {}
989 void encode(bufferlist
& bl
) const {
990 ENCODE_START(1, 1, bl
);
991 ::encode(marker
, bl
);
995 void decode(bufferlist::iterator
& bl
) {
997 ::decode(marker
, bl
);
1001 WRITE_CLASS_ENCODER(cls_rgw_lc_get_next_entry_op
)
1003 struct cls_rgw_lc_get_next_entry_ret
{
1004 pair
<string
, int> entry
;
1006 cls_rgw_lc_get_next_entry_ret() {}
1008 void encode(bufferlist
& bl
) const {
1009 ENCODE_START(1, 1, bl
);
1010 ::encode(entry
, bl
);
1014 void decode(bufferlist::iterator
& bl
) {
1015 DECODE_START(1, bl
);
1016 ::decode(entry
, bl
);
1021 WRITE_CLASS_ENCODER(cls_rgw_lc_get_next_entry_ret
)
1023 struct cls_rgw_lc_rm_entry_op
{
1024 pair
<string
, int> entry
;
1025 cls_rgw_lc_rm_entry_op() {}
1027 void encode(bufferlist
& bl
) const {
1028 ENCODE_START(1, 1, bl
);
1029 ::encode(entry
, bl
);
1033 void decode(bufferlist::iterator
& bl
) {
1034 DECODE_START(1, bl
);
1035 ::decode(entry
, bl
);
1039 WRITE_CLASS_ENCODER(cls_rgw_lc_rm_entry_op
)
1041 struct cls_rgw_lc_set_entry_op
{
1042 pair
<string
, int> entry
;
1043 cls_rgw_lc_set_entry_op() {}
1045 void encode(bufferlist
& bl
) const {
1046 ENCODE_START(1, 1, bl
);
1047 ::encode(entry
, bl
);
1051 void decode(bufferlist::iterator
& bl
) {
1052 DECODE_START(1, bl
);
1053 ::decode(entry
, bl
);
1057 WRITE_CLASS_ENCODER(cls_rgw_lc_set_entry_op
)
1059 struct cls_rgw_lc_put_head_op
{
1060 cls_rgw_lc_obj_head head
;
1063 cls_rgw_lc_put_head_op() {}
1065 void encode(bufferlist
& bl
) const {
1066 ENCODE_START(1, 1, bl
);
1071 void decode(bufferlist::iterator
& bl
) {
1072 DECODE_START(1, bl
);
1078 WRITE_CLASS_ENCODER(cls_rgw_lc_put_head_op
)
1080 struct cls_rgw_lc_get_head_ret
{
1081 cls_rgw_lc_obj_head head
;
1083 cls_rgw_lc_get_head_ret() {}
1085 void encode(bufferlist
& bl
) const {
1086 ENCODE_START(1, 1, bl
);
1091 void decode(bufferlist::iterator
& bl
) {
1092 DECODE_START(1, bl
);
1098 WRITE_CLASS_ENCODER(cls_rgw_lc_get_head_ret
)
1100 struct cls_rgw_lc_list_entries_op
{
1102 uint32_t max_entries
;
1104 cls_rgw_lc_list_entries_op() {}
1106 void encode(bufferlist
& bl
) const {
1107 ENCODE_START(1, 1, bl
);
1108 ::encode(marker
, bl
);
1109 ::encode(max_entries
, bl
);
1113 void decode(bufferlist::iterator
& bl
) {
1114 DECODE_START(1, bl
);
1115 ::decode(marker
, bl
);
1116 ::decode(max_entries
, bl
);
1121 WRITE_CLASS_ENCODER(cls_rgw_lc_list_entries_op
)
1123 struct cls_rgw_lc_list_entries_ret
{
1124 map
<string
, int> entries
;
1125 bool is_truncated
{false};
1127 cls_rgw_lc_list_entries_ret() {}
1129 void encode(bufferlist
& bl
) const {
1130 ENCODE_START(2, 1, bl
);
1131 ::encode(entries
, bl
);
1132 ::encode(is_truncated
, bl
);
1136 void decode(bufferlist::iterator
& bl
) {
1137 DECODE_START(2, bl
);
1138 ::decode(entries
, bl
);
1139 if (struct_v
>= 2) {
1140 ::decode(is_truncated
, bl
);
1146 WRITE_CLASS_ENCODER(cls_rgw_lc_list_entries_ret
)
1148 struct cls_rgw_reshard_add_op
{
1149 cls_rgw_reshard_entry entry
;
1151 cls_rgw_reshard_add_op() {}
1153 void encode(bufferlist
& bl
) const {
1154 ENCODE_START(1, 1, bl
);
1155 ::encode(entry
, bl
);
1159 void decode(bufferlist::iterator
& bl
) {
1160 DECODE_START(1, bl
);
1161 ::decode(entry
, bl
);
1164 static void generate_test_instances(list
<cls_rgw_reshard_add_op
*>& o
);
1165 void dump(Formatter
*f
) const;
1167 WRITE_CLASS_ENCODER(cls_rgw_reshard_add_op
)
1169 struct cls_rgw_reshard_list_op
{
1173 cls_rgw_reshard_list_op() {}
1175 void encode(bufferlist
& bl
) const {
1176 ENCODE_START(1, 1, bl
);
1178 ::encode(marker
, bl
);
1182 void decode(bufferlist::iterator
& bl
) {
1183 DECODE_START(1, bl
);
1185 ::decode(marker
, bl
);
1188 static void generate_test_instances(list
<cls_rgw_reshard_list_op
*>& o
);
1189 void dump(Formatter
*f
) const;
1191 WRITE_CLASS_ENCODER(cls_rgw_reshard_list_op
)
1194 struct cls_rgw_reshard_list_ret
{
1195 list
<cls_rgw_reshard_entry
> entries
;
1196 bool is_truncated
{false};
1198 cls_rgw_reshard_list_ret() {}
1200 void encode(bufferlist
& bl
) const {
1201 ENCODE_START(1, 1, bl
);
1202 ::encode(entries
, bl
);
1203 ::encode(is_truncated
, bl
);
1207 void decode(bufferlist::iterator
& bl
) {
1208 DECODE_START(1, bl
);
1209 ::decode(entries
, bl
);
1210 ::decode(is_truncated
, bl
);
1213 static void generate_test_instances(list
<cls_rgw_reshard_list_ret
*>& o
);
1214 void dump(Formatter
*f
) const;
1216 WRITE_CLASS_ENCODER(cls_rgw_reshard_list_ret
)
1218 struct cls_rgw_reshard_get_op
{
1219 cls_rgw_reshard_entry entry
;
1221 cls_rgw_reshard_get_op() {}
1223 void encode(bufferlist
& bl
) const {
1224 ENCODE_START(1, 1, bl
);
1225 ::encode(entry
, bl
);
1229 void decode(bufferlist::iterator
& bl
) {
1230 DECODE_START(1, bl
);
1231 ::decode(entry
, bl
);
1234 static void generate_test_instances(list
<cls_rgw_reshard_get_op
*>& o
);
1235 void dump(Formatter
*f
) const;
1237 WRITE_CLASS_ENCODER(cls_rgw_reshard_get_op
)
1239 struct cls_rgw_reshard_get_ret
{
1240 cls_rgw_reshard_entry entry
;
1242 cls_rgw_reshard_get_ret() {}
1244 void encode(bufferlist
& bl
) const {
1245 ENCODE_START(1, 1, bl
);
1246 ::encode(entry
, bl
);
1250 void decode(bufferlist::iterator
& bl
) {
1251 DECODE_START(1, bl
);
1252 ::decode(entry
, bl
);
1255 static void generate_test_instances(list
<cls_rgw_reshard_get_ret
*>& o
);
1256 void dump(Formatter
*f
) const;
1258 WRITE_CLASS_ENCODER(cls_rgw_reshard_get_ret
)
1260 struct cls_rgw_reshard_remove_op
{
1265 cls_rgw_reshard_remove_op() {}
1267 void encode(bufferlist
& bl
) const {
1268 ENCODE_START(1, 1, bl
);
1269 ::encode(tenant
, bl
);
1270 ::encode(bucket_name
, bl
);
1271 ::encode(bucket_id
, bl
);
1275 void decode(bufferlist::iterator
& bl
) {
1276 DECODE_START(1, bl
);
1277 ::decode(tenant
, bl
);
1278 ::decode(bucket_name
, bl
);
1279 ::decode(bucket_id
, bl
);
1282 static void generate_test_instances(list
<cls_rgw_reshard_remove_op
*>& o
);
1283 void dump(Formatter
*f
) const;
1285 WRITE_CLASS_ENCODER(cls_rgw_reshard_remove_op
)
1287 struct cls_rgw_set_bucket_resharding_op
{
1288 cls_rgw_bucket_instance_entry entry
;
1290 void encode(bufferlist
& bl
) const {
1291 ENCODE_START(1, 1, bl
);
1292 ::encode(entry
, bl
);
1296 void decode(bufferlist::iterator
& bl
) {
1297 DECODE_START(1, bl
);
1298 ::decode(entry
, bl
);
1301 static void generate_test_instances(list
<cls_rgw_set_bucket_resharding_op
*>& o
);
1302 void dump(Formatter
*f
) const;
1304 WRITE_CLASS_ENCODER(cls_rgw_set_bucket_resharding_op
)
1306 struct cls_rgw_clear_bucket_resharding_op
{
1307 void encode(bufferlist
& bl
) const {
1308 ENCODE_START(1, 1, bl
);
1312 void decode(bufferlist::iterator
& bl
) {
1313 DECODE_START(1, bl
);
1316 static void generate_test_instances(list
<cls_rgw_clear_bucket_resharding_op
*>& o
);
1317 void dump(Formatter
*f
) const;
1319 WRITE_CLASS_ENCODER(cls_rgw_clear_bucket_resharding_op
)
1321 struct cls_rgw_guard_bucket_resharding_op
{
1324 void encode(bufferlist
& bl
) const {
1325 ENCODE_START(1, 1, bl
);
1326 ::encode(ret_err
, bl
);
1330 void decode(bufferlist::iterator
& bl
) {
1331 DECODE_START(1, bl
);
1332 ::decode(ret_err
, bl
);
1336 static void generate_test_instances(list
<cls_rgw_guard_bucket_resharding_op
*>& o
);
1337 void dump(Formatter
*f
) const;
1339 WRITE_CLASS_ENCODER(cls_rgw_guard_bucket_resharding_op
)
1341 struct cls_rgw_get_bucket_resharding_op
{
1343 void encode(bufferlist
& bl
) const {
1344 ENCODE_START(1, 1, bl
);
1348 void decode(bufferlist::iterator
& bl
) {
1349 DECODE_START(1, bl
);
1353 static void generate_test_instances(list
<cls_rgw_get_bucket_resharding_op
*>& o
);
1354 void dump(Formatter
*f
) const;
1356 WRITE_CLASS_ENCODER(cls_rgw_get_bucket_resharding_op
)
1358 struct cls_rgw_get_bucket_resharding_ret
{
1359 cls_rgw_bucket_instance_entry new_instance
;
1361 void encode(bufferlist
& bl
) const {
1362 ENCODE_START(1, 1, bl
);
1363 ::encode(new_instance
, bl
);
1367 void decode(bufferlist::iterator
& bl
) {
1368 DECODE_START(1, bl
);
1369 ::decode(new_instance
, bl
);
1373 static void generate_test_instances(list
<cls_rgw_get_bucket_resharding_ret
*>& o
);
1374 void dump(Formatter
*f
) const;
1376 WRITE_CLASS_ENCODER(cls_rgw_get_bucket_resharding_ret
)
1378 #endif /* CEPH_CLS_RGW_OPS_H */