risingwave_pb/
hummock.rs

1// This file is @generated by prost-build.
2#[derive(prost_helpers::AnyPB)]
3#[derive(Eq)]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct SstableInfo {
6    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockSstableObjectId")]
7    pub object_id: crate::id::HummockSstableObjectId,
8    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockSstableId")]
9    pub sst_id: crate::id::HummockSstableId,
10    #[prost(message, optional, tag = "3")]
11    pub key_range: ::core::option::Option<KeyRange>,
12    /// represents the physical object size, which is usually used in the builder.
13    #[prost(uint64, tag = "4")]
14    pub file_size: u64,
15    #[prost(uint32, repeated, tag = "5", wrapper = "crate::id::TableId")]
16    pub table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
17    #[prost(uint64, tag = "6")]
18    pub meta_offset: u64,
19    #[prost(uint64, tag = "7")]
20    pub stale_key_count: u64,
21    #[prost(uint64, tag = "8")]
22    pub total_key_count: u64,
23    #[prost(uint64, tag = "9")]
24    pub min_epoch: u64,
25    #[prost(uint64, tag = "10")]
26    pub max_epoch: u64,
27    #[prost(uint64, tag = "11")]
28    pub uncompressed_file_size: u64,
29    #[prost(uint64, tag = "12")]
30    pub range_tombstone_count: u64,
31    #[prost(enumeration = "BloomFilterType", tag = "13")]
32    pub bloom_filter_kind: i32,
33    /// In order to calculate more finely in the compaction strategy, we need to re-calculate the sst_size after split sst
34    /// `sst_size` represents the size of the sst instead of the object size(usually used in the meta).
35    #[prost(uint64, tag = "14")]
36    pub sst_size: u64,
37}
38#[derive(prost_helpers::AnyPB)]
39#[derive(Clone, PartialEq, ::prost::Message)]
40pub struct OverlappingLevel {
41    #[prost(message, repeated, tag = "1")]
42    pub sub_levels: ::prost::alloc::vec::Vec<Level>,
43    #[prost(uint64, tag = "2")]
44    pub total_file_size: u64,
45    #[prost(uint64, tag = "3")]
46    pub uncompressed_file_size: u64,
47}
48#[derive(prost_helpers::AnyPB)]
49#[derive(Clone, PartialEq, ::prost::Message)]
50pub struct Level {
51    #[prost(uint32, tag = "1")]
52    pub level_idx: u32,
53    #[prost(enumeration = "LevelType", tag = "2")]
54    pub level_type: i32,
55    #[prost(message, repeated, tag = "3")]
56    pub table_infos: ::prost::alloc::vec::Vec<SstableInfo>,
57    #[prost(uint64, tag = "4")]
58    pub total_file_size: u64,
59    #[prost(uint64, tag = "5")]
60    pub sub_level_id: u64,
61    #[prost(uint64, tag = "6")]
62    pub uncompressed_file_size: u64,
63    #[prost(uint32, tag = "7")]
64    pub vnode_partition_count: u32,
65}
66#[derive(prost_helpers::AnyPB)]
67#[derive(Eq)]
68#[derive(Clone, PartialEq, ::prost::Message)]
69pub struct InputLevel {
70    #[prost(uint32, tag = "1")]
71    pub level_idx: u32,
72    #[prost(enumeration = "LevelType", tag = "2")]
73    pub level_type: i32,
74    #[prost(message, repeated, tag = "3")]
75    pub table_infos: ::prost::alloc::vec::Vec<SstableInfo>,
76}
77#[derive(prost_helpers::AnyPB)]
78#[derive(Eq)]
79#[derive(Clone, PartialEq, ::prost::Message)]
80pub struct NewL0SubLevel {
81    #[prost(message, repeated, tag = "1")]
82    pub inserted_table_infos: ::prost::alloc::vec::Vec<SstableInfo>,
83}
84#[derive(prost_helpers::AnyPB)]
85#[derive(Eq)]
86#[derive(Clone, PartialEq, ::prost::Message)]
87pub struct IntraLevelDelta {
88    #[prost(uint32, tag = "1")]
89    pub level_idx: u32,
90    #[prost(uint64, tag = "2")]
91    pub l0_sub_level_id: u64,
92    #[prost(uint64, repeated, tag = "3", wrapper = "crate::id::HummockSstableId")]
93    pub removed_table_ids: ::prost::alloc::vec::Vec<crate::id::HummockSstableId>,
94    #[prost(message, repeated, tag = "4")]
95    pub inserted_table_infos: ::prost::alloc::vec::Vec<SstableInfo>,
96    #[prost(uint32, tag = "5")]
97    pub vnode_partition_count: u32,
98    #[prost(uint64, tag = "6")]
99    pub compaction_group_version_id: u64,
100}
101#[derive(prost_helpers::AnyPB)]
102#[derive(Eq)]
103#[derive(Clone, PartialEq, ::prost::Message)]
104pub struct GroupConstruct {
105    #[prost(message, optional, tag = "1")]
106    pub group_config: ::core::option::Option<CompactionConfig>,
107    /// If parent_group_id is not 0, it means parent_group_id splits into parent_group_id and this group, so this group is not empty initially.
108    #[prost(uint64, tag = "2", wrapper = "crate::id::CompactionGroupId")]
109    pub parent_group_id: crate::id::CompactionGroupId,
110    #[deprecated]
111    #[prost(uint32, repeated, packed = "false", tag = "3")]
112    pub table_ids: ::prost::alloc::vec::Vec<u32>,
113    #[prost(uint64, tag = "4", wrapper = "crate::id::CompactionGroupId")]
114    pub group_id: crate::id::CompactionGroupId,
115    #[prost(uint64, tag = "5", wrapper = "crate::id::HummockSstableId")]
116    pub new_sst_start_id: crate::id::HummockSstableId,
117    #[prost(enumeration = "CompatibilityVersion", tag = "6")]
118    pub version: i32,
119    /// The split_key is the key that the group is split by.
120    /// When GroupConstruct with commit_epoch, split_key will be empty
121    /// When split_key is not None, GroupConstruct tells to use split_key to check each level and split the sstable_info in the level into two groups (bounded by split_key).
122    /// For the left sstable_info, split_key (right_exclusive=true) will be used as key_range_right.
123    /// In the current implementation split_key always contains a table_id, vnode = 0, epoch = MAX
124    #[prost(bytes = "vec", optional, tag = "7")]
125    pub split_key: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
126}
127#[derive(prost_helpers::AnyPB)]
128#[derive(Eq)]
129#[derive(Clone, Copy, PartialEq, ::prost::Message)]
130pub struct GroupDestroy {}
131#[derive(prost_helpers::AnyPB)]
132#[derive(Eq)]
133#[derive(Clone, Copy, PartialEq, ::prost::Message)]
134pub struct GroupMerge {
135    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
136    pub left_group_id: crate::id::CompactionGroupId,
137    #[prost(uint64, tag = "2", wrapper = "crate::id::CompactionGroupId")]
138    pub right_group_id: crate::id::CompactionGroupId,
139}
140/// TruncateTables is used to truncate multiple tables from sstables.
141#[derive(prost_helpers::AnyPB)]
142#[derive(Eq)]
143#[derive(Clone, PartialEq, ::prost::Message)]
144pub struct TruncateTables {
145    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::TableId")]
146    pub table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
147}
148#[derive(prost_helpers::AnyPB)]
149#[derive(Eq)]
150#[derive(Clone, PartialEq, ::prost::Message)]
151pub struct GroupDelta {
152    #[prost(oneof = "group_delta::DeltaType", tags = "1, 2, 3, 6, 7, 8")]
153    pub delta_type: ::core::option::Option<group_delta::DeltaType>,
154}
155/// Nested message and enum types in `GroupDelta`.
156pub mod group_delta {
157    #[derive(prost_helpers::AnyPB)]
158    #[derive(Eq)]
159    #[derive(Clone, PartialEq, ::prost::Oneof)]
160    pub enum DeltaType {
161        #[prost(message, tag = "1")]
162        IntraLevel(super::IntraLevelDelta),
163        #[prost(message, tag = "2")]
164        GroupConstruct(super::GroupConstruct),
165        #[prost(message, tag = "3")]
166        GroupDestroy(super::GroupDestroy),
167        #[prost(message, tag = "6")]
168        GroupMerge(super::GroupMerge),
169        #[prost(message, tag = "7")]
170        NewL0SubLevel(super::NewL0SubLevel),
171        #[prost(message, tag = "8")]
172        TruncateTables(super::TruncateTables),
173    }
174}
175#[derive(prost_helpers::AnyPB)]
176#[derive(Eq)]
177#[derive(Clone, PartialEq, ::prost::Message)]
178pub struct VnodeWatermark {
179    /// The watermark shared by multiple vnodes
180    #[prost(bytes = "vec", tag = "1")]
181    pub watermark: ::prost::alloc::vec::Vec<u8>,
182    /// The set of vnodes that share the same watermark
183    #[prost(message, optional, tag = "2")]
184    pub vnode_bitmap: ::core::option::Option<super::common::Buffer>,
185}
186/// Table watermark is a lighter weight range delete introduced in
187/// <https://github.com/risingwavelabs/risingwave/issues/13148>
188/// It means the lowest (or highest when `is_ascending` is false) visible
189/// keys in the table within a vnode. Keys lower (or higher) than the
190/// table watermark is invisible and will be cleaned in later compaction.
191#[derive(prost_helpers::AnyPB)]
192#[derive(Eq)]
193#[derive(Clone, PartialEq, ::prost::Message)]
194pub struct TableWatermarks {
195    /// Table watermarks of a state table from all vnodes written in multiple epochs.
196    /// Epochs should be sorted in ascending order, which means earlier epoch at the front
197    #[prost(message, repeated, tag = "1")]
198    pub epoch_watermarks: ::prost::alloc::vec::Vec<table_watermarks::EpochNewWatermarks>,
199    /// The direction of the table watermark.
200    #[prost(bool, tag = "2")]
201    pub is_ascending: bool,
202    /// The table watermark is non-pk prefix table watermark.
203    /// Deprecated. use WatermarkSerdeType instead;
204    #[deprecated]
205    #[prost(bool, tag = "3")]
206    pub is_non_pk_prefix: bool,
207    #[prost(enumeration = "WatermarkSerdeType", tag = "4")]
208    pub raw_watermark_serde_type: i32,
209}
210/// Nested message and enum types in `TableWatermarks`.
211pub mod table_watermarks {
212    #[derive(prost_helpers::AnyPB)]
213    #[derive(Eq)]
214    #[derive(Clone, PartialEq, ::prost::Message)]
215    pub struct EpochNewWatermarks {
216        #[prost(message, repeated, tag = "1")]
217        pub watermarks: ::prost::alloc::vec::Vec<super::VnodeWatermark>,
218        #[prost(uint64, tag = "2")]
219        pub epoch: u64,
220    }
221}
222#[derive(prost_helpers::AnyPB)]
223#[derive(Clone, PartialEq, ::prost::Message)]
224pub struct EpochNewChangeLog {
225    #[prost(message, repeated, tag = "1")]
226    pub old_value: ::prost::alloc::vec::Vec<SstableInfo>,
227    #[prost(message, repeated, tag = "2")]
228    pub new_value: ::prost::alloc::vec::Vec<SstableInfo>,
229    /// Epochs should be sorted in ascending order, which means earlier epoch at the front
230    #[prost(uint64, repeated, tag = "3")]
231    pub epochs: ::prost::alloc::vec::Vec<u64>,
232}
233#[derive(prost_helpers::AnyPB)]
234#[derive(Clone, PartialEq, ::prost::Message)]
235pub struct TableChangeLog {
236    /// Epochs should be sorted in ascending order, which means earlier epoch at the front.
237    #[prost(message, repeated, tag = "1")]
238    pub change_logs: ::prost::alloc::vec::Vec<EpochNewChangeLog>,
239}
240#[derive(prost_helpers::AnyPB)]
241#[derive(Clone, Copy, PartialEq, ::prost::Message)]
242pub struct StateTableInfo {
243    #[prost(uint64, tag = "1")]
244    pub committed_epoch: u64,
245    #[prost(uint64, tag = "3", wrapper = "crate::id::CompactionGroupId")]
246    pub compaction_group_id: crate::id::CompactionGroupId,
247}
248#[derive(prost_helpers::AnyPB)]
249#[derive(Clone, Copy, PartialEq, ::prost::Message)]
250pub struct StateTableInfoDelta {
251    #[prost(uint64, tag = "1")]
252    pub committed_epoch: u64,
253    #[prost(uint64, tag = "3", wrapper = "crate::id::CompactionGroupId")]
254    pub compaction_group_id: crate::id::CompactionGroupId,
255}
256#[derive(prost_helpers::AnyPB)]
257#[derive(Clone, Copy, PartialEq, ::prost::Message)]
258pub struct VectorIndexObject {
259    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockRawObjectId")]
260    pub id: crate::id::HummockRawObjectId,
261    #[prost(enumeration = "VectorIndexObjectType", tag = "2")]
262    pub object_type: i32,
263}
264#[derive(prost_helpers::AnyPB)]
265#[derive(Clone, Copy, PartialEq, ::prost::Message)]
266pub struct VectorFileInfo {
267    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockVectorFileId")]
268    pub object_id: crate::id::HummockVectorFileId,
269    #[prost(uint64, tag = "2")]
270    pub file_size: u64,
271    #[prost(uint64, tag = "3")]
272    pub start_vector_id: u64,
273    #[prost(uint32, tag = "4")]
274    pub vector_count: u32,
275    #[prost(uint64, tag = "5")]
276    pub meta_offset: u64,
277}
278#[derive(prost_helpers::AnyPB)]
279#[derive(Clone, PartialEq, ::prost::Message)]
280pub struct FlatIndex {
281    #[prost(message, optional, tag = "1")]
282    pub config: ::core::option::Option<super::catalog::FlatIndexConfig>,
283    #[prost(message, repeated, tag = "2")]
284    pub vector_files: ::prost::alloc::vec::Vec<VectorFileInfo>,
285    #[prost(uint64, tag = "3")]
286    pub next_vector_id: u64,
287}
288#[derive(prost_helpers::AnyPB)]
289#[derive(Clone, PartialEq, ::prost::Message)]
290pub struct FlatIndexAdd {
291    #[prost(message, repeated, tag = "1")]
292    pub added_vector_files: ::prost::alloc::vec::Vec<VectorFileInfo>,
293    #[prost(uint64, tag = "2")]
294    pub next_vector_id: u64,
295}
296#[derive(prost_helpers::AnyPB)]
297#[derive(Clone, PartialEq, ::prost::Message)]
298pub struct HnswGraph {
299    #[prost(message, repeated, tag = "1")]
300    pub nodes: ::prost::alloc::vec::Vec<hnsw_graph::HnswNode>,
301    #[prost(uint64, tag = "2")]
302    pub entrypoint_id: u64,
303}
304/// Nested message and enum types in `HnswGraph`.
305pub mod hnsw_graph {
306    #[derive(prost_helpers::AnyPB)]
307    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
308    pub struct HnswNeighbor {
309        #[prost(uint64, tag = "1")]
310        pub vector_id: u64,
311        #[prost(double, tag = "2")]
312        pub distance: f64,
313    }
314    #[derive(prost_helpers::AnyPB)]
315    #[derive(Clone, PartialEq, ::prost::Message)]
316    pub struct HnswLevel {
317        #[prost(message, repeated, tag = "1")]
318        pub neighbors: ::prost::alloc::vec::Vec<HnswNeighbor>,
319    }
320    #[derive(prost_helpers::AnyPB)]
321    #[derive(Clone, PartialEq, ::prost::Message)]
322    pub struct HnswNode {
323        #[prost(message, repeated, tag = "1")]
324        pub levels: ::prost::alloc::vec::Vec<HnswLevel>,
325    }
326}
327#[derive(prost_helpers::AnyPB)]
328#[derive(Clone, Copy, PartialEq, ::prost::Message)]
329pub struct HnswGraphFileInfo {
330    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockHnswGraphFileId")]
331    pub object_id: crate::id::HummockHnswGraphFileId,
332    #[prost(uint64, tag = "2")]
333    pub file_size: u64,
334}
335#[derive(prost_helpers::AnyPB)]
336#[derive(Clone, PartialEq, ::prost::Message)]
337pub struct HnswFlatIndex {
338    #[prost(message, optional, tag = "1")]
339    pub config: ::core::option::Option<super::catalog::HnswFlatIndexConfig>,
340    #[prost(message, repeated, tag = "2")]
341    pub vector_files: ::prost::alloc::vec::Vec<VectorFileInfo>,
342    #[prost(uint64, tag = "3")]
343    pub next_vector_id: u64,
344    #[prost(message, optional, tag = "4")]
345    pub graph_file: ::core::option::Option<HnswGraphFileInfo>,
346}
347#[derive(prost_helpers::AnyPB)]
348#[derive(Clone, PartialEq, ::prost::Message)]
349pub struct HnswFlatIndexAdd {
350    #[prost(message, repeated, tag = "1")]
351    pub added_vector_files: ::prost::alloc::vec::Vec<VectorFileInfo>,
352    #[prost(uint64, tag = "2")]
353    pub next_vector_id: u64,
354    #[prost(message, optional, tag = "3")]
355    pub graph_file: ::core::option::Option<HnswGraphFileInfo>,
356}
357#[derive(prost_helpers::AnyPB)]
358#[derive(Clone, PartialEq, ::prost::Message)]
359pub struct VectorIndex {
360    #[prost(uint32, tag = "1")]
361    pub dimension: u32,
362    #[prost(enumeration = "super::common::DistanceType", tag = "2")]
363    pub distance_type: i32,
364    #[prost(oneof = "vector_index::Variant", tags = "65, 66")]
365    pub variant: ::core::option::Option<vector_index::Variant>,
366}
367/// Nested message and enum types in `VectorIndex`.
368pub mod vector_index {
369    #[derive(prost_helpers::AnyPB)]
370    #[derive(Clone, PartialEq, ::prost::Oneof)]
371    pub enum Variant {
372        /// reserve 64 general configs
373        #[prost(message, tag = "65")]
374        Flat(super::FlatIndex),
375        #[prost(message, tag = "66")]
376        HnswFlat(super::HnswFlatIndex),
377    }
378}
379#[derive(prost_helpers::AnyPB)]
380#[derive(Clone, PartialEq, ::prost::Message)]
381pub struct VectorIndexDelta {
382    #[prost(oneof = "vector_index_delta::Delta", tags = "1, 2")]
383    pub delta: ::core::option::Option<vector_index_delta::Delta>,
384}
385/// Nested message and enum types in `VectorIndexDelta`.
386pub mod vector_index_delta {
387    #[derive(prost_helpers::AnyPB)]
388    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
389    pub struct VectorIndexInit {
390        #[prost(message, optional, tag = "1")]
391        pub info: ::core::option::Option<super::super::catalog::VectorIndexInfo>,
392    }
393    #[derive(prost_helpers::AnyPB)]
394    #[derive(Clone, PartialEq, ::prost::Message)]
395    pub struct VectorIndexAdd {
396        #[prost(oneof = "vector_index_add::Add", tags = "65, 66")]
397        pub add: ::core::option::Option<vector_index_add::Add>,
398    }
399    /// Nested message and enum types in `VectorIndexAdd`.
400    pub mod vector_index_add {
401        #[derive(prost_helpers::AnyPB)]
402        #[derive(Clone, PartialEq, ::prost::Oneof)]
403        pub enum Add {
404            /// reserve 64 general configs
405            #[prost(message, tag = "65")]
406            Flat(super::super::FlatIndexAdd),
407            #[prost(message, tag = "66")]
408            HnswFlat(super::super::HnswFlatIndexAdd),
409        }
410    }
411    #[derive(prost_helpers::AnyPB)]
412    #[derive(Clone, PartialEq, ::prost::Message)]
413    pub struct VectorIndexAdds {
414        #[prost(message, repeated, tag = "1")]
415        pub adds: ::prost::alloc::vec::Vec<VectorIndexAdd>,
416    }
417    #[derive(prost_helpers::AnyPB)]
418    #[derive(Clone, PartialEq, ::prost::Oneof)]
419    pub enum Delta {
420        #[prost(message, tag = "1")]
421        Init(VectorIndexInit),
422        #[prost(message, tag = "2")]
423        Adds(VectorIndexAdds),
424    }
425}
426#[derive(prost_helpers::AnyPB)]
427#[derive(Clone, PartialEq, ::prost::Message)]
428pub struct HummockVersion {
429    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockVersionId")]
430    pub id: crate::id::HummockVersionId,
431    /// Levels of each compaction group
432    #[prost(
433        map = "uint64, message",
434        tag = "2",
435        wrapper = "crate::id::CompactionGroupId"
436    )]
437    pub levels: ::std::collections::HashMap<
438        crate::id::CompactionGroupId,
439        hummock_version::Levels,
440    >,
441    #[deprecated]
442    #[prost(uint64, tag = "3")]
443    pub max_committed_epoch: u64,
444    #[prost(map = "uint32, message", tag = "5", wrapper = "crate::id::TableId")]
445    pub table_watermarks: ::std::collections::HashMap<
446        crate::id::TableId,
447        TableWatermarks,
448    >,
449    #[prost(map = "uint32, message", tag = "6", wrapper = "crate::id::TableId")]
450    pub table_change_logs: ::std::collections::HashMap<
451        crate::id::TableId,
452        TableChangeLog,
453    >,
454    #[prost(map = "uint32, message", tag = "7", wrapper = "crate::id::TableId")]
455    pub state_table_info: ::std::collections::HashMap<
456        crate::id::TableId,
457        StateTableInfo,
458    >,
459    #[prost(map = "uint32, message", tag = "8", wrapper = "crate::id::TableId")]
460    pub vector_indexes: ::std::collections::HashMap<crate::id::TableId, VectorIndex>,
461}
462/// Nested message and enum types in `HummockVersion`.
463pub mod hummock_version {
464    #[derive(prost_helpers::AnyPB)]
465    #[derive(Clone, PartialEq, ::prost::Message)]
466    pub struct Levels {
467        #[prost(message, repeated, tag = "1")]
468        pub levels: ::prost::alloc::vec::Vec<super::Level>,
469        #[prost(message, optional, tag = "2")]
470        pub l0: ::core::option::Option<super::OverlappingLevel>,
471        #[prost(uint64, tag = "3", wrapper = "crate::id::CompactionGroupId")]
472        pub group_id: crate::id::CompactionGroupId,
473        #[prost(uint64, tag = "4", wrapper = "crate::id::CompactionGroupId")]
474        pub parent_group_id: crate::id::CompactionGroupId,
475        #[deprecated]
476        #[prost(uint32, repeated, packed = "false", tag = "5")]
477        pub member_table_ids: ::prost::alloc::vec::Vec<u32>,
478        #[prost(uint64, tag = "6")]
479        pub compaction_group_version_id: u64,
480    }
481}
482#[derive(prost_helpers::AnyPB)]
483#[derive(Clone, PartialEq, ::prost::Message)]
484pub struct HummockVersionDelta {
485    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockVersionId")]
486    pub id: crate::id::HummockVersionId,
487    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockVersionId")]
488    pub prev_id: crate::id::HummockVersionId,
489    /// Levels of each compaction group
490    #[prost(
491        map = "uint64, message",
492        tag = "3",
493        wrapper = "crate::id::CompactionGroupId"
494    )]
495    pub group_deltas: ::std::collections::HashMap<
496        crate::id::CompactionGroupId,
497        hummock_version_delta::GroupDeltas,
498    >,
499    #[deprecated]
500    #[prost(uint64, tag = "4")]
501    pub max_committed_epoch: u64,
502    #[prost(bool, tag = "6")]
503    pub trivial_move: bool,
504    #[prost(map = "uint32, message", tag = "8", wrapper = "crate::id::TableId")]
505    pub new_table_watermarks: ::std::collections::HashMap<
506        crate::id::TableId,
507        TableWatermarks,
508    >,
509    #[prost(uint32, repeated, tag = "9", wrapper = "crate::id::TableId")]
510    pub removed_table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
511    #[prost(map = "uint32, message", tag = "10", wrapper = "crate::id::TableId")]
512    pub change_log_delta: ::std::collections::HashMap<
513        crate::id::TableId,
514        hummock_version_delta::ChangeLogDelta,
515    >,
516    #[prost(map = "uint32, message", tag = "11", wrapper = "crate::id::TableId")]
517    pub state_table_info_delta: ::std::collections::HashMap<
518        crate::id::TableId,
519        StateTableInfoDelta,
520    >,
521    #[prost(map = "uint32, message", tag = "12", wrapper = "crate::id::TableId")]
522    pub vector_index_delta: ::std::collections::HashMap<
523        crate::id::TableId,
524        VectorIndexDelta,
525    >,
526}
527/// Nested message and enum types in `HummockVersionDelta`.
528pub mod hummock_version_delta {
529    #[derive(prost_helpers::AnyPB)]
530    #[derive(Clone, PartialEq, ::prost::Message)]
531    pub struct GroupDeltas {
532        #[prost(message, repeated, tag = "1")]
533        pub group_deltas: ::prost::alloc::vec::Vec<super::GroupDelta>,
534    }
535    #[derive(prost_helpers::AnyPB)]
536    #[derive(Clone, PartialEq, ::prost::Message)]
537    pub struct ChangeLogDelta {
538        #[prost(message, optional, tag = "1")]
539        pub new_log: ::core::option::Option<super::EpochNewChangeLog>,
540        /// only logs in epoch later than truncate_epoch will be preserved
541        #[prost(uint64, tag = "2")]
542        pub truncate_epoch: u64,
543    }
544}
545#[derive(prost_helpers::AnyPB)]
546#[derive(Clone, PartialEq, ::prost::Message)]
547pub struct HummockVersionDeltas {
548    #[prost(message, repeated, tag = "1")]
549    pub version_deltas: ::prost::alloc::vec::Vec<HummockVersionDelta>,
550}
551#[derive(prost_helpers::AnyPB)]
552#[derive(Clone, PartialEq, ::prost::Message)]
553pub struct HummockVersionCheckpoint {
554    #[prost(message, optional, tag = "1")]
555    pub version: ::core::option::Option<HummockVersion>,
556    #[prost(map = "uint64, message", tag = "2", wrapper = "crate::id::HummockVersionId")]
557    pub stale_objects: ::std::collections::HashMap<
558        crate::id::HummockVersionId,
559        hummock_version_checkpoint::StaleObjects,
560    >,
561}
562/// Nested message and enum types in `HummockVersionCheckpoint`.
563pub mod hummock_version_checkpoint {
564    #[derive(prost_helpers::AnyPB)]
565    #[derive(Clone, PartialEq, ::prost::Message)]
566    pub struct StaleObjects {
567        #[prost(
568            uint64,
569            repeated,
570            tag = "1",
571            wrapper = "crate::id::HummockSstableObjectId"
572        )]
573        pub id: ::prost::alloc::vec::Vec<crate::id::HummockSstableObjectId>,
574        #[prost(uint64, tag = "2")]
575        pub total_file_size: u64,
576        #[prost(message, repeated, tag = "3")]
577        pub vector_files: ::prost::alloc::vec::Vec<super::VectorIndexObject>,
578    }
579}
580#[derive(prost_helpers::AnyPB)]
581#[derive(Clone, PartialEq, ::prost::Message)]
582pub struct HummockVersionArchive {
583    #[prost(message, optional, tag = "1")]
584    pub version: ::core::option::Option<HummockVersion>,
585    /// some version_deltas since version
586    #[prost(message, repeated, tag = "2")]
587    pub version_deltas: ::prost::alloc::vec::Vec<HummockVersionDelta>,
588}
589#[derive(prost_helpers::AnyPB)]
590#[derive(Clone, PartialEq, ::prost::Message)]
591pub struct VersionUpdatePayload {
592    #[prost(oneof = "version_update_payload::Payload", tags = "1, 2")]
593    pub payload: ::core::option::Option<version_update_payload::Payload>,
594}
595/// Nested message and enum types in `VersionUpdatePayload`.
596pub mod version_update_payload {
597    #[derive(prost_helpers::AnyPB)]
598    #[derive(Clone, PartialEq, ::prost::Oneof)]
599    pub enum Payload {
600        #[prost(message, tag = "1")]
601        VersionDeltas(super::HummockVersionDeltas),
602        #[prost(message, tag = "2")]
603        PinnedVersion(super::HummockVersion),
604    }
605}
606#[derive(prost_helpers::AnyPB)]
607#[derive(Clone, Copy, PartialEq, ::prost::Message)]
608pub struct UnpinVersionBeforeRequest {
609    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
610    pub context_id: crate::id::WorkerId,
611    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockVersionId")]
612    pub unpin_version_before: crate::id::HummockVersionId,
613}
614#[derive(prost_helpers::AnyPB)]
615#[derive(Clone, PartialEq, ::prost::Message)]
616pub struct UnpinVersionBeforeResponse {
617    #[prost(message, optional, tag = "1")]
618    pub status: ::core::option::Option<super::common::Status>,
619}
620#[derive(prost_helpers::AnyPB)]
621#[derive(Clone, Copy, PartialEq, ::prost::Message)]
622pub struct GetCurrentVersionRequest {}
623#[derive(prost_helpers::AnyPB)]
624#[derive(Clone, PartialEq, ::prost::Message)]
625pub struct GetCurrentVersionResponse {
626    #[prost(message, optional, tag = "1")]
627    pub status: ::core::option::Option<super::common::Status>,
628    #[prost(message, optional, tag = "2")]
629    pub current_version: ::core::option::Option<HummockVersion>,
630}
631#[derive(prost_helpers::AnyPB)]
632#[derive(Clone, Copy, PartialEq, ::prost::Message)]
633pub struct UnpinVersionRequest {
634    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
635    pub context_id: crate::id::WorkerId,
636}
637#[derive(prost_helpers::AnyPB)]
638#[derive(Clone, PartialEq, ::prost::Message)]
639pub struct UnpinVersionResponse {
640    #[prost(message, optional, tag = "1")]
641    pub status: ::core::option::Option<super::common::Status>,
642}
643#[derive(prost_helpers::AnyPB)]
644#[derive(Clone, Copy, PartialEq, ::prost::Message)]
645pub struct GetAssignedCompactTaskNumRequest {}
646#[derive(prost_helpers::AnyPB)]
647#[derive(Clone, Copy, PartialEq, ::prost::Message)]
648pub struct GetAssignedCompactTaskNumResponse {
649    #[prost(uint32, tag = "1")]
650    pub num_tasks: u32,
651}
652/// When right_exclusive=false, it represents \[left, right\], of which both boundary are open. When right_exclusive=true,
653/// it represents [left, right), of which right is exclusive.
654#[derive(prost_helpers::AnyPB)]
655#[derive(Eq)]
656#[derive(Clone, PartialEq, ::prost::Message)]
657pub struct KeyRange {
658    #[prost(bytes = "vec", tag = "1")]
659    pub left: ::prost::alloc::vec::Vec<u8>,
660    #[prost(bytes = "vec", tag = "2")]
661    pub right: ::prost::alloc::vec::Vec<u8>,
662    #[prost(bool, tag = "3")]
663    pub right_exclusive: bool,
664}
665#[derive(prost_helpers::AnyPB)]
666#[derive(Eq)]
667#[derive(Clone, Copy, PartialEq, ::prost::Message)]
668pub struct TableOption {
669    #[prost(uint32, optional, tag = "2")]
670    pub retention_seconds: ::core::option::Option<u32>,
671}
672#[derive(prost_helpers::AnyPB)]
673#[derive(Eq)]
674#[derive(Clone, PartialEq, ::prost::Message)]
675pub struct TableSchema {
676    #[prost(int32, repeated, tag = "1")]
677    pub column_ids: ::prost::alloc::vec::Vec<i32>,
678}
679#[derive(prost_helpers::AnyPB)]
680#[derive(Eq)]
681#[derive(Clone, PartialEq, ::prost::Message)]
682pub struct CompactTask {
683    /// SSTs to be compacted, which will be removed from LSM after compaction
684    #[prost(message, repeated, tag = "1")]
685    pub input_ssts: ::prost::alloc::vec::Vec<InputLevel>,
686    /// In ideal case, the compaction will generate splits.len() tables which have key range
687    /// corresponding to that in \[splits\], respectively
688    #[prost(message, repeated, tag = "2")]
689    pub splits: ::prost::alloc::vec::Vec<KeyRange>,
690    /// compaction output, which will be added to \[target_level\] of LSM after compaction
691    #[prost(message, repeated, tag = "4")]
692    pub sorted_output_ssts: ::prost::alloc::vec::Vec<SstableInfo>,
693    /// task id assigned by hummock storage service
694    #[prost(uint64, tag = "5")]
695    pub task_id: u64,
696    /// compaction output will be added to \[target_level\] of LSM after compaction
697    #[prost(uint32, tag = "6")]
698    pub target_level: u32,
699    #[prost(bool, tag = "7")]
700    pub gc_delete_keys: bool,
701    /// Lbase in LSM
702    #[prost(uint32, tag = "8")]
703    pub base_level: u32,
704    #[prost(enumeration = "compact_task::TaskStatus", tag = "9")]
705    pub task_status: i32,
706    /// compaction group the task belongs to
707    #[prost(uint64, tag = "12", wrapper = "crate::id::CompactionGroupId")]
708    pub compaction_group_id: crate::id::CompactionGroupId,
709    /// existing_table_ids for compaction drop key
710    #[prost(uint32, repeated, tag = "13", wrapper = "crate::id::TableId")]
711    pub existing_table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
712    #[prost(uint32, tag = "14")]
713    pub compression_algorithm: u32,
714    #[prost(uint64, tag = "15")]
715    pub target_file_size: u64,
716    #[prost(uint32, tag = "16")]
717    pub compaction_filter_mask: u32,
718    #[prost(btree_map = "uint32, message", tag = "17", wrapper = "crate::id::TableId")]
719    pub table_options: ::prost::alloc::collections::BTreeMap<
720        crate::id::TableId,
721        TableOption,
722    >,
723    #[prost(uint64, tag = "18")]
724    pub current_epoch_time: u64,
725    #[prost(uint64, tag = "19")]
726    pub target_sub_level_id: u64,
727    /// Identifies whether the task is space_reclaim, if the compact_task_type increases, it will be refactored to enum
728    #[prost(enumeration = "compact_task::TaskType", tag = "20")]
729    pub task_type: i32,
730    /// Deprecated. use table_vnode_partition instead;
731    #[deprecated]
732    #[prost(bool, tag = "21")]
733    pub split_by_state_table: bool,
734    /// Compaction needs to cut the state table every time 1/weight of vnodes in the table have been processed.
735    /// Deprecated. use table_vnode_partition instead;
736    #[prost(uint32, tag = "22")]
737    pub split_weight_by_vnode: u32,
738    #[prost(btree_map = "uint32, uint32", tag = "23", wrapper = "crate::id::TableId")]
739    pub table_vnode_partition: ::prost::alloc::collections::BTreeMap<
740        crate::id::TableId,
741        u32,
742    >,
743    /// The table watermark of any table id. In compaction we only use the table watermarks on safe epoch,
744    /// so we only need to include the table watermarks on safe epoch to reduce the size of metadata.
745    #[prost(btree_map = "uint32, message", tag = "24", wrapper = "crate::id::TableId")]
746    pub table_watermarks: ::prost::alloc::collections::BTreeMap<
747        crate::id::TableId,
748        TableWatermarks,
749    >,
750    /// The table schemas that are at least as new as the one used to create `input_ssts`.
751    #[prost(btree_map = "uint32, message", tag = "25", wrapper = "crate::id::TableId")]
752    pub table_schemas: ::prost::alloc::collections::BTreeMap<
753        crate::id::TableId,
754        TableSchema,
755    >,
756    /// Max sub compaction task numbers
757    #[prost(uint32, tag = "26")]
758    pub max_sub_compaction: u32,
759    /// The compaction group id when the compaction task is created.
760    #[prost(uint64, tag = "27")]
761    pub compaction_group_version_id: u64,
762    /// The maximum key-value count threshold for using Xor16 filter.
763    /// When the number of keys exceeds this threshold, a BlockedXor16 filter will be used.
764    #[prost(uint64, optional, tag = "28")]
765    pub max_kv_count_for_xor16: ::core::option::Option<u64>,
766}
767/// Nested message and enum types in `CompactTask`.
768pub mod compact_task {
769    #[derive(prost_helpers::AnyPB)]
770    #[derive(
771        Clone,
772        Copy,
773        Debug,
774        PartialEq,
775        Eq,
776        Hash,
777        PartialOrd,
778        Ord,
779        ::prost::Enumeration
780    )]
781    #[repr(i32)]
782    pub enum TaskStatus {
783        Unspecified = 0,
784        Pending = 1,
785        Success = 2,
786        HeartbeatCanceled = 3,
787        NoAvailMemoryResourceCanceled = 4,
788        AssignFailCanceled = 5,
789        SendFailCanceled = 6,
790        ManualCanceled = 7,
791        InvalidGroupCanceled = 8,
792        InputOutdatedCanceled = 9,
793        ExecuteFailed = 10,
794        JoinHandleFailed = 11,
795        TrackSstObjectIdFailed = 12,
796        NoAvailCpuResourceCanceled = 13,
797        HeartbeatProgressCanceled = 14,
798        RetentionTimeRejected = 17,
799        /// for serverless compaction
800        ServerlessSendFailCanceled = 15,
801        ServerlessTableNotFoundCanceled = 16,
802    }
803    impl TaskStatus {
804        /// String value of the enum field names used in the ProtoBuf definition.
805        ///
806        /// The values are not transformed in any way and thus are considered stable
807        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
808        pub fn as_str_name(&self) -> &'static str {
809            match self {
810                Self::Unspecified => "UNSPECIFIED",
811                Self::Pending => "PENDING",
812                Self::Success => "SUCCESS",
813                Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
814                Self::NoAvailMemoryResourceCanceled => {
815                    "NO_AVAIL_MEMORY_RESOURCE_CANCELED"
816                }
817                Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
818                Self::SendFailCanceled => "SEND_FAIL_CANCELED",
819                Self::ManualCanceled => "MANUAL_CANCELED",
820                Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
821                Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
822                Self::ExecuteFailed => "EXECUTE_FAILED",
823                Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
824                Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
825                Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
826                Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
827                Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
828                Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
829                Self::ServerlessTableNotFoundCanceled => {
830                    "SERVERLESS_TABLE_NOT_FOUND_CANCELED"
831                }
832            }
833        }
834        /// Creates an enum from field names used in the ProtoBuf definition.
835        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
836            match value {
837                "UNSPECIFIED" => Some(Self::Unspecified),
838                "PENDING" => Some(Self::Pending),
839                "SUCCESS" => Some(Self::Success),
840                "HEARTBEAT_CANCELED" => Some(Self::HeartbeatCanceled),
841                "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => {
842                    Some(Self::NoAvailMemoryResourceCanceled)
843                }
844                "ASSIGN_FAIL_CANCELED" => Some(Self::AssignFailCanceled),
845                "SEND_FAIL_CANCELED" => Some(Self::SendFailCanceled),
846                "MANUAL_CANCELED" => Some(Self::ManualCanceled),
847                "INVALID_GROUP_CANCELED" => Some(Self::InvalidGroupCanceled),
848                "INPUT_OUTDATED_CANCELED" => Some(Self::InputOutdatedCanceled),
849                "EXECUTE_FAILED" => Some(Self::ExecuteFailed),
850                "JOIN_HANDLE_FAILED" => Some(Self::JoinHandleFailed),
851                "TRACK_SST_OBJECT_ID_FAILED" => Some(Self::TrackSstObjectIdFailed),
852                "NO_AVAIL_CPU_RESOURCE_CANCELED" => {
853                    Some(Self::NoAvailCpuResourceCanceled)
854                }
855                "HEARTBEAT_PROGRESS_CANCELED" => Some(Self::HeartbeatProgressCanceled),
856                "RETENTION_TIME_REJECTED" => Some(Self::RetentionTimeRejected),
857                "SERVERLESS_SEND_FAIL_CANCELED" => Some(Self::ServerlessSendFailCanceled),
858                "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => {
859                    Some(Self::ServerlessTableNotFoundCanceled)
860                }
861                _ => None,
862            }
863        }
864    }
865    #[derive(prost_helpers::AnyPB)]
866    #[derive(
867        Clone,
868        Copy,
869        Debug,
870        PartialEq,
871        Eq,
872        Hash,
873        PartialOrd,
874        Ord,
875        ::prost::Enumeration
876    )]
877    #[repr(i32)]
878    pub enum TaskType {
879        TypeUnspecified = 0,
880        Dynamic = 1,
881        SpaceReclaim = 2,
882        Manual = 3,
883        SharedBuffer = 4,
884        Ttl = 5,
885        Tombstone = 6,
886        Emergency = 7,
887        VnodeWatermark = 8,
888    }
889    impl TaskType {
890        /// String value of the enum field names used in the ProtoBuf definition.
891        ///
892        /// The values are not transformed in any way and thus are considered stable
893        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
894        pub fn as_str_name(&self) -> &'static str {
895            match self {
896                Self::TypeUnspecified => "TYPE_UNSPECIFIED",
897                Self::Dynamic => "DYNAMIC",
898                Self::SpaceReclaim => "SPACE_RECLAIM",
899                Self::Manual => "MANUAL",
900                Self::SharedBuffer => "SHARED_BUFFER",
901                Self::Ttl => "TTL",
902                Self::Tombstone => "TOMBSTONE",
903                Self::Emergency => "EMERGENCY",
904                Self::VnodeWatermark => "VNODE_WATERMARK",
905            }
906        }
907        /// Creates an enum from field names used in the ProtoBuf definition.
908        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
909            match value {
910                "TYPE_UNSPECIFIED" => Some(Self::TypeUnspecified),
911                "DYNAMIC" => Some(Self::Dynamic),
912                "SPACE_RECLAIM" => Some(Self::SpaceReclaim),
913                "MANUAL" => Some(Self::Manual),
914                "SHARED_BUFFER" => Some(Self::SharedBuffer),
915                "TTL" => Some(Self::Ttl),
916                "TOMBSTONE" => Some(Self::Tombstone),
917                "EMERGENCY" => Some(Self::Emergency),
918                "VNODE_WATERMARK" => Some(Self::VnodeWatermark),
919                _ => None,
920            }
921        }
922    }
923}
924#[derive(prost_helpers::AnyPB)]
925#[derive(Eq)]
926#[derive(Clone, PartialEq, ::prost::Message)]
927pub struct LevelHandler {
928    #[prost(uint32, tag = "1")]
929    pub level: u32,
930    #[prost(message, repeated, tag = "3")]
931    pub tasks: ::prost::alloc::vec::Vec<level_handler::RunningCompactTask>,
932}
933/// Nested message and enum types in `LevelHandler`.
934pub mod level_handler {
935    #[derive(prost_helpers::AnyPB)]
936    #[derive(Eq)]
937    #[derive(Clone, PartialEq, ::prost::Message)]
938    pub struct RunningCompactTask {
939        #[prost(uint64, tag = "1")]
940        pub task_id: u64,
941        #[prost(uint64, repeated, tag = "2", wrapper = "crate::id::HummockSstableId")]
942        pub ssts: ::prost::alloc::vec::Vec<crate::id::HummockSstableId>,
943        #[prost(uint64, tag = "3")]
944        pub total_file_size: u64,
945        #[prost(uint32, tag = "4")]
946        pub target_level: u32,
947    }
948}
949#[derive(prost_helpers::AnyPB)]
950#[derive(Clone, PartialEq, ::prost::Message)]
951pub struct CompactStatus {
952    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
953    pub compaction_group_id: crate::id::CompactionGroupId,
954    #[prost(message, repeated, tag = "2")]
955    pub level_handlers: ::prost::alloc::vec::Vec<LevelHandler>,
956}
957/// Config info of compaction group.
958#[derive(prost_helpers::AnyPB)]
959#[derive(Clone, PartialEq, ::prost::Message)]
960pub struct CompactionGroup {
961    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
962    pub id: crate::id::CompactionGroupId,
963    #[prost(message, optional, tag = "4")]
964    pub compaction_config: ::core::option::Option<CompactionConfig>,
965}
966/// Complete info of compaction group.
967/// The info is the aggregate of HummockVersion and CompactionGroupConfig
968#[derive(prost_helpers::AnyPB)]
969#[derive(Clone, PartialEq, ::prost::Message)]
970pub struct CompactionGroupInfo {
971    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
972    pub id: crate::id::CompactionGroupId,
973    #[prost(uint64, tag = "2", wrapper = "crate::id::CompactionGroupId")]
974    pub parent_id: crate::id::CompactionGroupId,
975    #[prost(uint32, repeated, tag = "3", wrapper = "crate::id::TableId")]
976    pub member_table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
977    #[prost(message, optional, tag = "4")]
978    pub compaction_config: ::core::option::Option<CompactionConfig>,
979}
980#[derive(prost_helpers::AnyPB)]
981#[derive(Clone, PartialEq, ::prost::Message)]
982pub struct CompactTaskAssignment {
983    #[prost(message, optional, tag = "1")]
984    pub compact_task: ::core::option::Option<CompactTask>,
985    #[prost(uint32, tag = "2", wrapper = "crate::id::WorkerId")]
986    pub context_id: crate::id::WorkerId,
987}
988#[derive(prost_helpers::AnyPB)]
989#[derive(Clone, Copy, PartialEq, ::prost::Message)]
990pub struct HummockPinnedVersion {
991    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
992    pub context_id: crate::id::WorkerId,
993    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockVersionId")]
994    pub min_pinned_id: crate::id::HummockVersionId,
995}
996#[derive(prost_helpers::AnyPB)]
997#[derive(Clone, Copy, PartialEq, ::prost::Message)]
998pub struct HummockPinnedSnapshot {
999    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
1000    pub context_id: crate::id::WorkerId,
1001    #[prost(uint64, tag = "2")]
1002    pub minimal_pinned_snapshot: u64,
1003}
1004#[derive(prost_helpers::AnyPB)]
1005#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1006pub struct GetNewObjectIdsRequest {
1007    #[prost(uint32, tag = "1")]
1008    pub number: u32,
1009}
1010#[derive(prost_helpers::AnyPB)]
1011#[derive(Clone, PartialEq, ::prost::Message)]
1012pub struct GetNewObjectIdsResponse {
1013    #[prost(message, optional, tag = "1")]
1014    pub status: ::core::option::Option<super::common::Status>,
1015    /// inclusive
1016    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockRawObjectId")]
1017    pub start_id: crate::id::HummockRawObjectId,
1018    /// exclusive
1019    #[prost(uint64, tag = "3", wrapper = "crate::id::HummockRawObjectId")]
1020    pub end_id: crate::id::HummockRawObjectId,
1021}
1022/// This is a heartbeat message. Task will be considered dead if
1023/// CompactTaskProgress is not received for a timeout
1024/// or num_ssts_sealed/num_ssts_uploaded do not increase for a timeout.
1025#[derive(prost_helpers::AnyPB)]
1026#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1027pub struct CompactTaskProgress {
1028    #[prost(uint64, tag = "1")]
1029    pub task_id: u64,
1030    #[prost(uint32, tag = "2")]
1031    pub num_ssts_sealed: u32,
1032    #[prost(uint32, tag = "3")]
1033    pub num_ssts_uploaded: u32,
1034    #[prost(uint64, tag = "4")]
1035    pub num_progress_key: u64,
1036    #[prost(uint64, tag = "5")]
1037    pub num_pending_read_io: u64,
1038    #[prost(uint64, tag = "6")]
1039    pub num_pending_write_io: u64,
1040    #[prost(uint64, optional, tag = "7", wrapper = "crate::id::CompactionGroupId")]
1041    pub compaction_group_id: ::core::option::Option<crate::id::CompactionGroupId>,
1042}
1043#[derive(prost_helpers::AnyPB)]
1044#[derive(Clone, PartialEq, ::prost::Message)]
1045pub struct SubscribeCompactionEventRequest {
1046    #[prost(uint64, tag = "7")]
1047    pub create_at: u64,
1048    #[prost(oneof = "subscribe_compaction_event_request::Event", tags = "1, 2, 3, 4")]
1049    pub event: ::core::option::Option<subscribe_compaction_event_request::Event>,
1050}
1051/// Nested message and enum types in `SubscribeCompactionEventRequest`.
1052pub mod subscribe_compaction_event_request {
1053    /// Register provides the context_id of the corresponding Compactor.
1054    #[derive(prost_helpers::AnyPB)]
1055    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
1056    pub struct Register {
1057        #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
1058        pub context_id: crate::id::WorkerId,
1059    }
1060    /// PullTask provides the number of tasks needed for the Compactor.
1061    #[derive(prost_helpers::AnyPB)]
1062    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
1063    pub struct PullTask {
1064        #[prost(uint32, tag = "4")]
1065        pub pull_task_count: u32,
1066    }
1067    /// ReportTask provides the compact task to report to the meta.
1068    #[derive(prost_helpers::AnyPB)]
1069    #[derive(Clone, PartialEq, ::prost::Message)]
1070    pub struct ReportTask {
1071        #[prost(map = "uint32, message", tag = "3", wrapper = "crate::id::TableId")]
1072        pub table_stats_change: ::std::collections::HashMap<
1073            crate::id::TableId,
1074            super::TableStats,
1075        >,
1076        #[prost(uint64, tag = "4")]
1077        pub task_id: u64,
1078        #[prost(enumeration = "super::compact_task::TaskStatus", tag = "5")]
1079        pub task_status: i32,
1080        #[prost(message, repeated, tag = "6")]
1081        pub sorted_output_ssts: ::prost::alloc::vec::Vec<super::SstableInfo>,
1082        #[prost(
1083            map = "uint64, uint64",
1084            tag = "7",
1085            wrapper = "crate::id::HummockSstableObjectId"
1086        )]
1087        pub object_timestamps: ::std::collections::HashMap<
1088            crate::id::HummockSstableObjectId,
1089            u64,
1090        >,
1091    }
1092    /// HeartBeat provides the progress status of all tasks on the Compactor.
1093    #[derive(prost_helpers::AnyPB)]
1094    #[derive(Clone, PartialEq, ::prost::Message)]
1095    pub struct HeartBeat {
1096        #[prost(message, repeated, tag = "2")]
1097        pub progress: ::prost::alloc::vec::Vec<super::CompactTaskProgress>,
1098    }
1099    #[derive(prost_helpers::AnyPB)]
1100    #[derive(Clone, PartialEq, ::prost::Oneof)]
1101    pub enum Event {
1102        /// Compactor will register its own context_id with Meta via Register and establish a bi-directional streaming rpc.
1103        #[prost(message, tag = "1")]
1104        Register(Register),
1105        /// Compactor will recalculate the number of tasks needed locally after receiving the PullTaskAck and get the next batch of tasks from Meta via PullTask.
1106        #[prost(message, tag = "2")]
1107        PullTask(PullTask),
1108        /// When the execution of each task completes/fails, Compactor returns the task to the meta via ReportTask.
1109        #[prost(message, tag = "3")]
1110        ReportTask(ReportTask),
1111        /// Periodically, HeartBeat carries the progress of all tasks on the Compactor, and the meta will cancel the task when it expires.
1112        #[prost(message, tag = "4")]
1113        HeartBeat(HeartBeat),
1114    }
1115}
1116#[derive(prost_helpers::AnyPB)]
1117#[derive(Clone, PartialEq, ::prost::Message)]
1118pub struct SubscribeCompactionEventResponse {
1119    #[prost(uint64, tag = "7")]
1120    pub create_at: u64,
1121    #[prost(
1122        oneof = "subscribe_compaction_event_response::Event",
1123        tags = "1, 2, 3, 4, 5, 6"
1124    )]
1125    pub event: ::core::option::Option<subscribe_compaction_event_response::Event>,
1126}
1127/// Nested message and enum types in `SubscribeCompactionEventResponse`.
1128pub mod subscribe_compaction_event_response {
1129    /// PullTaskAck is a response, the meta will return a PullTaskAck after distributing the task requested by the PullTask.
1130    /// The Compactor receives the PullTaskAck and remakes its state and tries to initiate the next PullTask.
1131    #[derive(prost_helpers::AnyPB)]
1132    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
1133    pub struct PullTaskAck {}
1134    #[derive(prost_helpers::AnyPB)]
1135    #[derive(Clone, PartialEq, ::prost::Oneof)]
1136    pub enum Event {
1137        #[prost(message, tag = "1")]
1138        CompactTask(super::CompactTask),
1139        #[prost(message, tag = "2")]
1140        VacuumTask(super::VacuumTask),
1141        #[prost(message, tag = "3")]
1142        FullScanTask(super::FullScanTask),
1143        #[prost(message, tag = "4")]
1144        ValidationTask(super::ValidationTask),
1145        #[prost(message, tag = "5")]
1146        CancelCompactTask(super::CancelCompactTask),
1147        #[prost(message, tag = "6")]
1148        PullTaskAck(PullTaskAck),
1149    }
1150}
1151#[derive(prost_helpers::AnyPB)]
1152#[derive(Clone, PartialEq, ::prost::Message)]
1153pub struct ReportCompactionTaskRequest {
1154    #[prost(oneof = "report_compaction_task_request::Event", tags = "1, 2")]
1155    pub event: ::core::option::Option<report_compaction_task_request::Event>,
1156}
1157/// Nested message and enum types in `ReportCompactionTaskRequest`.
1158pub mod report_compaction_task_request {
1159    /// ReportTask provides the compact task to report to the meta.
1160    #[derive(prost_helpers::AnyPB)]
1161    #[derive(Clone, PartialEq, ::prost::Message)]
1162    pub struct ReportTask {
1163        #[prost(message, optional, tag = "2")]
1164        pub compact_task: ::core::option::Option<super::CompactTask>,
1165        #[prost(map = "uint32, message", tag = "3", wrapper = "crate::id::TableId")]
1166        pub table_stats_change: ::std::collections::HashMap<
1167            crate::id::TableId,
1168            super::TableStats,
1169        >,
1170        #[prost(
1171            map = "uint64, uint64",
1172            tag = "4",
1173            wrapper = "crate::id::HummockSstableObjectId"
1174        )]
1175        pub object_timestamps: ::std::collections::HashMap<
1176            crate::id::HummockSstableObjectId,
1177            u64,
1178        >,
1179    }
1180    /// HeartBeat provides the progress status of all tasks on the Compactor.
1181    #[derive(prost_helpers::AnyPB)]
1182    #[derive(Clone, PartialEq, ::prost::Message)]
1183    pub struct HeartBeat {
1184        #[prost(message, repeated, tag = "2")]
1185        pub progress: ::prost::alloc::vec::Vec<super::CompactTaskProgress>,
1186    }
1187    #[derive(prost_helpers::AnyPB)]
1188    #[derive(Clone, PartialEq, ::prost::Oneof)]
1189    pub enum Event {
1190        #[prost(message, tag = "1")]
1191        ReportTask(ReportTask),
1192        #[prost(message, tag = "2")]
1193        HeartBeat(HeartBeat),
1194    }
1195}
1196#[derive(prost_helpers::AnyPB)]
1197#[derive(Clone, PartialEq, ::prost::Message)]
1198pub struct ReportCompactionTaskResponse {
1199    #[prost(message, optional, tag = "1")]
1200    pub status: ::core::option::Option<super::common::Status>,
1201}
1202#[derive(prost_helpers::AnyPB)]
1203#[derive(Clone, PartialEq, ::prost::Message)]
1204pub struct ValidationTask {
1205    #[prost(message, repeated, tag = "1")]
1206    pub sst_infos: ::prost::alloc::vec::Vec<SstableInfo>,
1207    #[prost(
1208        map = "uint64, uint32",
1209        tag = "2",
1210        wrapper = "crate::id::HummockSstableObjectId"
1211    )]
1212    pub sst_id_to_worker_id: ::std::collections::HashMap<
1213        crate::id::HummockSstableObjectId,
1214        u32,
1215    >,
1216}
1217/// Delete SSTs in object store
1218#[derive(prost_helpers::AnyPB)]
1219#[derive(Clone, PartialEq, ::prost::Message)]
1220pub struct VacuumTask {
1221    #[prost(uint64, repeated, tag = "1", wrapper = "crate::id::HummockSstableObjectId")]
1222    pub sstable_object_ids: ::prost::alloc::vec::Vec<crate::id::HummockSstableObjectId>,
1223}
1224/// Scan object store to get candidate orphan SSTs.
1225#[derive(prost_helpers::AnyPB)]
1226#[derive(Clone, PartialEq, ::prost::Message)]
1227pub struct FullScanTask {
1228    #[prost(uint64, tag = "1")]
1229    pub sst_retention_watermark: u64,
1230    #[prost(string, optional, tag = "2")]
1231    pub prefix: ::core::option::Option<::prost::alloc::string::String>,
1232    #[prost(string, optional, tag = "3")]
1233    pub start_after: ::core::option::Option<::prost::alloc::string::String>,
1234    #[prost(uint64, optional, tag = "4")]
1235    pub limit: ::core::option::Option<u64>,
1236}
1237/// Cancel compact task
1238#[derive(prost_helpers::AnyPB)]
1239#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1240pub struct CancelCompactTask {
1241    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
1242    pub context_id: crate::id::WorkerId,
1243    #[prost(uint64, tag = "2")]
1244    pub task_id: u64,
1245}
1246#[derive(prost_helpers::AnyPB)]
1247#[derive(Clone, PartialEq, ::prost::Message)]
1248pub struct TriggerManualCompactionRequest {
1249    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1250    pub compaction_group_id: crate::id::CompactionGroupId,
1251    #[prost(message, optional, tag = "2")]
1252    pub key_range: ::core::option::Option<KeyRange>,
1253    #[prost(uint32, tag = "3", wrapper = "crate::id::JobId")]
1254    pub table_id: crate::id::JobId,
1255    #[prost(uint32, tag = "4")]
1256    pub level: u32,
1257    #[prost(uint64, repeated, tag = "5", wrapper = "crate::id::HummockSstableId")]
1258    pub sst_ids: ::prost::alloc::vec::Vec<crate::id::HummockSstableId>,
1259}
1260#[derive(prost_helpers::AnyPB)]
1261#[derive(Clone, PartialEq, ::prost::Message)]
1262pub struct TriggerManualCompactionResponse {
1263    #[prost(message, optional, tag = "1")]
1264    pub status: ::core::option::Option<super::common::Status>,
1265}
1266#[derive(prost_helpers::AnyPB)]
1267#[derive(Clone, PartialEq, ::prost::Message)]
1268pub struct TriggerFullGcRequest {
1269    #[prost(uint64, tag = "1")]
1270    pub sst_retention_time_sec: u64,
1271    #[prost(string, optional, tag = "2")]
1272    pub prefix: ::core::option::Option<::prost::alloc::string::String>,
1273}
1274#[derive(prost_helpers::AnyPB)]
1275#[derive(Clone, PartialEq, ::prost::Message)]
1276pub struct TriggerFullGcResponse {
1277    #[prost(message, optional, tag = "1")]
1278    pub status: ::core::option::Option<super::common::Status>,
1279}
1280#[derive(prost_helpers::AnyPB)]
1281#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1282pub struct ListVersionDeltasRequest {
1283    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockVersionId")]
1284    pub start_id: crate::id::HummockVersionId,
1285    #[prost(uint32, tag = "2")]
1286    pub num_limit: u32,
1287    #[prost(uint64, tag = "3")]
1288    pub committed_epoch_limit: u64,
1289}
1290#[derive(prost_helpers::AnyPB)]
1291#[derive(Clone, PartialEq, ::prost::Message)]
1292pub struct ListVersionDeltasResponse {
1293    #[prost(message, optional, tag = "1")]
1294    pub version_deltas: ::core::option::Option<HummockVersionDeltas>,
1295}
1296#[derive(prost_helpers::AnyPB)]
1297#[derive(Clone, PartialEq, ::prost::Message)]
1298pub struct PinnedVersionsSummary {
1299    #[prost(message, repeated, tag = "1")]
1300    pub pinned_versions: ::prost::alloc::vec::Vec<HummockPinnedVersion>,
1301    #[prost(map = "uint32, message", tag = "2", wrapper = "crate::id::WorkerId")]
1302    pub workers: ::std::collections::HashMap<
1303        crate::id::WorkerId,
1304        super::common::WorkerNode,
1305    >,
1306}
1307#[derive(prost_helpers::AnyPB)]
1308#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1309pub struct RiseCtlGetPinnedVersionsSummaryRequest {}
1310#[derive(prost_helpers::AnyPB)]
1311#[derive(Clone, PartialEq, ::prost::Message)]
1312pub struct RiseCtlGetPinnedVersionsSummaryResponse {
1313    #[prost(message, optional, tag = "1")]
1314    pub summary: ::core::option::Option<PinnedVersionsSummary>,
1315}
1316#[derive(prost_helpers::AnyPB)]
1317#[derive(Clone, PartialEq, ::prost::Message)]
1318pub struct InitMetadataForReplayRequest {
1319    #[prost(message, repeated, tag = "1")]
1320    pub tables: ::prost::alloc::vec::Vec<super::catalog::Table>,
1321    #[prost(message, repeated, tag = "2")]
1322    pub compaction_groups: ::prost::alloc::vec::Vec<CompactionGroupInfo>,
1323}
1324#[derive(prost_helpers::AnyPB)]
1325#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1326pub struct InitMetadataForReplayResponse {}
1327#[derive(prost_helpers::AnyPB)]
1328#[derive(Clone, PartialEq, ::prost::Message)]
1329pub struct ReplayVersionDeltaRequest {
1330    #[prost(message, optional, tag = "1")]
1331    pub version_delta: ::core::option::Option<HummockVersionDelta>,
1332}
1333#[derive(prost_helpers::AnyPB)]
1334#[derive(Clone, PartialEq, ::prost::Message)]
1335pub struct ReplayVersionDeltaResponse {
1336    #[prost(message, optional, tag = "1")]
1337    pub version: ::core::option::Option<HummockVersion>,
1338    #[prost(uint64, repeated, tag = "2", wrapper = "crate::id::CompactionGroupId")]
1339    pub modified_compaction_groups: ::prost::alloc::vec::Vec<
1340        crate::id::CompactionGroupId,
1341    >,
1342}
1343#[derive(prost_helpers::AnyPB)]
1344#[derive(Clone, PartialEq, ::prost::Message)]
1345pub struct TriggerCompactionDeterministicRequest {
1346    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockVersionId")]
1347    pub version_id: crate::id::HummockVersionId,
1348    #[prost(uint64, repeated, tag = "2", wrapper = "crate::id::CompactionGroupId")]
1349    pub compaction_groups: ::prost::alloc::vec::Vec<crate::id::CompactionGroupId>,
1350}
1351#[derive(prost_helpers::AnyPB)]
1352#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1353pub struct TriggerCompactionDeterministicResponse {}
1354#[derive(prost_helpers::AnyPB)]
1355#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1356pub struct DisableCommitEpochRequest {}
1357#[derive(prost_helpers::AnyPB)]
1358#[derive(Clone, PartialEq, ::prost::Message)]
1359pub struct DisableCommitEpochResponse {
1360    #[prost(message, optional, tag = "1")]
1361    pub current_version: ::core::option::Option<HummockVersion>,
1362}
1363#[derive(prost_helpers::AnyPB)]
1364#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1365pub struct RiseCtlListCompactionGroupRequest {}
1366#[derive(prost_helpers::AnyPB)]
1367#[derive(Clone, PartialEq, ::prost::Message)]
1368pub struct RiseCtlListCompactionGroupResponse {
1369    #[prost(message, optional, tag = "1")]
1370    pub status: ::core::option::Option<super::common::Status>,
1371    #[prost(message, repeated, tag = "2")]
1372    pub compaction_groups: ::prost::alloc::vec::Vec<CompactionGroupInfo>,
1373}
1374#[derive(prost_helpers::AnyPB)]
1375#[derive(Clone, PartialEq, ::prost::Message)]
1376pub struct RiseCtlUpdateCompactionConfigRequest {
1377    #[prost(uint64, repeated, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1378    pub compaction_group_ids: ::prost::alloc::vec::Vec<crate::id::CompactionGroupId>,
1379    #[prost(message, repeated, tag = "2")]
1380    pub configs: ::prost::alloc::vec::Vec<
1381        rise_ctl_update_compaction_config_request::MutableConfig,
1382    >,
1383}
1384/// Nested message and enum types in `RiseCtlUpdateCompactionConfigRequest`.
1385pub mod rise_ctl_update_compaction_config_request {
1386    #[derive(prost_helpers::AnyPB)]
1387    #[derive(Clone, PartialEq, ::prost::Message)]
1388    pub struct CompressionAlgorithm {
1389        #[prost(uint32, tag = "1")]
1390        pub level: u32,
1391        #[prost(string, tag = "2")]
1392        pub compression_algorithm: ::prost::alloc::string::String,
1393    }
1394    #[derive(prost_helpers::AnyPB)]
1395    #[derive(Clone, PartialEq, ::prost::Message)]
1396    pub struct MutableConfig {
1397        #[prost(
1398            oneof = "mutable_config::MutableConfig",
1399            tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 25, 26, 27, 28, 29, 30, 31, 32"
1400        )]
1401        pub mutable_config: ::core::option::Option<mutable_config::MutableConfig>,
1402    }
1403    /// Nested message and enum types in `MutableConfig`.
1404    pub mod mutable_config {
1405        #[derive(prost_helpers::AnyPB)]
1406        #[derive(Clone, PartialEq, ::prost::Oneof)]
1407        pub enum MutableConfig {
1408            #[prost(uint64, tag = "1")]
1409            MaxBytesForLevelBase(u64),
1410            #[prost(uint64, tag = "2")]
1411            MaxBytesForLevelMultiplier(u64),
1412            #[prost(uint64, tag = "3")]
1413            MaxCompactionBytes(u64),
1414            #[prost(uint64, tag = "4")]
1415            SubLevelMaxCompactionBytes(u64),
1416            #[prost(uint64, tag = "6")]
1417            Level0TierCompactFileNumber(u64),
1418            #[prost(uint64, tag = "7")]
1419            TargetFileSizeBase(u64),
1420            #[prost(uint32, tag = "8")]
1421            CompactionFilterMask(u32),
1422            #[prost(uint32, tag = "9")]
1423            MaxSubCompaction(u32),
1424            #[prost(uint64, tag = "10")]
1425            Level0StopWriteThresholdSubLevelNumber(u64),
1426            #[prost(uint32, tag = "11")]
1427            Level0SubLevelCompactLevelCount(u32),
1428            #[prost(uint32, tag = "12")]
1429            Level0OverlappingSubLevelCompactLevelCount(u32),
1430            #[prost(uint64, tag = "13")]
1431            MaxSpaceReclaimBytes(u64),
1432            #[prost(uint64, tag = "14")]
1433            Level0MaxCompactFileNumber(u64),
1434            #[prost(bool, tag = "15")]
1435            EnableEmergencyPicker(bool),
1436            #[prost(uint32, tag = "16")]
1437            TombstoneReclaimRatio(u32),
1438            #[prost(message, tag = "17")]
1439            CompressionAlgorithm(super::CompressionAlgorithm),
1440            #[prost(uint32, tag = "18")]
1441            MaxL0CompactLevelCount(u32),
1442            #[prost(uint64, tag = "19")]
1443            SstAllowedTrivialMoveMinSize(u64),
1444            #[prost(uint32, tag = "20")]
1445            SplitWeightByVnode(u32),
1446            #[prost(bool, tag = "21")]
1447            DisableAutoGroupScheduling(bool),
1448            #[prost(uint64, tag = "22")]
1449            MaxOverlappingLevelSize(u64),
1450            /// The emergency compaction limitations for the level0 sstables file count
1451            #[prost(uint32, tag = "25")]
1452            EmergencyLevel0SstFileCount(u32),
1453            /// The emergency compaction limitations for the level0 sub level partition
1454            #[prost(uint32, tag = "26")]
1455            EmergencyLevel0SubLevelPartition(u32),
1456            /// The limitation of the max sst size of the level0 to trigger the write stop
1457            #[prost(uint32, tag = "27")]
1458            Level0StopWriteThresholdMaxSstCount(u32),
1459            /// The limitation of the max sst size of the level0 to trigger the write stop
1460            #[prost(uint64, tag = "28")]
1461            Level0StopWriteThresholdMaxSize(u64),
1462            /// The limitation of the max sst count of the trivial move task
1463            #[prost(uint32, tag = "29")]
1464            SstAllowedTrivialMoveMaxCount(u32),
1465            /// Enable the optimization of the interval selection for the level0 compaction
1466            #[prost(bool, tag = "30")]
1467            EnableOptimizeL0IntervalSelection(bool),
1468            #[prost(uint64, tag = "31")]
1469            VnodeAlignedLevelSizeThreshold(u64),
1470            /// The maximum key-value count threshold for using Xor16 filter
1471            #[prost(uint64, tag = "32")]
1472            MaxKvCountForXor16(u64),
1473        }
1474    }
1475}
1476#[derive(prost_helpers::AnyPB)]
1477#[derive(Clone, PartialEq, ::prost::Message)]
1478pub struct RiseCtlUpdateCompactionConfigResponse {
1479    #[prost(message, optional, tag = "1")]
1480    pub status: ::core::option::Option<super::common::Status>,
1481}
1482#[derive(prost_helpers::AnyPB)]
1483#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1484pub struct PinVersionRequest {
1485    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
1486    pub context_id: crate::id::WorkerId,
1487}
1488#[derive(prost_helpers::AnyPB)]
1489#[derive(Clone, PartialEq, ::prost::Message)]
1490pub struct PinVersionResponse {
1491    #[prost(message, optional, tag = "1")]
1492    pub pinned_version: ::core::option::Option<HummockVersion>,
1493}
1494#[derive(prost_helpers::AnyPB)]
1495#[derive(Clone, PartialEq, ::prost::Message)]
1496pub struct SplitCompactionGroupRequest {
1497    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1498    pub group_id: crate::id::CompactionGroupId,
1499    #[prost(uint32, repeated, tag = "2", wrapper = "crate::id::TableId")]
1500    pub table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
1501    #[prost(uint32, tag = "3")]
1502    pub partition_vnode_count: u32,
1503}
1504#[derive(prost_helpers::AnyPB)]
1505#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1506pub struct SplitCompactionGroupResponse {
1507    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1508    pub new_group_id: crate::id::CompactionGroupId,
1509}
1510#[derive(prost_helpers::AnyPB)]
1511#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1512pub struct RiseCtlPauseVersionCheckpointRequest {}
1513#[derive(prost_helpers::AnyPB)]
1514#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1515pub struct RiseCtlPauseVersionCheckpointResponse {}
1516#[derive(prost_helpers::AnyPB)]
1517#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1518pub struct RiseCtlResumeVersionCheckpointRequest {}
1519#[derive(prost_helpers::AnyPB)]
1520#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1521pub struct RiseCtlResumeVersionCheckpointResponse {}
1522#[derive(prost_helpers::AnyPB)]
1523#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1524pub struct RiseCtlGetCheckpointVersionRequest {}
1525#[derive(prost_helpers::AnyPB)]
1526#[derive(Clone, PartialEq, ::prost::Message)]
1527pub struct RiseCtlGetCheckpointVersionResponse {
1528    #[prost(message, optional, tag = "1")]
1529    pub checkpoint_version: ::core::option::Option<HummockVersion>,
1530}
1531#[derive(prost_helpers::AnyPB)]
1532#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1533pub struct RiseCtlListCompactionStatusRequest {}
1534#[derive(prost_helpers::AnyPB)]
1535#[derive(Clone, PartialEq, ::prost::Message)]
1536pub struct RiseCtlListCompactionStatusResponse {
1537    #[prost(message, repeated, tag = "1")]
1538    pub compaction_statuses: ::prost::alloc::vec::Vec<CompactStatus>,
1539    #[prost(message, repeated, tag = "2")]
1540    pub task_assignment: ::prost::alloc::vec::Vec<CompactTaskAssignment>,
1541    #[prost(message, repeated, tag = "3")]
1542    pub task_progress: ::prost::alloc::vec::Vec<CompactTaskProgress>,
1543}
1544#[derive(prost_helpers::AnyPB)]
1545#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1546pub struct ListBranchedObjectRequest {}
1547#[derive(prost_helpers::AnyPB)]
1548#[derive(Clone, PartialEq, ::prost::Message)]
1549pub struct ListBranchedObjectResponse {
1550    #[prost(message, repeated, tag = "1")]
1551    pub branched_objects: ::prost::alloc::vec::Vec<BranchedObject>,
1552}
1553#[derive(prost_helpers::AnyPB)]
1554#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1555pub struct ListActiveWriteLimitRequest {}
1556#[derive(prost_helpers::AnyPB)]
1557#[derive(Clone, PartialEq, ::prost::Message)]
1558pub struct ListActiveWriteLimitResponse {
1559    /// < compaction group id, write limit info >
1560    #[prost(
1561        map = "uint64, message",
1562        tag = "1",
1563        wrapper = "crate::id::CompactionGroupId"
1564    )]
1565    pub write_limits: ::std::collections::HashMap<
1566        crate::id::CompactionGroupId,
1567        write_limits::WriteLimit,
1568    >,
1569}
1570#[derive(prost_helpers::AnyPB)]
1571#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1572pub struct ListHummockMetaConfigRequest {}
1573#[derive(prost_helpers::AnyPB)]
1574#[derive(Clone, PartialEq, ::prost::Message)]
1575pub struct ListHummockMetaConfigResponse {
1576    #[prost(map = "string, string", tag = "1")]
1577    pub configs: ::std::collections::HashMap<
1578        ::prost::alloc::string::String,
1579        ::prost::alloc::string::String,
1580    >,
1581}
1582#[derive(prost_helpers::AnyPB)]
1583#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1584pub struct RiseCtlRebuildTableStatsRequest {}
1585#[derive(prost_helpers::AnyPB)]
1586#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1587pub struct RiseCtlRebuildTableStatsResponse {}
1588#[derive(prost_helpers::AnyPB)]
1589#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1590pub struct GetCompactionScoreRequest {
1591    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1592    pub compaction_group_id: crate::id::CompactionGroupId,
1593}
1594#[derive(prost_helpers::AnyPB)]
1595#[derive(Clone, PartialEq, ::prost::Message)]
1596pub struct GetCompactionScoreResponse {
1597    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1598    pub compaction_group_id: crate::id::CompactionGroupId,
1599    #[prost(message, repeated, tag = "2")]
1600    pub scores: ::prost::alloc::vec::Vec<get_compaction_score_response::PickerInfo>,
1601}
1602/// Nested message and enum types in `GetCompactionScoreResponse`.
1603pub mod get_compaction_score_response {
1604    #[derive(prost_helpers::AnyPB)]
1605    #[derive(Clone, PartialEq, ::prost::Message)]
1606    pub struct PickerInfo {
1607        #[prost(uint64, tag = "1")]
1608        pub score: u64,
1609        #[prost(uint64, tag = "2")]
1610        pub select_level: u64,
1611        #[prost(uint64, tag = "3")]
1612        pub target_level: u64,
1613        #[prost(string, tag = "4")]
1614        pub picker_type: ::prost::alloc::string::String,
1615    }
1616}
1617#[derive(prost_helpers::AnyPB)]
1618#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1619pub struct ListCompactTaskAssignmentRequest {}
1620#[derive(prost_helpers::AnyPB)]
1621#[derive(Clone, PartialEq, ::prost::Message)]
1622pub struct ListCompactTaskAssignmentResponse {
1623    #[prost(message, repeated, tag = "1")]
1624    pub task_assignment: ::prost::alloc::vec::Vec<CompactTaskAssignment>,
1625}
1626#[derive(prost_helpers::AnyPB)]
1627#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1628pub struct ListCompactTaskProgressRequest {}
1629#[derive(prost_helpers::AnyPB)]
1630#[derive(Clone, PartialEq, ::prost::Message)]
1631pub struct ListCompactTaskProgressResponse {
1632    #[prost(message, repeated, tag = "1")]
1633    pub task_progress: ::prost::alloc::vec::Vec<CompactTaskProgress>,
1634}
1635#[derive(prost_helpers::AnyPB)]
1636#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1637pub struct CancelCompactTaskRequest {
1638    #[prost(uint64, tag = "1")]
1639    pub task_id: u64,
1640    #[prost(enumeration = "compact_task::TaskStatus", tag = "2")]
1641    pub task_status: i32,
1642}
1643#[derive(prost_helpers::AnyPB)]
1644#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1645pub struct CancelCompactTaskResponse {
1646    #[prost(bool, tag = "1")]
1647    pub ret: bool,
1648}
1649#[derive(prost_helpers::AnyPB)]
1650#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1651pub struct GetVersionByEpochRequest {
1652    #[prost(uint64, tag = "1")]
1653    pub epoch: u64,
1654    #[prost(uint32, tag = "2", wrapper = "crate::id::TableId")]
1655    pub table_id: crate::id::TableId,
1656}
1657#[derive(prost_helpers::AnyPB)]
1658#[derive(Clone, PartialEq, ::prost::Message)]
1659pub struct GetVersionByEpochResponse {
1660    #[prost(message, optional, tag = "1")]
1661    pub version: ::core::option::Option<HummockVersion>,
1662}
1663#[derive(prost_helpers::AnyPB)]
1664#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1665pub struct MergeCompactionGroupRequest {
1666    #[prost(uint64, tag = "1", wrapper = "crate::id::CompactionGroupId")]
1667    pub left_group_id: crate::id::CompactionGroupId,
1668    #[prost(uint64, tag = "2", wrapper = "crate::id::CompactionGroupId")]
1669    pub right_group_id: crate::id::CompactionGroupId,
1670}
1671#[derive(prost_helpers::AnyPB)]
1672#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1673pub struct MergeCompactionGroupResponse {}
1674#[derive(prost_helpers::AnyPB)]
1675#[derive(Eq)]
1676#[derive(Clone, PartialEq, ::prost::Message)]
1677pub struct CompactionConfig {
1678    #[prost(uint64, tag = "1")]
1679    pub max_bytes_for_level_base: u64,
1680    #[prost(uint64, tag = "2")]
1681    pub max_level: u64,
1682    #[prost(uint64, tag = "3")]
1683    pub max_bytes_for_level_multiplier: u64,
1684    #[prost(uint64, tag = "4")]
1685    pub max_compaction_bytes: u64,
1686    #[prost(uint64, tag = "5")]
1687    pub sub_level_max_compaction_bytes: u64,
1688    #[prost(uint64, tag = "7")]
1689    pub level0_tier_compact_file_number: u64,
1690    #[prost(enumeration = "compaction_config::CompactionMode", tag = "8")]
1691    pub compaction_mode: i32,
1692    #[prost(string, repeated, tag = "9")]
1693    pub compression_algorithm: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1694    #[prost(uint64, tag = "10")]
1695    pub target_file_size_base: u64,
1696    #[prost(uint32, tag = "11")]
1697    pub compaction_filter_mask: u32,
1698    #[prost(uint32, tag = "12")]
1699    pub max_sub_compaction: u32,
1700    #[prost(uint64, tag = "13")]
1701    pub max_space_reclaim_bytes: u64,
1702    #[prost(bool, tag = "14")]
1703    pub split_by_state_table: bool,
1704    /// Compaction needs to cut the state table every time 1/weight of vnodes in the table have been processed.
1705    #[prost(uint32, tag = "6")]
1706    pub split_weight_by_vnode: u32,
1707    /// soft limit for max number of sub level number
1708    #[prost(uint64, tag = "15")]
1709    pub level0_stop_write_threshold_sub_level_number: u64,
1710    #[prost(uint64, tag = "16")]
1711    pub level0_max_compact_file_number: u64,
1712    #[prost(uint32, tag = "17")]
1713    pub level0_sub_level_compact_level_count: u32,
1714    /// for tier compaction pick overlapping level
1715    #[prost(uint32, tag = "18")]
1716    pub level0_overlapping_sub_level_compact_level_count: u32,
1717    #[prost(uint32, tag = "19")]
1718    pub tombstone_reclaim_ratio: u32,
1719    #[prost(bool, tag = "20")]
1720    pub enable_emergency_picker: bool,
1721    /// The limitation of the level count of l0 compaction
1722    #[prost(uint32, optional, tag = "21")]
1723    pub max_l0_compact_level_count: ::core::option::Option<u32>,
1724    /// The limitation of base level trivial move sst size
1725    #[prost(uint64, optional, tag = "22")]
1726    pub sst_allowed_trivial_move_min_size: ::core::option::Option<u64>,
1727    /// The limitation of auto group scheduling
1728    #[prost(bool, optional, tag = "23")]
1729    pub disable_auto_group_scheduling: ::core::option::Option<bool>,
1730    /// The limitation of the max size of the overlapping-level for the compaction
1731    /// hummock will reorg the commit-sstables to the multi overlapping-level if the size of the commit-sstables is larger than `max_overlapping_level_size`
1732    #[prost(uint64, optional, tag = "24")]
1733    pub max_overlapping_level_size: ::core::option::Option<u64>,
1734    /// The emergency compaction limitations for the level0 sstables file count
1735    #[prost(uint32, optional, tag = "25")]
1736    pub emergency_level0_sst_file_count: ::core::option::Option<u32>,
1737    /// The emergency compaction limitations for the level0 sub level partition
1738    #[prost(uint32, optional, tag = "26")]
1739    pub emergency_level0_sub_level_partition: ::core::option::Option<u32>,
1740    /// The limitation of the max sst count of the level0 to trigger the write stop
1741    #[prost(uint32, optional, tag = "27")]
1742    pub level0_stop_write_threshold_max_sst_count: ::core::option::Option<u32>,
1743    /// The limitation of the max sst size of the level0 to trigger the write stop
1744    #[prost(uint64, optional, tag = "28")]
1745    pub level0_stop_write_threshold_max_size: ::core::option::Option<u64>,
1746    /// The limitation of the max sst count of the trivial move task
1747    #[prost(uint32, optional, tag = "29")]
1748    pub sst_allowed_trivial_move_max_count: ::core::option::Option<u32>,
1749    /// Enable the optimization of the interval selection for the level0 compaction
1750    #[prost(bool, optional, tag = "30")]
1751    pub enable_optimize_l0_interval_selection: ::core::option::Option<bool>,
1752    /// Enable strict one-vnode-per-SST for levels that meet the size threshold.
1753    /// Only effective when both conditions are met:
1754    ///    1. target_level > base_level (deeper levels only)
1755    ///    2. level.total_file_size >= this threshold
1756    ///
1757    /// This prevents generating too many small SSTs when level size is small.
1758    /// Each SST will contain exactly one vnode, enabling precise query pruning.
1759    ///
1760    /// Typical value: 50GB.
1761    #[prost(uint64, optional, tag = "31")]
1762    pub vnode_aligned_level_size_threshold: ::core::option::Option<u64>,
1763    /// The maximum key-value count threshold for using Xor16 filter instead of BlockedXor16 filter.
1764    /// When the number of keys in a compaction task or SST exceeds this threshold,
1765    /// a BlockedXor16 filter will be used instead of a single Xor16 filter.
1766    ///
1767    /// Typical value: 256 * 1024 (256K keys).
1768    #[prost(uint64, optional, tag = "32")]
1769    pub max_kv_count_for_xor16: ::core::option::Option<u64>,
1770}
1771/// Nested message and enum types in `CompactionConfig`.
1772pub mod compaction_config {
1773    #[derive(prost_helpers::AnyPB)]
1774    #[derive(
1775        Clone,
1776        Copy,
1777        Debug,
1778        PartialEq,
1779        Eq,
1780        Hash,
1781        PartialOrd,
1782        Ord,
1783        ::prost::Enumeration
1784    )]
1785    #[repr(i32)]
1786    pub enum CompactionMode {
1787        Unspecified = 0,
1788        Range = 1,
1789    }
1790    impl CompactionMode {
1791        /// String value of the enum field names used in the ProtoBuf definition.
1792        ///
1793        /// The values are not transformed in any way and thus are considered stable
1794        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1795        pub fn as_str_name(&self) -> &'static str {
1796            match self {
1797                Self::Unspecified => "UNSPECIFIED",
1798                Self::Range => "RANGE",
1799            }
1800        }
1801        /// Creates an enum from field names used in the ProtoBuf definition.
1802        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1803            match value {
1804                "UNSPECIFIED" => Some(Self::Unspecified),
1805                "RANGE" => Some(Self::Range),
1806                _ => None,
1807            }
1808        }
1809    }
1810}
1811#[derive(prost_helpers::AnyPB)]
1812#[derive(Eq)]
1813#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1814pub struct TableStats {
1815    #[prost(int64, tag = "1")]
1816    pub total_key_size: i64,
1817    #[prost(int64, tag = "2")]
1818    pub total_value_size: i64,
1819    #[prost(int64, tag = "3")]
1820    pub total_key_count: i64,
1821    /// `total_compressed_size`` represents the size that the table takes up in the output sst
1822    ///   and this field is only filled and used by CN flushes, not compactor compaction
1823    #[prost(uint64, tag = "4")]
1824    pub total_compressed_size: u64,
1825}
1826#[derive(prost_helpers::AnyPB)]
1827#[derive(Clone, PartialEq, ::prost::Message)]
1828pub struct HummockVersionStats {
1829    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockVersionId")]
1830    pub hummock_version_id: crate::id::HummockVersionId,
1831    #[prost(map = "uint32, message", tag = "2", wrapper = "crate::id::TableId")]
1832    pub table_stats: ::std::collections::HashMap<crate::id::TableId, TableStats>,
1833}
1834#[derive(prost_helpers::AnyPB)]
1835#[derive(Clone, PartialEq, ::prost::Message)]
1836pub struct WriteLimits {
1837    /// < compaction group id, write limit info >
1838    #[prost(
1839        map = "uint64, message",
1840        tag = "1",
1841        wrapper = "crate::id::CompactionGroupId"
1842    )]
1843    pub write_limits: ::std::collections::HashMap<
1844        crate::id::CompactionGroupId,
1845        write_limits::WriteLimit,
1846    >,
1847}
1848/// Nested message and enum types in `WriteLimits`.
1849pub mod write_limits {
1850    #[derive(prost_helpers::AnyPB)]
1851    #[derive(Clone, PartialEq, ::prost::Message)]
1852    pub struct WriteLimit {
1853        #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::TableId")]
1854        pub table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
1855        #[prost(string, tag = "2")]
1856        pub reason: ::prost::alloc::string::String,
1857    }
1858}
1859#[derive(prost_helpers::AnyPB)]
1860#[derive(Clone, PartialEq, ::prost::Message)]
1861pub struct BranchedObject {
1862    #[prost(uint64, tag = "1", wrapper = "crate::id::HummockSstableObjectId")]
1863    pub object_id: crate::id::HummockSstableObjectId,
1864    #[prost(uint64, repeated, tag = "2", wrapper = "crate::id::HummockSstableId")]
1865    pub sst_id: ::prost::alloc::vec::Vec<crate::id::HummockSstableId>,
1866    /// Compaction group id the SST belongs to.
1867    #[prost(uint64, tag = "3", wrapper = "crate::id::CompactionGroupId")]
1868    pub compaction_group_id: crate::id::CompactionGroupId,
1869}
1870#[derive(prost_helpers::AnyPB)]
1871#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1872#[repr(i32)]
1873pub enum BloomFilterType {
1874    BloomFilterUnspecified = 0,
1875    Sstable = 1,
1876    Blocked = 2,
1877}
1878impl BloomFilterType {
1879    /// String value of the enum field names used in the ProtoBuf definition.
1880    ///
1881    /// The values are not transformed in any way and thus are considered stable
1882    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1883    pub fn as_str_name(&self) -> &'static str {
1884        match self {
1885            Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
1886            Self::Sstable => "SSTABLE",
1887            Self::Blocked => "BLOCKED",
1888        }
1889    }
1890    /// Creates an enum from field names used in the ProtoBuf definition.
1891    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1892        match value {
1893            "BLOOM_FILTER_UNSPECIFIED" => Some(Self::BloomFilterUnspecified),
1894            "SSTABLE" => Some(Self::Sstable),
1895            "BLOCKED" => Some(Self::Blocked),
1896            _ => None,
1897        }
1898    }
1899}
1900#[derive(prost_helpers::AnyPB)]
1901#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1902#[repr(i32)]
1903pub enum LevelType {
1904    Unspecified = 0,
1905    Nonoverlapping = 1,
1906    Overlapping = 2,
1907}
1908impl LevelType {
1909    /// String value of the enum field names used in the ProtoBuf definition.
1910    ///
1911    /// The values are not transformed in any way and thus are considered stable
1912    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1913    pub fn as_str_name(&self) -> &'static str {
1914        match self {
1915            Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
1916            Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
1917            Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
1918        }
1919    }
1920    /// Creates an enum from field names used in the ProtoBuf definition.
1921    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1922        match value {
1923            "LEVEL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
1924            "LEVEL_TYPE_NONOVERLAPPING" => Some(Self::Nonoverlapping),
1925            "LEVEL_TYPE_OVERLAPPING" => Some(Self::Overlapping),
1926            _ => None,
1927        }
1928    }
1929}
1930#[derive(prost_helpers::AnyPB)]
1931#[derive(prost_helpers::Version)]
1932#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1933#[repr(i32)]
1934pub enum CompatibilityVersion {
1935    VersionUnspecified = 0,
1936    NoTrivialSplit = 1,
1937    NoMemberTableIds = 2,
1938    SplitGroupByTableId = 3,
1939}
1940impl CompatibilityVersion {
1941    /// String value of the enum field names used in the ProtoBuf definition.
1942    ///
1943    /// The values are not transformed in any way and thus are considered stable
1944    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1945    pub fn as_str_name(&self) -> &'static str {
1946        match self {
1947            Self::VersionUnspecified => "VERSION_UNSPECIFIED",
1948            Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
1949            Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
1950            Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
1951        }
1952    }
1953    /// Creates an enum from field names used in the ProtoBuf definition.
1954    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1955        match value {
1956            "VERSION_UNSPECIFIED" => Some(Self::VersionUnspecified),
1957            "NO_TRIVIAL_SPLIT" => Some(Self::NoTrivialSplit),
1958            "NO_MEMBER_TABLE_IDS" => Some(Self::NoMemberTableIds),
1959            "SPLIT_GROUP_BY_TABLE_ID" => Some(Self::SplitGroupByTableId),
1960            _ => None,
1961        }
1962    }
1963}
1964#[derive(prost_helpers::AnyPB)]
1965#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1966#[repr(i32)]
1967pub enum WatermarkSerdeType {
1968    TypeUnspecified = 0,
1969    PkPrefix = 1,
1970    NonPkPrefix = 2,
1971    Value = 3,
1972}
1973impl WatermarkSerdeType {
1974    /// String value of the enum field names used in the ProtoBuf definition.
1975    ///
1976    /// The values are not transformed in any way and thus are considered stable
1977    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1978    pub fn as_str_name(&self) -> &'static str {
1979        match self {
1980            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1981            Self::PkPrefix => "PK_PREFIX",
1982            Self::NonPkPrefix => "NON_PK_PREFIX",
1983            Self::Value => "VALUE",
1984        }
1985    }
1986    /// Creates an enum from field names used in the ProtoBuf definition.
1987    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1988        match value {
1989            "TYPE_UNSPECIFIED" => Some(Self::TypeUnspecified),
1990            "PK_PREFIX" => Some(Self::PkPrefix),
1991            "NON_PK_PREFIX" => Some(Self::NonPkPrefix),
1992            "VALUE" => Some(Self::Value),
1993            _ => None,
1994        }
1995    }
1996}
1997#[derive(prost_helpers::AnyPB)]
1998#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1999#[repr(i32)]
2000pub enum VectorIndexObjectType {
2001    VectorIndexObjectUnspecified = 0,
2002    VectorIndexObjectVector = 1,
2003    VectorIndexObjectHnswGraph = 2,
2004}
2005impl VectorIndexObjectType {
2006    /// String value of the enum field names used in the ProtoBuf definition.
2007    ///
2008    /// The values are not transformed in any way and thus are considered stable
2009    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2010    pub fn as_str_name(&self) -> &'static str {
2011        match self {
2012            Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
2013            Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
2014            Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
2015        }
2016    }
2017    /// Creates an enum from field names used in the ProtoBuf definition.
2018    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2019        match value {
2020            "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Some(Self::VectorIndexObjectUnspecified),
2021            "VECTOR_INDEX_OBJECT_VECTOR" => Some(Self::VectorIndexObjectVector),
2022            "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Some(Self::VectorIndexObjectHnswGraph),
2023            _ => None,
2024        }
2025    }
2026}
2027/// Generated client implementations.
2028pub mod hummock_manager_service_client {
2029    #![allow(
2030        unused_variables,
2031        dead_code,
2032        missing_docs,
2033        clippy::wildcard_imports,
2034        clippy::let_unit_value,
2035    )]
2036    use tonic::codegen::*;
2037    use tonic::codegen::http::Uri;
2038    #[derive(Debug, Clone)]
2039    pub struct HummockManagerServiceClient<T> {
2040        inner: tonic::client::Grpc<T>,
2041    }
2042    impl HummockManagerServiceClient<tonic::transport::Channel> {
2043        /// Attempt to create a new client by connecting to a given endpoint.
2044        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
2045        where
2046            D: TryInto<tonic::transport::Endpoint>,
2047            D::Error: Into<StdError>,
2048        {
2049            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
2050            Ok(Self::new(conn))
2051        }
2052    }
2053    impl<T> HummockManagerServiceClient<T>
2054    where
2055        T: tonic::client::GrpcService<tonic::body::BoxBody>,
2056        T::Error: Into<StdError>,
2057        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
2058        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
2059    {
2060        pub fn new(inner: T) -> Self {
2061            let inner = tonic::client::Grpc::new(inner);
2062            Self { inner }
2063        }
2064        pub fn with_origin(inner: T, origin: Uri) -> Self {
2065            let inner = tonic::client::Grpc::with_origin(inner, origin);
2066            Self { inner }
2067        }
2068        pub fn with_interceptor<F>(
2069            inner: T,
2070            interceptor: F,
2071        ) -> HummockManagerServiceClient<InterceptedService<T, F>>
2072        where
2073            F: tonic::service::Interceptor,
2074            T::ResponseBody: Default,
2075            T: tonic::codegen::Service<
2076                http::Request<tonic::body::BoxBody>,
2077                Response = http::Response<
2078                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
2079                >,
2080            >,
2081            <T as tonic::codegen::Service<
2082                http::Request<tonic::body::BoxBody>,
2083            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2084        {
2085            HummockManagerServiceClient::new(InterceptedService::new(inner, interceptor))
2086        }
2087        /// Compress requests with the given encoding.
2088        ///
2089        /// This requires the server to support it otherwise it might respond with an
2090        /// error.
2091        #[must_use]
2092        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2093            self.inner = self.inner.send_compressed(encoding);
2094            self
2095        }
2096        /// Enable decompressing responses.
2097        #[must_use]
2098        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2099            self.inner = self.inner.accept_compressed(encoding);
2100            self
2101        }
2102        /// Limits the maximum size of a decoded message.
2103        ///
2104        /// Default: `4MB`
2105        #[must_use]
2106        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2107            self.inner = self.inner.max_decoding_message_size(limit);
2108            self
2109        }
2110        /// Limits the maximum size of an encoded message.
2111        ///
2112        /// Default: `usize::MAX`
2113        #[must_use]
2114        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2115            self.inner = self.inner.max_encoding_message_size(limit);
2116            self
2117        }
2118        pub async fn unpin_version_before(
2119            &mut self,
2120            request: impl tonic::IntoRequest<super::UnpinVersionBeforeRequest>,
2121        ) -> std::result::Result<
2122            tonic::Response<super::UnpinVersionBeforeResponse>,
2123            tonic::Status,
2124        > {
2125            self.inner
2126                .ready()
2127                .await
2128                .map_err(|e| {
2129                    tonic::Status::unknown(
2130                        format!("Service was not ready: {}", e.into()),
2131                    )
2132                })?;
2133            let codec = tonic::codec::ProstCodec::default();
2134            let path = http::uri::PathAndQuery::from_static(
2135                "/hummock.HummockManagerService/UnpinVersionBefore",
2136            );
2137            let mut req = request.into_request();
2138            req.extensions_mut()
2139                .insert(
2140                    GrpcMethod::new(
2141                        "hummock.HummockManagerService",
2142                        "UnpinVersionBefore",
2143                    ),
2144                );
2145            self.inner.unary(req, path, codec).await
2146        }
2147        pub async fn get_current_version(
2148            &mut self,
2149            request: impl tonic::IntoRequest<super::GetCurrentVersionRequest>,
2150        ) -> std::result::Result<
2151            tonic::Response<super::GetCurrentVersionResponse>,
2152            tonic::Status,
2153        > {
2154            self.inner
2155                .ready()
2156                .await
2157                .map_err(|e| {
2158                    tonic::Status::unknown(
2159                        format!("Service was not ready: {}", e.into()),
2160                    )
2161                })?;
2162            let codec = tonic::codec::ProstCodec::default();
2163            let path = http::uri::PathAndQuery::from_static(
2164                "/hummock.HummockManagerService/GetCurrentVersion",
2165            );
2166            let mut req = request.into_request();
2167            req.extensions_mut()
2168                .insert(
2169                    GrpcMethod::new("hummock.HummockManagerService", "GetCurrentVersion"),
2170                );
2171            self.inner.unary(req, path, codec).await
2172        }
2173        pub async fn list_version_deltas(
2174            &mut self,
2175            request: impl tonic::IntoRequest<super::ListVersionDeltasRequest>,
2176        ) -> std::result::Result<
2177            tonic::Response<super::ListVersionDeltasResponse>,
2178            tonic::Status,
2179        > {
2180            self.inner
2181                .ready()
2182                .await
2183                .map_err(|e| {
2184                    tonic::Status::unknown(
2185                        format!("Service was not ready: {}", e.into()),
2186                    )
2187                })?;
2188            let codec = tonic::codec::ProstCodec::default();
2189            let path = http::uri::PathAndQuery::from_static(
2190                "/hummock.HummockManagerService/ListVersionDeltas",
2191            );
2192            let mut req = request.into_request();
2193            req.extensions_mut()
2194                .insert(
2195                    GrpcMethod::new("hummock.HummockManagerService", "ListVersionDeltas"),
2196                );
2197            self.inner.unary(req, path, codec).await
2198        }
2199        pub async fn replay_version_delta(
2200            &mut self,
2201            request: impl tonic::IntoRequest<super::ReplayVersionDeltaRequest>,
2202        ) -> std::result::Result<
2203            tonic::Response<super::ReplayVersionDeltaResponse>,
2204            tonic::Status,
2205        > {
2206            self.inner
2207                .ready()
2208                .await
2209                .map_err(|e| {
2210                    tonic::Status::unknown(
2211                        format!("Service was not ready: {}", e.into()),
2212                    )
2213                })?;
2214            let codec = tonic::codec::ProstCodec::default();
2215            let path = http::uri::PathAndQuery::from_static(
2216                "/hummock.HummockManagerService/ReplayVersionDelta",
2217            );
2218            let mut req = request.into_request();
2219            req.extensions_mut()
2220                .insert(
2221                    GrpcMethod::new(
2222                        "hummock.HummockManagerService",
2223                        "ReplayVersionDelta",
2224                    ),
2225                );
2226            self.inner.unary(req, path, codec).await
2227        }
2228        pub async fn get_assigned_compact_task_num(
2229            &mut self,
2230            request: impl tonic::IntoRequest<super::GetAssignedCompactTaskNumRequest>,
2231        ) -> std::result::Result<
2232            tonic::Response<super::GetAssignedCompactTaskNumResponse>,
2233            tonic::Status,
2234        > {
2235            self.inner
2236                .ready()
2237                .await
2238                .map_err(|e| {
2239                    tonic::Status::unknown(
2240                        format!("Service was not ready: {}", e.into()),
2241                    )
2242                })?;
2243            let codec = tonic::codec::ProstCodec::default();
2244            let path = http::uri::PathAndQuery::from_static(
2245                "/hummock.HummockManagerService/GetAssignedCompactTaskNum",
2246            );
2247            let mut req = request.into_request();
2248            req.extensions_mut()
2249                .insert(
2250                    GrpcMethod::new(
2251                        "hummock.HummockManagerService",
2252                        "GetAssignedCompactTaskNum",
2253                    ),
2254                );
2255            self.inner.unary(req, path, codec).await
2256        }
2257        pub async fn trigger_compaction_deterministic(
2258            &mut self,
2259            request: impl tonic::IntoRequest<
2260                super::TriggerCompactionDeterministicRequest,
2261            >,
2262        ) -> std::result::Result<
2263            tonic::Response<super::TriggerCompactionDeterministicResponse>,
2264            tonic::Status,
2265        > {
2266            self.inner
2267                .ready()
2268                .await
2269                .map_err(|e| {
2270                    tonic::Status::unknown(
2271                        format!("Service was not ready: {}", e.into()),
2272                    )
2273                })?;
2274            let codec = tonic::codec::ProstCodec::default();
2275            let path = http::uri::PathAndQuery::from_static(
2276                "/hummock.HummockManagerService/TriggerCompactionDeterministic",
2277            );
2278            let mut req = request.into_request();
2279            req.extensions_mut()
2280                .insert(
2281                    GrpcMethod::new(
2282                        "hummock.HummockManagerService",
2283                        "TriggerCompactionDeterministic",
2284                    ),
2285                );
2286            self.inner.unary(req, path, codec).await
2287        }
2288        pub async fn disable_commit_epoch(
2289            &mut self,
2290            request: impl tonic::IntoRequest<super::DisableCommitEpochRequest>,
2291        ) -> std::result::Result<
2292            tonic::Response<super::DisableCommitEpochResponse>,
2293            tonic::Status,
2294        > {
2295            self.inner
2296                .ready()
2297                .await
2298                .map_err(|e| {
2299                    tonic::Status::unknown(
2300                        format!("Service was not ready: {}", e.into()),
2301                    )
2302                })?;
2303            let codec = tonic::codec::ProstCodec::default();
2304            let path = http::uri::PathAndQuery::from_static(
2305                "/hummock.HummockManagerService/DisableCommitEpoch",
2306            );
2307            let mut req = request.into_request();
2308            req.extensions_mut()
2309                .insert(
2310                    GrpcMethod::new(
2311                        "hummock.HummockManagerService",
2312                        "DisableCommitEpoch",
2313                    ),
2314                );
2315            self.inner.unary(req, path, codec).await
2316        }
2317        pub async fn get_new_object_ids(
2318            &mut self,
2319            request: impl tonic::IntoRequest<super::GetNewObjectIdsRequest>,
2320        ) -> std::result::Result<
2321            tonic::Response<super::GetNewObjectIdsResponse>,
2322            tonic::Status,
2323        > {
2324            self.inner
2325                .ready()
2326                .await
2327                .map_err(|e| {
2328                    tonic::Status::unknown(
2329                        format!("Service was not ready: {}", e.into()),
2330                    )
2331                })?;
2332            let codec = tonic::codec::ProstCodec::default();
2333            let path = http::uri::PathAndQuery::from_static(
2334                "/hummock.HummockManagerService/GetNewObjectIds",
2335            );
2336            let mut req = request.into_request();
2337            req.extensions_mut()
2338                .insert(
2339                    GrpcMethod::new("hummock.HummockManagerService", "GetNewObjectIds"),
2340                );
2341            self.inner.unary(req, path, codec).await
2342        }
2343        pub async fn trigger_manual_compaction(
2344            &mut self,
2345            request: impl tonic::IntoRequest<super::TriggerManualCompactionRequest>,
2346        ) -> std::result::Result<
2347            tonic::Response<super::TriggerManualCompactionResponse>,
2348            tonic::Status,
2349        > {
2350            self.inner
2351                .ready()
2352                .await
2353                .map_err(|e| {
2354                    tonic::Status::unknown(
2355                        format!("Service was not ready: {}", e.into()),
2356                    )
2357                })?;
2358            let codec = tonic::codec::ProstCodec::default();
2359            let path = http::uri::PathAndQuery::from_static(
2360                "/hummock.HummockManagerService/TriggerManualCompaction",
2361            );
2362            let mut req = request.into_request();
2363            req.extensions_mut()
2364                .insert(
2365                    GrpcMethod::new(
2366                        "hummock.HummockManagerService",
2367                        "TriggerManualCompaction",
2368                    ),
2369                );
2370            self.inner.unary(req, path, codec).await
2371        }
2372        pub async fn trigger_full_gc(
2373            &mut self,
2374            request: impl tonic::IntoRequest<super::TriggerFullGcRequest>,
2375        ) -> std::result::Result<
2376            tonic::Response<super::TriggerFullGcResponse>,
2377            tonic::Status,
2378        > {
2379            self.inner
2380                .ready()
2381                .await
2382                .map_err(|e| {
2383                    tonic::Status::unknown(
2384                        format!("Service was not ready: {}", e.into()),
2385                    )
2386                })?;
2387            let codec = tonic::codec::ProstCodec::default();
2388            let path = http::uri::PathAndQuery::from_static(
2389                "/hummock.HummockManagerService/TriggerFullGC",
2390            );
2391            let mut req = request.into_request();
2392            req.extensions_mut()
2393                .insert(
2394                    GrpcMethod::new("hummock.HummockManagerService", "TriggerFullGC"),
2395                );
2396            self.inner.unary(req, path, codec).await
2397        }
2398        pub async fn rise_ctl_get_pinned_versions_summary(
2399            &mut self,
2400            request: impl tonic::IntoRequest<
2401                super::RiseCtlGetPinnedVersionsSummaryRequest,
2402            >,
2403        ) -> std::result::Result<
2404            tonic::Response<super::RiseCtlGetPinnedVersionsSummaryResponse>,
2405            tonic::Status,
2406        > {
2407            self.inner
2408                .ready()
2409                .await
2410                .map_err(|e| {
2411                    tonic::Status::unknown(
2412                        format!("Service was not ready: {}", e.into()),
2413                    )
2414                })?;
2415            let codec = tonic::codec::ProstCodec::default();
2416            let path = http::uri::PathAndQuery::from_static(
2417                "/hummock.HummockManagerService/RiseCtlGetPinnedVersionsSummary",
2418            );
2419            let mut req = request.into_request();
2420            req.extensions_mut()
2421                .insert(
2422                    GrpcMethod::new(
2423                        "hummock.HummockManagerService",
2424                        "RiseCtlGetPinnedVersionsSummary",
2425                    ),
2426                );
2427            self.inner.unary(req, path, codec).await
2428        }
2429        pub async fn rise_ctl_list_compaction_group(
2430            &mut self,
2431            request: impl tonic::IntoRequest<super::RiseCtlListCompactionGroupRequest>,
2432        ) -> std::result::Result<
2433            tonic::Response<super::RiseCtlListCompactionGroupResponse>,
2434            tonic::Status,
2435        > {
2436            self.inner
2437                .ready()
2438                .await
2439                .map_err(|e| {
2440                    tonic::Status::unknown(
2441                        format!("Service was not ready: {}", e.into()),
2442                    )
2443                })?;
2444            let codec = tonic::codec::ProstCodec::default();
2445            let path = http::uri::PathAndQuery::from_static(
2446                "/hummock.HummockManagerService/RiseCtlListCompactionGroup",
2447            );
2448            let mut req = request.into_request();
2449            req.extensions_mut()
2450                .insert(
2451                    GrpcMethod::new(
2452                        "hummock.HummockManagerService",
2453                        "RiseCtlListCompactionGroup",
2454                    ),
2455                );
2456            self.inner.unary(req, path, codec).await
2457        }
2458        pub async fn rise_ctl_update_compaction_config(
2459            &mut self,
2460            request: impl tonic::IntoRequest<super::RiseCtlUpdateCompactionConfigRequest>,
2461        ) -> std::result::Result<
2462            tonic::Response<super::RiseCtlUpdateCompactionConfigResponse>,
2463            tonic::Status,
2464        > {
2465            self.inner
2466                .ready()
2467                .await
2468                .map_err(|e| {
2469                    tonic::Status::unknown(
2470                        format!("Service was not ready: {}", e.into()),
2471                    )
2472                })?;
2473            let codec = tonic::codec::ProstCodec::default();
2474            let path = http::uri::PathAndQuery::from_static(
2475                "/hummock.HummockManagerService/RiseCtlUpdateCompactionConfig",
2476            );
2477            let mut req = request.into_request();
2478            req.extensions_mut()
2479                .insert(
2480                    GrpcMethod::new(
2481                        "hummock.HummockManagerService",
2482                        "RiseCtlUpdateCompactionConfig",
2483                    ),
2484                );
2485            self.inner.unary(req, path, codec).await
2486        }
2487        pub async fn rise_ctl_pause_version_checkpoint(
2488            &mut self,
2489            request: impl tonic::IntoRequest<super::RiseCtlPauseVersionCheckpointRequest>,
2490        ) -> std::result::Result<
2491            tonic::Response<super::RiseCtlPauseVersionCheckpointResponse>,
2492            tonic::Status,
2493        > {
2494            self.inner
2495                .ready()
2496                .await
2497                .map_err(|e| {
2498                    tonic::Status::unknown(
2499                        format!("Service was not ready: {}", e.into()),
2500                    )
2501                })?;
2502            let codec = tonic::codec::ProstCodec::default();
2503            let path = http::uri::PathAndQuery::from_static(
2504                "/hummock.HummockManagerService/RiseCtlPauseVersionCheckpoint",
2505            );
2506            let mut req = request.into_request();
2507            req.extensions_mut()
2508                .insert(
2509                    GrpcMethod::new(
2510                        "hummock.HummockManagerService",
2511                        "RiseCtlPauseVersionCheckpoint",
2512                    ),
2513                );
2514            self.inner.unary(req, path, codec).await
2515        }
2516        pub async fn rise_ctl_resume_version_checkpoint(
2517            &mut self,
2518            request: impl tonic::IntoRequest<
2519                super::RiseCtlResumeVersionCheckpointRequest,
2520            >,
2521        ) -> std::result::Result<
2522            tonic::Response<super::RiseCtlResumeVersionCheckpointResponse>,
2523            tonic::Status,
2524        > {
2525            self.inner
2526                .ready()
2527                .await
2528                .map_err(|e| {
2529                    tonic::Status::unknown(
2530                        format!("Service was not ready: {}", e.into()),
2531                    )
2532                })?;
2533            let codec = tonic::codec::ProstCodec::default();
2534            let path = http::uri::PathAndQuery::from_static(
2535                "/hummock.HummockManagerService/RiseCtlResumeVersionCheckpoint",
2536            );
2537            let mut req = request.into_request();
2538            req.extensions_mut()
2539                .insert(
2540                    GrpcMethod::new(
2541                        "hummock.HummockManagerService",
2542                        "RiseCtlResumeVersionCheckpoint",
2543                    ),
2544                );
2545            self.inner.unary(req, path, codec).await
2546        }
2547        pub async fn rise_ctl_get_checkpoint_version(
2548            &mut self,
2549            request: impl tonic::IntoRequest<super::RiseCtlGetCheckpointVersionRequest>,
2550        ) -> std::result::Result<
2551            tonic::Response<super::RiseCtlGetCheckpointVersionResponse>,
2552            tonic::Status,
2553        > {
2554            self.inner
2555                .ready()
2556                .await
2557                .map_err(|e| {
2558                    tonic::Status::unknown(
2559                        format!("Service was not ready: {}", e.into()),
2560                    )
2561                })?;
2562            let codec = tonic::codec::ProstCodec::default();
2563            let path = http::uri::PathAndQuery::from_static(
2564                "/hummock.HummockManagerService/RiseCtlGetCheckpointVersion",
2565            );
2566            let mut req = request.into_request();
2567            req.extensions_mut()
2568                .insert(
2569                    GrpcMethod::new(
2570                        "hummock.HummockManagerService",
2571                        "RiseCtlGetCheckpointVersion",
2572                    ),
2573                );
2574            self.inner.unary(req, path, codec).await
2575        }
2576        pub async fn rise_ctl_rebuild_table_stats(
2577            &mut self,
2578            request: impl tonic::IntoRequest<super::RiseCtlRebuildTableStatsRequest>,
2579        ) -> std::result::Result<
2580            tonic::Response<super::RiseCtlRebuildTableStatsResponse>,
2581            tonic::Status,
2582        > {
2583            self.inner
2584                .ready()
2585                .await
2586                .map_err(|e| {
2587                    tonic::Status::unknown(
2588                        format!("Service was not ready: {}", e.into()),
2589                    )
2590                })?;
2591            let codec = tonic::codec::ProstCodec::default();
2592            let path = http::uri::PathAndQuery::from_static(
2593                "/hummock.HummockManagerService/RiseCtlRebuildTableStats",
2594            );
2595            let mut req = request.into_request();
2596            req.extensions_mut()
2597                .insert(
2598                    GrpcMethod::new(
2599                        "hummock.HummockManagerService",
2600                        "RiseCtlRebuildTableStats",
2601                    ),
2602                );
2603            self.inner.unary(req, path, codec).await
2604        }
2605        pub async fn init_metadata_for_replay(
2606            &mut self,
2607            request: impl tonic::IntoRequest<super::InitMetadataForReplayRequest>,
2608        ) -> std::result::Result<
2609            tonic::Response<super::InitMetadataForReplayResponse>,
2610            tonic::Status,
2611        > {
2612            self.inner
2613                .ready()
2614                .await
2615                .map_err(|e| {
2616                    tonic::Status::unknown(
2617                        format!("Service was not ready: {}", e.into()),
2618                    )
2619                })?;
2620            let codec = tonic::codec::ProstCodec::default();
2621            let path = http::uri::PathAndQuery::from_static(
2622                "/hummock.HummockManagerService/InitMetadataForReplay",
2623            );
2624            let mut req = request.into_request();
2625            req.extensions_mut()
2626                .insert(
2627                    GrpcMethod::new(
2628                        "hummock.HummockManagerService",
2629                        "InitMetadataForReplay",
2630                    ),
2631                );
2632            self.inner.unary(req, path, codec).await
2633        }
2634        pub async fn pin_version(
2635            &mut self,
2636            request: impl tonic::IntoRequest<super::PinVersionRequest>,
2637        ) -> std::result::Result<
2638            tonic::Response<super::PinVersionResponse>,
2639            tonic::Status,
2640        > {
2641            self.inner
2642                .ready()
2643                .await
2644                .map_err(|e| {
2645                    tonic::Status::unknown(
2646                        format!("Service was not ready: {}", e.into()),
2647                    )
2648                })?;
2649            let codec = tonic::codec::ProstCodec::default();
2650            let path = http::uri::PathAndQuery::from_static(
2651                "/hummock.HummockManagerService/PinVersion",
2652            );
2653            let mut req = request.into_request();
2654            req.extensions_mut()
2655                .insert(GrpcMethod::new("hummock.HummockManagerService", "PinVersion"));
2656            self.inner.unary(req, path, codec).await
2657        }
2658        pub async fn split_compaction_group(
2659            &mut self,
2660            request: impl tonic::IntoRequest<super::SplitCompactionGroupRequest>,
2661        ) -> std::result::Result<
2662            tonic::Response<super::SplitCompactionGroupResponse>,
2663            tonic::Status,
2664        > {
2665            self.inner
2666                .ready()
2667                .await
2668                .map_err(|e| {
2669                    tonic::Status::unknown(
2670                        format!("Service was not ready: {}", e.into()),
2671                    )
2672                })?;
2673            let codec = tonic::codec::ProstCodec::default();
2674            let path = http::uri::PathAndQuery::from_static(
2675                "/hummock.HummockManagerService/SplitCompactionGroup",
2676            );
2677            let mut req = request.into_request();
2678            req.extensions_mut()
2679                .insert(
2680                    GrpcMethod::new(
2681                        "hummock.HummockManagerService",
2682                        "SplitCompactionGroup",
2683                    ),
2684                );
2685            self.inner.unary(req, path, codec).await
2686        }
2687        pub async fn rise_ctl_list_compaction_status(
2688            &mut self,
2689            request: impl tonic::IntoRequest<super::RiseCtlListCompactionStatusRequest>,
2690        ) -> std::result::Result<
2691            tonic::Response<super::RiseCtlListCompactionStatusResponse>,
2692            tonic::Status,
2693        > {
2694            self.inner
2695                .ready()
2696                .await
2697                .map_err(|e| {
2698                    tonic::Status::unknown(
2699                        format!("Service was not ready: {}", e.into()),
2700                    )
2701                })?;
2702            let codec = tonic::codec::ProstCodec::default();
2703            let path = http::uri::PathAndQuery::from_static(
2704                "/hummock.HummockManagerService/RiseCtlListCompactionStatus",
2705            );
2706            let mut req = request.into_request();
2707            req.extensions_mut()
2708                .insert(
2709                    GrpcMethod::new(
2710                        "hummock.HummockManagerService",
2711                        "RiseCtlListCompactionStatus",
2712                    ),
2713                );
2714            self.inner.unary(req, path, codec).await
2715        }
2716        pub async fn subscribe_compaction_event(
2717            &mut self,
2718            request: impl tonic::IntoStreamingRequest<
2719                Message = super::SubscribeCompactionEventRequest,
2720            >,
2721        ) -> std::result::Result<
2722            tonic::Response<
2723                tonic::codec::Streaming<super::SubscribeCompactionEventResponse>,
2724            >,
2725            tonic::Status,
2726        > {
2727            self.inner
2728                .ready()
2729                .await
2730                .map_err(|e| {
2731                    tonic::Status::unknown(
2732                        format!("Service was not ready: {}", e.into()),
2733                    )
2734                })?;
2735            let codec = tonic::codec::ProstCodec::default();
2736            let path = http::uri::PathAndQuery::from_static(
2737                "/hummock.HummockManagerService/SubscribeCompactionEvent",
2738            );
2739            let mut req = request.into_streaming_request();
2740            req.extensions_mut()
2741                .insert(
2742                    GrpcMethod::new(
2743                        "hummock.HummockManagerService",
2744                        "SubscribeCompactionEvent",
2745                    ),
2746                );
2747            self.inner.streaming(req, path, codec).await
2748        }
2749        pub async fn report_compaction_task(
2750            &mut self,
2751            request: impl tonic::IntoRequest<super::ReportCompactionTaskRequest>,
2752        ) -> std::result::Result<
2753            tonic::Response<super::ReportCompactionTaskResponse>,
2754            tonic::Status,
2755        > {
2756            self.inner
2757                .ready()
2758                .await
2759                .map_err(|e| {
2760                    tonic::Status::unknown(
2761                        format!("Service was not ready: {}", e.into()),
2762                    )
2763                })?;
2764            let codec = tonic::codec::ProstCodec::default();
2765            let path = http::uri::PathAndQuery::from_static(
2766                "/hummock.HummockManagerService/ReportCompactionTask",
2767            );
2768            let mut req = request.into_request();
2769            req.extensions_mut()
2770                .insert(
2771                    GrpcMethod::new(
2772                        "hummock.HummockManagerService",
2773                        "ReportCompactionTask",
2774                    ),
2775                );
2776            self.inner.unary(req, path, codec).await
2777        }
2778        pub async fn list_branched_object(
2779            &mut self,
2780            request: impl tonic::IntoRequest<super::ListBranchedObjectRequest>,
2781        ) -> std::result::Result<
2782            tonic::Response<super::ListBranchedObjectResponse>,
2783            tonic::Status,
2784        > {
2785            self.inner
2786                .ready()
2787                .await
2788                .map_err(|e| {
2789                    tonic::Status::unknown(
2790                        format!("Service was not ready: {}", e.into()),
2791                    )
2792                })?;
2793            let codec = tonic::codec::ProstCodec::default();
2794            let path = http::uri::PathAndQuery::from_static(
2795                "/hummock.HummockManagerService/ListBranchedObject",
2796            );
2797            let mut req = request.into_request();
2798            req.extensions_mut()
2799                .insert(
2800                    GrpcMethod::new(
2801                        "hummock.HummockManagerService",
2802                        "ListBranchedObject",
2803                    ),
2804                );
2805            self.inner.unary(req, path, codec).await
2806        }
2807        pub async fn list_active_write_limit(
2808            &mut self,
2809            request: impl tonic::IntoRequest<super::ListActiveWriteLimitRequest>,
2810        ) -> std::result::Result<
2811            tonic::Response<super::ListActiveWriteLimitResponse>,
2812            tonic::Status,
2813        > {
2814            self.inner
2815                .ready()
2816                .await
2817                .map_err(|e| {
2818                    tonic::Status::unknown(
2819                        format!("Service was not ready: {}", e.into()),
2820                    )
2821                })?;
2822            let codec = tonic::codec::ProstCodec::default();
2823            let path = http::uri::PathAndQuery::from_static(
2824                "/hummock.HummockManagerService/ListActiveWriteLimit",
2825            );
2826            let mut req = request.into_request();
2827            req.extensions_mut()
2828                .insert(
2829                    GrpcMethod::new(
2830                        "hummock.HummockManagerService",
2831                        "ListActiveWriteLimit",
2832                    ),
2833                );
2834            self.inner.unary(req, path, codec).await
2835        }
2836        pub async fn list_hummock_meta_config(
2837            &mut self,
2838            request: impl tonic::IntoRequest<super::ListHummockMetaConfigRequest>,
2839        ) -> std::result::Result<
2840            tonic::Response<super::ListHummockMetaConfigResponse>,
2841            tonic::Status,
2842        > {
2843            self.inner
2844                .ready()
2845                .await
2846                .map_err(|e| {
2847                    tonic::Status::unknown(
2848                        format!("Service was not ready: {}", e.into()),
2849                    )
2850                })?;
2851            let codec = tonic::codec::ProstCodec::default();
2852            let path = http::uri::PathAndQuery::from_static(
2853                "/hummock.HummockManagerService/ListHummockMetaConfig",
2854            );
2855            let mut req = request.into_request();
2856            req.extensions_mut()
2857                .insert(
2858                    GrpcMethod::new(
2859                        "hummock.HummockManagerService",
2860                        "ListHummockMetaConfig",
2861                    ),
2862                );
2863            self.inner.unary(req, path, codec).await
2864        }
2865        pub async fn get_compaction_score(
2866            &mut self,
2867            request: impl tonic::IntoRequest<super::GetCompactionScoreRequest>,
2868        ) -> std::result::Result<
2869            tonic::Response<super::GetCompactionScoreResponse>,
2870            tonic::Status,
2871        > {
2872            self.inner
2873                .ready()
2874                .await
2875                .map_err(|e| {
2876                    tonic::Status::unknown(
2877                        format!("Service was not ready: {}", e.into()),
2878                    )
2879                })?;
2880            let codec = tonic::codec::ProstCodec::default();
2881            let path = http::uri::PathAndQuery::from_static(
2882                "/hummock.HummockManagerService/GetCompactionScore",
2883            );
2884            let mut req = request.into_request();
2885            req.extensions_mut()
2886                .insert(
2887                    GrpcMethod::new(
2888                        "hummock.HummockManagerService",
2889                        "GetCompactionScore",
2890                    ),
2891                );
2892            self.inner.unary(req, path, codec).await
2893        }
2894        pub async fn list_compact_task_assignment(
2895            &mut self,
2896            request: impl tonic::IntoRequest<super::ListCompactTaskAssignmentRequest>,
2897        ) -> std::result::Result<
2898            tonic::Response<super::ListCompactTaskAssignmentResponse>,
2899            tonic::Status,
2900        > {
2901            self.inner
2902                .ready()
2903                .await
2904                .map_err(|e| {
2905                    tonic::Status::unknown(
2906                        format!("Service was not ready: {}", e.into()),
2907                    )
2908                })?;
2909            let codec = tonic::codec::ProstCodec::default();
2910            let path = http::uri::PathAndQuery::from_static(
2911                "/hummock.HummockManagerService/ListCompactTaskAssignment",
2912            );
2913            let mut req = request.into_request();
2914            req.extensions_mut()
2915                .insert(
2916                    GrpcMethod::new(
2917                        "hummock.HummockManagerService",
2918                        "ListCompactTaskAssignment",
2919                    ),
2920                );
2921            self.inner.unary(req, path, codec).await
2922        }
2923        pub async fn list_compact_task_progress(
2924            &mut self,
2925            request: impl tonic::IntoRequest<super::ListCompactTaskProgressRequest>,
2926        ) -> std::result::Result<
2927            tonic::Response<super::ListCompactTaskProgressResponse>,
2928            tonic::Status,
2929        > {
2930            self.inner
2931                .ready()
2932                .await
2933                .map_err(|e| {
2934                    tonic::Status::unknown(
2935                        format!("Service was not ready: {}", e.into()),
2936                    )
2937                })?;
2938            let codec = tonic::codec::ProstCodec::default();
2939            let path = http::uri::PathAndQuery::from_static(
2940                "/hummock.HummockManagerService/ListCompactTaskProgress",
2941            );
2942            let mut req = request.into_request();
2943            req.extensions_mut()
2944                .insert(
2945                    GrpcMethod::new(
2946                        "hummock.HummockManagerService",
2947                        "ListCompactTaskProgress",
2948                    ),
2949                );
2950            self.inner.unary(req, path, codec).await
2951        }
2952        pub async fn cancel_compact_task(
2953            &mut self,
2954            request: impl tonic::IntoRequest<super::CancelCompactTaskRequest>,
2955        ) -> std::result::Result<
2956            tonic::Response<super::CancelCompactTaskResponse>,
2957            tonic::Status,
2958        > {
2959            self.inner
2960                .ready()
2961                .await
2962                .map_err(|e| {
2963                    tonic::Status::unknown(
2964                        format!("Service was not ready: {}", e.into()),
2965                    )
2966                })?;
2967            let codec = tonic::codec::ProstCodec::default();
2968            let path = http::uri::PathAndQuery::from_static(
2969                "/hummock.HummockManagerService/CancelCompactTask",
2970            );
2971            let mut req = request.into_request();
2972            req.extensions_mut()
2973                .insert(
2974                    GrpcMethod::new("hummock.HummockManagerService", "CancelCompactTask"),
2975                );
2976            self.inner.unary(req, path, codec).await
2977        }
2978        pub async fn get_version_by_epoch(
2979            &mut self,
2980            request: impl tonic::IntoRequest<super::GetVersionByEpochRequest>,
2981        ) -> std::result::Result<
2982            tonic::Response<super::GetVersionByEpochResponse>,
2983            tonic::Status,
2984        > {
2985            self.inner
2986                .ready()
2987                .await
2988                .map_err(|e| {
2989                    tonic::Status::unknown(
2990                        format!("Service was not ready: {}", e.into()),
2991                    )
2992                })?;
2993            let codec = tonic::codec::ProstCodec::default();
2994            let path = http::uri::PathAndQuery::from_static(
2995                "/hummock.HummockManagerService/GetVersionByEpoch",
2996            );
2997            let mut req = request.into_request();
2998            req.extensions_mut()
2999                .insert(
3000                    GrpcMethod::new("hummock.HummockManagerService", "GetVersionByEpoch"),
3001                );
3002            self.inner.unary(req, path, codec).await
3003        }
3004        pub async fn merge_compaction_group(
3005            &mut self,
3006            request: impl tonic::IntoRequest<super::MergeCompactionGroupRequest>,
3007        ) -> std::result::Result<
3008            tonic::Response<super::MergeCompactionGroupResponse>,
3009            tonic::Status,
3010        > {
3011            self.inner
3012                .ready()
3013                .await
3014                .map_err(|e| {
3015                    tonic::Status::unknown(
3016                        format!("Service was not ready: {}", e.into()),
3017                    )
3018                })?;
3019            let codec = tonic::codec::ProstCodec::default();
3020            let path = http::uri::PathAndQuery::from_static(
3021                "/hummock.HummockManagerService/MergeCompactionGroup",
3022            );
3023            let mut req = request.into_request();
3024            req.extensions_mut()
3025                .insert(
3026                    GrpcMethod::new(
3027                        "hummock.HummockManagerService",
3028                        "MergeCompactionGroup",
3029                    ),
3030                );
3031            self.inner.unary(req, path, codec).await
3032        }
3033        /// iceberg
3034        pub async fn subscribe_iceberg_compaction_event(
3035            &mut self,
3036            request: impl tonic::IntoStreamingRequest<
3037                Message = super::super::iceberg_compaction::SubscribeIcebergCompactionEventRequest,
3038            >,
3039        ) -> std::result::Result<
3040            tonic::Response<
3041                tonic::codec::Streaming<
3042                    super::super::iceberg_compaction::SubscribeIcebergCompactionEventResponse,
3043                >,
3044            >,
3045            tonic::Status,
3046        > {
3047            self.inner
3048                .ready()
3049                .await
3050                .map_err(|e| {
3051                    tonic::Status::unknown(
3052                        format!("Service was not ready: {}", e.into()),
3053                    )
3054                })?;
3055            let codec = tonic::codec::ProstCodec::default();
3056            let path = http::uri::PathAndQuery::from_static(
3057                "/hummock.HummockManagerService/SubscribeIcebergCompactionEvent",
3058            );
3059            let mut req = request.into_streaming_request();
3060            req.extensions_mut()
3061                .insert(
3062                    GrpcMethod::new(
3063                        "hummock.HummockManagerService",
3064                        "SubscribeIcebergCompactionEvent",
3065                    ),
3066                );
3067            self.inner.streaming(req, path, codec).await
3068        }
3069    }
3070}
3071/// Generated server implementations.
3072pub mod hummock_manager_service_server {
3073    #![allow(
3074        unused_variables,
3075        dead_code,
3076        missing_docs,
3077        clippy::wildcard_imports,
3078        clippy::let_unit_value,
3079    )]
3080    use tonic::codegen::*;
3081    /// Generated trait containing gRPC methods that should be implemented for use with HummockManagerServiceServer.
3082    #[async_trait]
3083    pub trait HummockManagerService: std::marker::Send + std::marker::Sync + 'static {
3084        async fn unpin_version_before(
3085            &self,
3086            request: tonic::Request<super::UnpinVersionBeforeRequest>,
3087        ) -> std::result::Result<
3088            tonic::Response<super::UnpinVersionBeforeResponse>,
3089            tonic::Status,
3090        >;
3091        async fn get_current_version(
3092            &self,
3093            request: tonic::Request<super::GetCurrentVersionRequest>,
3094        ) -> std::result::Result<
3095            tonic::Response<super::GetCurrentVersionResponse>,
3096            tonic::Status,
3097        >;
3098        async fn list_version_deltas(
3099            &self,
3100            request: tonic::Request<super::ListVersionDeltasRequest>,
3101        ) -> std::result::Result<
3102            tonic::Response<super::ListVersionDeltasResponse>,
3103            tonic::Status,
3104        >;
3105        async fn replay_version_delta(
3106            &self,
3107            request: tonic::Request<super::ReplayVersionDeltaRequest>,
3108        ) -> std::result::Result<
3109            tonic::Response<super::ReplayVersionDeltaResponse>,
3110            tonic::Status,
3111        >;
3112        async fn get_assigned_compact_task_num(
3113            &self,
3114            request: tonic::Request<super::GetAssignedCompactTaskNumRequest>,
3115        ) -> std::result::Result<
3116            tonic::Response<super::GetAssignedCompactTaskNumResponse>,
3117            tonic::Status,
3118        >;
3119        async fn trigger_compaction_deterministic(
3120            &self,
3121            request: tonic::Request<super::TriggerCompactionDeterministicRequest>,
3122        ) -> std::result::Result<
3123            tonic::Response<super::TriggerCompactionDeterministicResponse>,
3124            tonic::Status,
3125        >;
3126        async fn disable_commit_epoch(
3127            &self,
3128            request: tonic::Request<super::DisableCommitEpochRequest>,
3129        ) -> std::result::Result<
3130            tonic::Response<super::DisableCommitEpochResponse>,
3131            tonic::Status,
3132        >;
3133        async fn get_new_object_ids(
3134            &self,
3135            request: tonic::Request<super::GetNewObjectIdsRequest>,
3136        ) -> std::result::Result<
3137            tonic::Response<super::GetNewObjectIdsResponse>,
3138            tonic::Status,
3139        >;
3140        async fn trigger_manual_compaction(
3141            &self,
3142            request: tonic::Request<super::TriggerManualCompactionRequest>,
3143        ) -> std::result::Result<
3144            tonic::Response<super::TriggerManualCompactionResponse>,
3145            tonic::Status,
3146        >;
3147        async fn trigger_full_gc(
3148            &self,
3149            request: tonic::Request<super::TriggerFullGcRequest>,
3150        ) -> std::result::Result<
3151            tonic::Response<super::TriggerFullGcResponse>,
3152            tonic::Status,
3153        >;
3154        async fn rise_ctl_get_pinned_versions_summary(
3155            &self,
3156            request: tonic::Request<super::RiseCtlGetPinnedVersionsSummaryRequest>,
3157        ) -> std::result::Result<
3158            tonic::Response<super::RiseCtlGetPinnedVersionsSummaryResponse>,
3159            tonic::Status,
3160        >;
3161        async fn rise_ctl_list_compaction_group(
3162            &self,
3163            request: tonic::Request<super::RiseCtlListCompactionGroupRequest>,
3164        ) -> std::result::Result<
3165            tonic::Response<super::RiseCtlListCompactionGroupResponse>,
3166            tonic::Status,
3167        >;
3168        async fn rise_ctl_update_compaction_config(
3169            &self,
3170            request: tonic::Request<super::RiseCtlUpdateCompactionConfigRequest>,
3171        ) -> std::result::Result<
3172            tonic::Response<super::RiseCtlUpdateCompactionConfigResponse>,
3173            tonic::Status,
3174        >;
3175        async fn rise_ctl_pause_version_checkpoint(
3176            &self,
3177            request: tonic::Request<super::RiseCtlPauseVersionCheckpointRequest>,
3178        ) -> std::result::Result<
3179            tonic::Response<super::RiseCtlPauseVersionCheckpointResponse>,
3180            tonic::Status,
3181        >;
3182        async fn rise_ctl_resume_version_checkpoint(
3183            &self,
3184            request: tonic::Request<super::RiseCtlResumeVersionCheckpointRequest>,
3185        ) -> std::result::Result<
3186            tonic::Response<super::RiseCtlResumeVersionCheckpointResponse>,
3187            tonic::Status,
3188        >;
3189        async fn rise_ctl_get_checkpoint_version(
3190            &self,
3191            request: tonic::Request<super::RiseCtlGetCheckpointVersionRequest>,
3192        ) -> std::result::Result<
3193            tonic::Response<super::RiseCtlGetCheckpointVersionResponse>,
3194            tonic::Status,
3195        >;
3196        async fn rise_ctl_rebuild_table_stats(
3197            &self,
3198            request: tonic::Request<super::RiseCtlRebuildTableStatsRequest>,
3199        ) -> std::result::Result<
3200            tonic::Response<super::RiseCtlRebuildTableStatsResponse>,
3201            tonic::Status,
3202        >;
3203        async fn init_metadata_for_replay(
3204            &self,
3205            request: tonic::Request<super::InitMetadataForReplayRequest>,
3206        ) -> std::result::Result<
3207            tonic::Response<super::InitMetadataForReplayResponse>,
3208            tonic::Status,
3209        >;
3210        async fn pin_version(
3211            &self,
3212            request: tonic::Request<super::PinVersionRequest>,
3213        ) -> std::result::Result<
3214            tonic::Response<super::PinVersionResponse>,
3215            tonic::Status,
3216        >;
3217        async fn split_compaction_group(
3218            &self,
3219            request: tonic::Request<super::SplitCompactionGroupRequest>,
3220        ) -> std::result::Result<
3221            tonic::Response<super::SplitCompactionGroupResponse>,
3222            tonic::Status,
3223        >;
3224        async fn rise_ctl_list_compaction_status(
3225            &self,
3226            request: tonic::Request<super::RiseCtlListCompactionStatusRequest>,
3227        ) -> std::result::Result<
3228            tonic::Response<super::RiseCtlListCompactionStatusResponse>,
3229            tonic::Status,
3230        >;
3231        /// Server streaming response type for the SubscribeCompactionEvent method.
3232        type SubscribeCompactionEventStream: tonic::codegen::tokio_stream::Stream<
3233                Item = std::result::Result<
3234                    super::SubscribeCompactionEventResponse,
3235                    tonic::Status,
3236                >,
3237            >
3238            + std::marker::Send
3239            + 'static;
3240        async fn subscribe_compaction_event(
3241            &self,
3242            request: tonic::Request<
3243                tonic::Streaming<super::SubscribeCompactionEventRequest>,
3244            >,
3245        ) -> std::result::Result<
3246            tonic::Response<Self::SubscribeCompactionEventStream>,
3247            tonic::Status,
3248        >;
3249        async fn report_compaction_task(
3250            &self,
3251            request: tonic::Request<super::ReportCompactionTaskRequest>,
3252        ) -> std::result::Result<
3253            tonic::Response<super::ReportCompactionTaskResponse>,
3254            tonic::Status,
3255        >;
3256        async fn list_branched_object(
3257            &self,
3258            request: tonic::Request<super::ListBranchedObjectRequest>,
3259        ) -> std::result::Result<
3260            tonic::Response<super::ListBranchedObjectResponse>,
3261            tonic::Status,
3262        >;
3263        async fn list_active_write_limit(
3264            &self,
3265            request: tonic::Request<super::ListActiveWriteLimitRequest>,
3266        ) -> std::result::Result<
3267            tonic::Response<super::ListActiveWriteLimitResponse>,
3268            tonic::Status,
3269        >;
3270        async fn list_hummock_meta_config(
3271            &self,
3272            request: tonic::Request<super::ListHummockMetaConfigRequest>,
3273        ) -> std::result::Result<
3274            tonic::Response<super::ListHummockMetaConfigResponse>,
3275            tonic::Status,
3276        >;
3277        async fn get_compaction_score(
3278            &self,
3279            request: tonic::Request<super::GetCompactionScoreRequest>,
3280        ) -> std::result::Result<
3281            tonic::Response<super::GetCompactionScoreResponse>,
3282            tonic::Status,
3283        >;
3284        async fn list_compact_task_assignment(
3285            &self,
3286            request: tonic::Request<super::ListCompactTaskAssignmentRequest>,
3287        ) -> std::result::Result<
3288            tonic::Response<super::ListCompactTaskAssignmentResponse>,
3289            tonic::Status,
3290        >;
3291        async fn list_compact_task_progress(
3292            &self,
3293            request: tonic::Request<super::ListCompactTaskProgressRequest>,
3294        ) -> std::result::Result<
3295            tonic::Response<super::ListCompactTaskProgressResponse>,
3296            tonic::Status,
3297        >;
3298        async fn cancel_compact_task(
3299            &self,
3300            request: tonic::Request<super::CancelCompactTaskRequest>,
3301        ) -> std::result::Result<
3302            tonic::Response<super::CancelCompactTaskResponse>,
3303            tonic::Status,
3304        >;
3305        async fn get_version_by_epoch(
3306            &self,
3307            request: tonic::Request<super::GetVersionByEpochRequest>,
3308        ) -> std::result::Result<
3309            tonic::Response<super::GetVersionByEpochResponse>,
3310            tonic::Status,
3311        >;
3312        async fn merge_compaction_group(
3313            &self,
3314            request: tonic::Request<super::MergeCompactionGroupRequest>,
3315        ) -> std::result::Result<
3316            tonic::Response<super::MergeCompactionGroupResponse>,
3317            tonic::Status,
3318        >;
3319        /// Server streaming response type for the SubscribeIcebergCompactionEvent method.
3320        type SubscribeIcebergCompactionEventStream: tonic::codegen::tokio_stream::Stream<
3321                Item = std::result::Result<
3322                    super::super::iceberg_compaction::SubscribeIcebergCompactionEventResponse,
3323                    tonic::Status,
3324                >,
3325            >
3326            + std::marker::Send
3327            + 'static;
3328        /// iceberg
3329        async fn subscribe_iceberg_compaction_event(
3330            &self,
3331            request: tonic::Request<
3332                tonic::Streaming<
3333                    super::super::iceberg_compaction::SubscribeIcebergCompactionEventRequest,
3334                >,
3335            >,
3336        ) -> std::result::Result<
3337            tonic::Response<Self::SubscribeIcebergCompactionEventStream>,
3338            tonic::Status,
3339        >;
3340    }
3341    #[derive(Debug)]
3342    pub struct HummockManagerServiceServer<T> {
3343        inner: Arc<T>,
3344        accept_compression_encodings: EnabledCompressionEncodings,
3345        send_compression_encodings: EnabledCompressionEncodings,
3346        max_decoding_message_size: Option<usize>,
3347        max_encoding_message_size: Option<usize>,
3348    }
3349    impl<T> HummockManagerServiceServer<T> {
3350        pub fn new(inner: T) -> Self {
3351            Self::from_arc(Arc::new(inner))
3352        }
3353        pub fn from_arc(inner: Arc<T>) -> Self {
3354            Self {
3355                inner,
3356                accept_compression_encodings: Default::default(),
3357                send_compression_encodings: Default::default(),
3358                max_decoding_message_size: None,
3359                max_encoding_message_size: None,
3360            }
3361        }
3362        pub fn with_interceptor<F>(
3363            inner: T,
3364            interceptor: F,
3365        ) -> InterceptedService<Self, F>
3366        where
3367            F: tonic::service::Interceptor,
3368        {
3369            InterceptedService::new(Self::new(inner), interceptor)
3370        }
3371        /// Enable decompressing requests with the given encoding.
3372        #[must_use]
3373        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
3374            self.accept_compression_encodings.enable(encoding);
3375            self
3376        }
3377        /// Compress responses with the given encoding, if the client supports it.
3378        #[must_use]
3379        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
3380            self.send_compression_encodings.enable(encoding);
3381            self
3382        }
3383        /// Limits the maximum size of a decoded message.
3384        ///
3385        /// Default: `4MB`
3386        #[must_use]
3387        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
3388            self.max_decoding_message_size = Some(limit);
3389            self
3390        }
3391        /// Limits the maximum size of an encoded message.
3392        ///
3393        /// Default: `usize::MAX`
3394        #[must_use]
3395        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
3396            self.max_encoding_message_size = Some(limit);
3397            self
3398        }
3399    }
3400    impl<T, B> tonic::codegen::Service<http::Request<B>>
3401    for HummockManagerServiceServer<T>
3402    where
3403        T: HummockManagerService,
3404        B: Body + std::marker::Send + 'static,
3405        B::Error: Into<StdError> + std::marker::Send + 'static,
3406    {
3407        type Response = http::Response<tonic::body::BoxBody>;
3408        type Error = std::convert::Infallible;
3409        type Future = BoxFuture<Self::Response, Self::Error>;
3410        fn poll_ready(
3411            &mut self,
3412            _cx: &mut Context<'_>,
3413        ) -> Poll<std::result::Result<(), Self::Error>> {
3414            Poll::Ready(Ok(()))
3415        }
3416        fn call(&mut self, req: http::Request<B>) -> Self::Future {
3417            match req.uri().path() {
3418                "/hummock.HummockManagerService/UnpinVersionBefore" => {
3419                    #[allow(non_camel_case_types)]
3420                    struct UnpinVersionBeforeSvc<T: HummockManagerService>(pub Arc<T>);
3421                    impl<
3422                        T: HummockManagerService,
3423                    > tonic::server::UnaryService<super::UnpinVersionBeforeRequest>
3424                    for UnpinVersionBeforeSvc<T> {
3425                        type Response = super::UnpinVersionBeforeResponse;
3426                        type Future = BoxFuture<
3427                            tonic::Response<Self::Response>,
3428                            tonic::Status,
3429                        >;
3430                        fn call(
3431                            &mut self,
3432                            request: tonic::Request<super::UnpinVersionBeforeRequest>,
3433                        ) -> Self::Future {
3434                            let inner = Arc::clone(&self.0);
3435                            let fut = async move {
3436                                <T as HummockManagerService>::unpin_version_before(
3437                                        &inner,
3438                                        request,
3439                                    )
3440                                    .await
3441                            };
3442                            Box::pin(fut)
3443                        }
3444                    }
3445                    let accept_compression_encodings = self.accept_compression_encodings;
3446                    let send_compression_encodings = self.send_compression_encodings;
3447                    let max_decoding_message_size = self.max_decoding_message_size;
3448                    let max_encoding_message_size = self.max_encoding_message_size;
3449                    let inner = self.inner.clone();
3450                    let fut = async move {
3451                        let method = UnpinVersionBeforeSvc(inner);
3452                        let codec = tonic::codec::ProstCodec::default();
3453                        let mut grpc = tonic::server::Grpc::new(codec)
3454                            .apply_compression_config(
3455                                accept_compression_encodings,
3456                                send_compression_encodings,
3457                            )
3458                            .apply_max_message_size_config(
3459                                max_decoding_message_size,
3460                                max_encoding_message_size,
3461                            );
3462                        let res = grpc.unary(method, req).await;
3463                        Ok(res)
3464                    };
3465                    Box::pin(fut)
3466                }
3467                "/hummock.HummockManagerService/GetCurrentVersion" => {
3468                    #[allow(non_camel_case_types)]
3469                    struct GetCurrentVersionSvc<T: HummockManagerService>(pub Arc<T>);
3470                    impl<
3471                        T: HummockManagerService,
3472                    > tonic::server::UnaryService<super::GetCurrentVersionRequest>
3473                    for GetCurrentVersionSvc<T> {
3474                        type Response = super::GetCurrentVersionResponse;
3475                        type Future = BoxFuture<
3476                            tonic::Response<Self::Response>,
3477                            tonic::Status,
3478                        >;
3479                        fn call(
3480                            &mut self,
3481                            request: tonic::Request<super::GetCurrentVersionRequest>,
3482                        ) -> Self::Future {
3483                            let inner = Arc::clone(&self.0);
3484                            let fut = async move {
3485                                <T as HummockManagerService>::get_current_version(
3486                                        &inner,
3487                                        request,
3488                                    )
3489                                    .await
3490                            };
3491                            Box::pin(fut)
3492                        }
3493                    }
3494                    let accept_compression_encodings = self.accept_compression_encodings;
3495                    let send_compression_encodings = self.send_compression_encodings;
3496                    let max_decoding_message_size = self.max_decoding_message_size;
3497                    let max_encoding_message_size = self.max_encoding_message_size;
3498                    let inner = self.inner.clone();
3499                    let fut = async move {
3500                        let method = GetCurrentVersionSvc(inner);
3501                        let codec = tonic::codec::ProstCodec::default();
3502                        let mut grpc = tonic::server::Grpc::new(codec)
3503                            .apply_compression_config(
3504                                accept_compression_encodings,
3505                                send_compression_encodings,
3506                            )
3507                            .apply_max_message_size_config(
3508                                max_decoding_message_size,
3509                                max_encoding_message_size,
3510                            );
3511                        let res = grpc.unary(method, req).await;
3512                        Ok(res)
3513                    };
3514                    Box::pin(fut)
3515                }
3516                "/hummock.HummockManagerService/ListVersionDeltas" => {
3517                    #[allow(non_camel_case_types)]
3518                    struct ListVersionDeltasSvc<T: HummockManagerService>(pub Arc<T>);
3519                    impl<
3520                        T: HummockManagerService,
3521                    > tonic::server::UnaryService<super::ListVersionDeltasRequest>
3522                    for ListVersionDeltasSvc<T> {
3523                        type Response = super::ListVersionDeltasResponse;
3524                        type Future = BoxFuture<
3525                            tonic::Response<Self::Response>,
3526                            tonic::Status,
3527                        >;
3528                        fn call(
3529                            &mut self,
3530                            request: tonic::Request<super::ListVersionDeltasRequest>,
3531                        ) -> Self::Future {
3532                            let inner = Arc::clone(&self.0);
3533                            let fut = async move {
3534                                <T as HummockManagerService>::list_version_deltas(
3535                                        &inner,
3536                                        request,
3537                                    )
3538                                    .await
3539                            };
3540                            Box::pin(fut)
3541                        }
3542                    }
3543                    let accept_compression_encodings = self.accept_compression_encodings;
3544                    let send_compression_encodings = self.send_compression_encodings;
3545                    let max_decoding_message_size = self.max_decoding_message_size;
3546                    let max_encoding_message_size = self.max_encoding_message_size;
3547                    let inner = self.inner.clone();
3548                    let fut = async move {
3549                        let method = ListVersionDeltasSvc(inner);
3550                        let codec = tonic::codec::ProstCodec::default();
3551                        let mut grpc = tonic::server::Grpc::new(codec)
3552                            .apply_compression_config(
3553                                accept_compression_encodings,
3554                                send_compression_encodings,
3555                            )
3556                            .apply_max_message_size_config(
3557                                max_decoding_message_size,
3558                                max_encoding_message_size,
3559                            );
3560                        let res = grpc.unary(method, req).await;
3561                        Ok(res)
3562                    };
3563                    Box::pin(fut)
3564                }
3565                "/hummock.HummockManagerService/ReplayVersionDelta" => {
3566                    #[allow(non_camel_case_types)]
3567                    struct ReplayVersionDeltaSvc<T: HummockManagerService>(pub Arc<T>);
3568                    impl<
3569                        T: HummockManagerService,
3570                    > tonic::server::UnaryService<super::ReplayVersionDeltaRequest>
3571                    for ReplayVersionDeltaSvc<T> {
3572                        type Response = super::ReplayVersionDeltaResponse;
3573                        type Future = BoxFuture<
3574                            tonic::Response<Self::Response>,
3575                            tonic::Status,
3576                        >;
3577                        fn call(
3578                            &mut self,
3579                            request: tonic::Request<super::ReplayVersionDeltaRequest>,
3580                        ) -> Self::Future {
3581                            let inner = Arc::clone(&self.0);
3582                            let fut = async move {
3583                                <T as HummockManagerService>::replay_version_delta(
3584                                        &inner,
3585                                        request,
3586                                    )
3587                                    .await
3588                            };
3589                            Box::pin(fut)
3590                        }
3591                    }
3592                    let accept_compression_encodings = self.accept_compression_encodings;
3593                    let send_compression_encodings = self.send_compression_encodings;
3594                    let max_decoding_message_size = self.max_decoding_message_size;
3595                    let max_encoding_message_size = self.max_encoding_message_size;
3596                    let inner = self.inner.clone();
3597                    let fut = async move {
3598                        let method = ReplayVersionDeltaSvc(inner);
3599                        let codec = tonic::codec::ProstCodec::default();
3600                        let mut grpc = tonic::server::Grpc::new(codec)
3601                            .apply_compression_config(
3602                                accept_compression_encodings,
3603                                send_compression_encodings,
3604                            )
3605                            .apply_max_message_size_config(
3606                                max_decoding_message_size,
3607                                max_encoding_message_size,
3608                            );
3609                        let res = grpc.unary(method, req).await;
3610                        Ok(res)
3611                    };
3612                    Box::pin(fut)
3613                }
3614                "/hummock.HummockManagerService/GetAssignedCompactTaskNum" => {
3615                    #[allow(non_camel_case_types)]
3616                    struct GetAssignedCompactTaskNumSvc<T: HummockManagerService>(
3617                        pub Arc<T>,
3618                    );
3619                    impl<
3620                        T: HummockManagerService,
3621                    > tonic::server::UnaryService<
3622                        super::GetAssignedCompactTaskNumRequest,
3623                    > for GetAssignedCompactTaskNumSvc<T> {
3624                        type Response = super::GetAssignedCompactTaskNumResponse;
3625                        type Future = BoxFuture<
3626                            tonic::Response<Self::Response>,
3627                            tonic::Status,
3628                        >;
3629                        fn call(
3630                            &mut self,
3631                            request: tonic::Request<
3632                                super::GetAssignedCompactTaskNumRequest,
3633                            >,
3634                        ) -> Self::Future {
3635                            let inner = Arc::clone(&self.0);
3636                            let fut = async move {
3637                                <T as HummockManagerService>::get_assigned_compact_task_num(
3638                                        &inner,
3639                                        request,
3640                                    )
3641                                    .await
3642                            };
3643                            Box::pin(fut)
3644                        }
3645                    }
3646                    let accept_compression_encodings = self.accept_compression_encodings;
3647                    let send_compression_encodings = self.send_compression_encodings;
3648                    let max_decoding_message_size = self.max_decoding_message_size;
3649                    let max_encoding_message_size = self.max_encoding_message_size;
3650                    let inner = self.inner.clone();
3651                    let fut = async move {
3652                        let method = GetAssignedCompactTaskNumSvc(inner);
3653                        let codec = tonic::codec::ProstCodec::default();
3654                        let mut grpc = tonic::server::Grpc::new(codec)
3655                            .apply_compression_config(
3656                                accept_compression_encodings,
3657                                send_compression_encodings,
3658                            )
3659                            .apply_max_message_size_config(
3660                                max_decoding_message_size,
3661                                max_encoding_message_size,
3662                            );
3663                        let res = grpc.unary(method, req).await;
3664                        Ok(res)
3665                    };
3666                    Box::pin(fut)
3667                }
3668                "/hummock.HummockManagerService/TriggerCompactionDeterministic" => {
3669                    #[allow(non_camel_case_types)]
3670                    struct TriggerCompactionDeterministicSvc<T: HummockManagerService>(
3671                        pub Arc<T>,
3672                    );
3673                    impl<
3674                        T: HummockManagerService,
3675                    > tonic::server::UnaryService<
3676                        super::TriggerCompactionDeterministicRequest,
3677                    > for TriggerCompactionDeterministicSvc<T> {
3678                        type Response = super::TriggerCompactionDeterministicResponse;
3679                        type Future = BoxFuture<
3680                            tonic::Response<Self::Response>,
3681                            tonic::Status,
3682                        >;
3683                        fn call(
3684                            &mut self,
3685                            request: tonic::Request<
3686                                super::TriggerCompactionDeterministicRequest,
3687                            >,
3688                        ) -> Self::Future {
3689                            let inner = Arc::clone(&self.0);
3690                            let fut = async move {
3691                                <T as HummockManagerService>::trigger_compaction_deterministic(
3692                                        &inner,
3693                                        request,
3694                                    )
3695                                    .await
3696                            };
3697                            Box::pin(fut)
3698                        }
3699                    }
3700                    let accept_compression_encodings = self.accept_compression_encodings;
3701                    let send_compression_encodings = self.send_compression_encodings;
3702                    let max_decoding_message_size = self.max_decoding_message_size;
3703                    let max_encoding_message_size = self.max_encoding_message_size;
3704                    let inner = self.inner.clone();
3705                    let fut = async move {
3706                        let method = TriggerCompactionDeterministicSvc(inner);
3707                        let codec = tonic::codec::ProstCodec::default();
3708                        let mut grpc = tonic::server::Grpc::new(codec)
3709                            .apply_compression_config(
3710                                accept_compression_encodings,
3711                                send_compression_encodings,
3712                            )
3713                            .apply_max_message_size_config(
3714                                max_decoding_message_size,
3715                                max_encoding_message_size,
3716                            );
3717                        let res = grpc.unary(method, req).await;
3718                        Ok(res)
3719                    };
3720                    Box::pin(fut)
3721                }
3722                "/hummock.HummockManagerService/DisableCommitEpoch" => {
3723                    #[allow(non_camel_case_types)]
3724                    struct DisableCommitEpochSvc<T: HummockManagerService>(pub Arc<T>);
3725                    impl<
3726                        T: HummockManagerService,
3727                    > tonic::server::UnaryService<super::DisableCommitEpochRequest>
3728                    for DisableCommitEpochSvc<T> {
3729                        type Response = super::DisableCommitEpochResponse;
3730                        type Future = BoxFuture<
3731                            tonic::Response<Self::Response>,
3732                            tonic::Status,
3733                        >;
3734                        fn call(
3735                            &mut self,
3736                            request: tonic::Request<super::DisableCommitEpochRequest>,
3737                        ) -> Self::Future {
3738                            let inner = Arc::clone(&self.0);
3739                            let fut = async move {
3740                                <T as HummockManagerService>::disable_commit_epoch(
3741                                        &inner,
3742                                        request,
3743                                    )
3744                                    .await
3745                            };
3746                            Box::pin(fut)
3747                        }
3748                    }
3749                    let accept_compression_encodings = self.accept_compression_encodings;
3750                    let send_compression_encodings = self.send_compression_encodings;
3751                    let max_decoding_message_size = self.max_decoding_message_size;
3752                    let max_encoding_message_size = self.max_encoding_message_size;
3753                    let inner = self.inner.clone();
3754                    let fut = async move {
3755                        let method = DisableCommitEpochSvc(inner);
3756                        let codec = tonic::codec::ProstCodec::default();
3757                        let mut grpc = tonic::server::Grpc::new(codec)
3758                            .apply_compression_config(
3759                                accept_compression_encodings,
3760                                send_compression_encodings,
3761                            )
3762                            .apply_max_message_size_config(
3763                                max_decoding_message_size,
3764                                max_encoding_message_size,
3765                            );
3766                        let res = grpc.unary(method, req).await;
3767                        Ok(res)
3768                    };
3769                    Box::pin(fut)
3770                }
3771                "/hummock.HummockManagerService/GetNewObjectIds" => {
3772                    #[allow(non_camel_case_types)]
3773                    struct GetNewObjectIdsSvc<T: HummockManagerService>(pub Arc<T>);
3774                    impl<
3775                        T: HummockManagerService,
3776                    > tonic::server::UnaryService<super::GetNewObjectIdsRequest>
3777                    for GetNewObjectIdsSvc<T> {
3778                        type Response = super::GetNewObjectIdsResponse;
3779                        type Future = BoxFuture<
3780                            tonic::Response<Self::Response>,
3781                            tonic::Status,
3782                        >;
3783                        fn call(
3784                            &mut self,
3785                            request: tonic::Request<super::GetNewObjectIdsRequest>,
3786                        ) -> Self::Future {
3787                            let inner = Arc::clone(&self.0);
3788                            let fut = async move {
3789                                <T as HummockManagerService>::get_new_object_ids(
3790                                        &inner,
3791                                        request,
3792                                    )
3793                                    .await
3794                            };
3795                            Box::pin(fut)
3796                        }
3797                    }
3798                    let accept_compression_encodings = self.accept_compression_encodings;
3799                    let send_compression_encodings = self.send_compression_encodings;
3800                    let max_decoding_message_size = self.max_decoding_message_size;
3801                    let max_encoding_message_size = self.max_encoding_message_size;
3802                    let inner = self.inner.clone();
3803                    let fut = async move {
3804                        let method = GetNewObjectIdsSvc(inner);
3805                        let codec = tonic::codec::ProstCodec::default();
3806                        let mut grpc = tonic::server::Grpc::new(codec)
3807                            .apply_compression_config(
3808                                accept_compression_encodings,
3809                                send_compression_encodings,
3810                            )
3811                            .apply_max_message_size_config(
3812                                max_decoding_message_size,
3813                                max_encoding_message_size,
3814                            );
3815                        let res = grpc.unary(method, req).await;
3816                        Ok(res)
3817                    };
3818                    Box::pin(fut)
3819                }
3820                "/hummock.HummockManagerService/TriggerManualCompaction" => {
3821                    #[allow(non_camel_case_types)]
3822                    struct TriggerManualCompactionSvc<T: HummockManagerService>(
3823                        pub Arc<T>,
3824                    );
3825                    impl<
3826                        T: HummockManagerService,
3827                    > tonic::server::UnaryService<super::TriggerManualCompactionRequest>
3828                    for TriggerManualCompactionSvc<T> {
3829                        type Response = super::TriggerManualCompactionResponse;
3830                        type Future = BoxFuture<
3831                            tonic::Response<Self::Response>,
3832                            tonic::Status,
3833                        >;
3834                        fn call(
3835                            &mut self,
3836                            request: tonic::Request<
3837                                super::TriggerManualCompactionRequest,
3838                            >,
3839                        ) -> Self::Future {
3840                            let inner = Arc::clone(&self.0);
3841                            let fut = async move {
3842                                <T as HummockManagerService>::trigger_manual_compaction(
3843                                        &inner,
3844                                        request,
3845                                    )
3846                                    .await
3847                            };
3848                            Box::pin(fut)
3849                        }
3850                    }
3851                    let accept_compression_encodings = self.accept_compression_encodings;
3852                    let send_compression_encodings = self.send_compression_encodings;
3853                    let max_decoding_message_size = self.max_decoding_message_size;
3854                    let max_encoding_message_size = self.max_encoding_message_size;
3855                    let inner = self.inner.clone();
3856                    let fut = async move {
3857                        let method = TriggerManualCompactionSvc(inner);
3858                        let codec = tonic::codec::ProstCodec::default();
3859                        let mut grpc = tonic::server::Grpc::new(codec)
3860                            .apply_compression_config(
3861                                accept_compression_encodings,
3862                                send_compression_encodings,
3863                            )
3864                            .apply_max_message_size_config(
3865                                max_decoding_message_size,
3866                                max_encoding_message_size,
3867                            );
3868                        let res = grpc.unary(method, req).await;
3869                        Ok(res)
3870                    };
3871                    Box::pin(fut)
3872                }
3873                "/hummock.HummockManagerService/TriggerFullGC" => {
3874                    #[allow(non_camel_case_types)]
3875                    struct TriggerFullGCSvc<T: HummockManagerService>(pub Arc<T>);
3876                    impl<
3877                        T: HummockManagerService,
3878                    > tonic::server::UnaryService<super::TriggerFullGcRequest>
3879                    for TriggerFullGCSvc<T> {
3880                        type Response = super::TriggerFullGcResponse;
3881                        type Future = BoxFuture<
3882                            tonic::Response<Self::Response>,
3883                            tonic::Status,
3884                        >;
3885                        fn call(
3886                            &mut self,
3887                            request: tonic::Request<super::TriggerFullGcRequest>,
3888                        ) -> Self::Future {
3889                            let inner = Arc::clone(&self.0);
3890                            let fut = async move {
3891                                <T as HummockManagerService>::trigger_full_gc(
3892                                        &inner,
3893                                        request,
3894                                    )
3895                                    .await
3896                            };
3897                            Box::pin(fut)
3898                        }
3899                    }
3900                    let accept_compression_encodings = self.accept_compression_encodings;
3901                    let send_compression_encodings = self.send_compression_encodings;
3902                    let max_decoding_message_size = self.max_decoding_message_size;
3903                    let max_encoding_message_size = self.max_encoding_message_size;
3904                    let inner = self.inner.clone();
3905                    let fut = async move {
3906                        let method = TriggerFullGCSvc(inner);
3907                        let codec = tonic::codec::ProstCodec::default();
3908                        let mut grpc = tonic::server::Grpc::new(codec)
3909                            .apply_compression_config(
3910                                accept_compression_encodings,
3911                                send_compression_encodings,
3912                            )
3913                            .apply_max_message_size_config(
3914                                max_decoding_message_size,
3915                                max_encoding_message_size,
3916                            );
3917                        let res = grpc.unary(method, req).await;
3918                        Ok(res)
3919                    };
3920                    Box::pin(fut)
3921                }
3922                "/hummock.HummockManagerService/RiseCtlGetPinnedVersionsSummary" => {
3923                    #[allow(non_camel_case_types)]
3924                    struct RiseCtlGetPinnedVersionsSummarySvc<T: HummockManagerService>(
3925                        pub Arc<T>,
3926                    );
3927                    impl<
3928                        T: HummockManagerService,
3929                    > tonic::server::UnaryService<
3930                        super::RiseCtlGetPinnedVersionsSummaryRequest,
3931                    > for RiseCtlGetPinnedVersionsSummarySvc<T> {
3932                        type Response = super::RiseCtlGetPinnedVersionsSummaryResponse;
3933                        type Future = BoxFuture<
3934                            tonic::Response<Self::Response>,
3935                            tonic::Status,
3936                        >;
3937                        fn call(
3938                            &mut self,
3939                            request: tonic::Request<
3940                                super::RiseCtlGetPinnedVersionsSummaryRequest,
3941                            >,
3942                        ) -> Self::Future {
3943                            let inner = Arc::clone(&self.0);
3944                            let fut = async move {
3945                                <T as HummockManagerService>::rise_ctl_get_pinned_versions_summary(
3946                                        &inner,
3947                                        request,
3948                                    )
3949                                    .await
3950                            };
3951                            Box::pin(fut)
3952                        }
3953                    }
3954                    let accept_compression_encodings = self.accept_compression_encodings;
3955                    let send_compression_encodings = self.send_compression_encodings;
3956                    let max_decoding_message_size = self.max_decoding_message_size;
3957                    let max_encoding_message_size = self.max_encoding_message_size;
3958                    let inner = self.inner.clone();
3959                    let fut = async move {
3960                        let method = RiseCtlGetPinnedVersionsSummarySvc(inner);
3961                        let codec = tonic::codec::ProstCodec::default();
3962                        let mut grpc = tonic::server::Grpc::new(codec)
3963                            .apply_compression_config(
3964                                accept_compression_encodings,
3965                                send_compression_encodings,
3966                            )
3967                            .apply_max_message_size_config(
3968                                max_decoding_message_size,
3969                                max_encoding_message_size,
3970                            );
3971                        let res = grpc.unary(method, req).await;
3972                        Ok(res)
3973                    };
3974                    Box::pin(fut)
3975                }
3976                "/hummock.HummockManagerService/RiseCtlListCompactionGroup" => {
3977                    #[allow(non_camel_case_types)]
3978                    struct RiseCtlListCompactionGroupSvc<T: HummockManagerService>(
3979                        pub Arc<T>,
3980                    );
3981                    impl<
3982                        T: HummockManagerService,
3983                    > tonic::server::UnaryService<
3984                        super::RiseCtlListCompactionGroupRequest,
3985                    > for RiseCtlListCompactionGroupSvc<T> {
3986                        type Response = super::RiseCtlListCompactionGroupResponse;
3987                        type Future = BoxFuture<
3988                            tonic::Response<Self::Response>,
3989                            tonic::Status,
3990                        >;
3991                        fn call(
3992                            &mut self,
3993                            request: tonic::Request<
3994                                super::RiseCtlListCompactionGroupRequest,
3995                            >,
3996                        ) -> Self::Future {
3997                            let inner = Arc::clone(&self.0);
3998                            let fut = async move {
3999                                <T as HummockManagerService>::rise_ctl_list_compaction_group(
4000                                        &inner,
4001                                        request,
4002                                    )
4003                                    .await
4004                            };
4005                            Box::pin(fut)
4006                        }
4007                    }
4008                    let accept_compression_encodings = self.accept_compression_encodings;
4009                    let send_compression_encodings = self.send_compression_encodings;
4010                    let max_decoding_message_size = self.max_decoding_message_size;
4011                    let max_encoding_message_size = self.max_encoding_message_size;
4012                    let inner = self.inner.clone();
4013                    let fut = async move {
4014                        let method = RiseCtlListCompactionGroupSvc(inner);
4015                        let codec = tonic::codec::ProstCodec::default();
4016                        let mut grpc = tonic::server::Grpc::new(codec)
4017                            .apply_compression_config(
4018                                accept_compression_encodings,
4019                                send_compression_encodings,
4020                            )
4021                            .apply_max_message_size_config(
4022                                max_decoding_message_size,
4023                                max_encoding_message_size,
4024                            );
4025                        let res = grpc.unary(method, req).await;
4026                        Ok(res)
4027                    };
4028                    Box::pin(fut)
4029                }
4030                "/hummock.HummockManagerService/RiseCtlUpdateCompactionConfig" => {
4031                    #[allow(non_camel_case_types)]
4032                    struct RiseCtlUpdateCompactionConfigSvc<T: HummockManagerService>(
4033                        pub Arc<T>,
4034                    );
4035                    impl<
4036                        T: HummockManagerService,
4037                    > tonic::server::UnaryService<
4038                        super::RiseCtlUpdateCompactionConfigRequest,
4039                    > for RiseCtlUpdateCompactionConfigSvc<T> {
4040                        type Response = super::RiseCtlUpdateCompactionConfigResponse;
4041                        type Future = BoxFuture<
4042                            tonic::Response<Self::Response>,
4043                            tonic::Status,
4044                        >;
4045                        fn call(
4046                            &mut self,
4047                            request: tonic::Request<
4048                                super::RiseCtlUpdateCompactionConfigRequest,
4049                            >,
4050                        ) -> Self::Future {
4051                            let inner = Arc::clone(&self.0);
4052                            let fut = async move {
4053                                <T as HummockManagerService>::rise_ctl_update_compaction_config(
4054                                        &inner,
4055                                        request,
4056                                    )
4057                                    .await
4058                            };
4059                            Box::pin(fut)
4060                        }
4061                    }
4062                    let accept_compression_encodings = self.accept_compression_encodings;
4063                    let send_compression_encodings = self.send_compression_encodings;
4064                    let max_decoding_message_size = self.max_decoding_message_size;
4065                    let max_encoding_message_size = self.max_encoding_message_size;
4066                    let inner = self.inner.clone();
4067                    let fut = async move {
4068                        let method = RiseCtlUpdateCompactionConfigSvc(inner);
4069                        let codec = tonic::codec::ProstCodec::default();
4070                        let mut grpc = tonic::server::Grpc::new(codec)
4071                            .apply_compression_config(
4072                                accept_compression_encodings,
4073                                send_compression_encodings,
4074                            )
4075                            .apply_max_message_size_config(
4076                                max_decoding_message_size,
4077                                max_encoding_message_size,
4078                            );
4079                        let res = grpc.unary(method, req).await;
4080                        Ok(res)
4081                    };
4082                    Box::pin(fut)
4083                }
4084                "/hummock.HummockManagerService/RiseCtlPauseVersionCheckpoint" => {
4085                    #[allow(non_camel_case_types)]
4086                    struct RiseCtlPauseVersionCheckpointSvc<T: HummockManagerService>(
4087                        pub Arc<T>,
4088                    );
4089                    impl<
4090                        T: HummockManagerService,
4091                    > tonic::server::UnaryService<
4092                        super::RiseCtlPauseVersionCheckpointRequest,
4093                    > for RiseCtlPauseVersionCheckpointSvc<T> {
4094                        type Response = super::RiseCtlPauseVersionCheckpointResponse;
4095                        type Future = BoxFuture<
4096                            tonic::Response<Self::Response>,
4097                            tonic::Status,
4098                        >;
4099                        fn call(
4100                            &mut self,
4101                            request: tonic::Request<
4102                                super::RiseCtlPauseVersionCheckpointRequest,
4103                            >,
4104                        ) -> Self::Future {
4105                            let inner = Arc::clone(&self.0);
4106                            let fut = async move {
4107                                <T as HummockManagerService>::rise_ctl_pause_version_checkpoint(
4108                                        &inner,
4109                                        request,
4110                                    )
4111                                    .await
4112                            };
4113                            Box::pin(fut)
4114                        }
4115                    }
4116                    let accept_compression_encodings = self.accept_compression_encodings;
4117                    let send_compression_encodings = self.send_compression_encodings;
4118                    let max_decoding_message_size = self.max_decoding_message_size;
4119                    let max_encoding_message_size = self.max_encoding_message_size;
4120                    let inner = self.inner.clone();
4121                    let fut = async move {
4122                        let method = RiseCtlPauseVersionCheckpointSvc(inner);
4123                        let codec = tonic::codec::ProstCodec::default();
4124                        let mut grpc = tonic::server::Grpc::new(codec)
4125                            .apply_compression_config(
4126                                accept_compression_encodings,
4127                                send_compression_encodings,
4128                            )
4129                            .apply_max_message_size_config(
4130                                max_decoding_message_size,
4131                                max_encoding_message_size,
4132                            );
4133                        let res = grpc.unary(method, req).await;
4134                        Ok(res)
4135                    };
4136                    Box::pin(fut)
4137                }
4138                "/hummock.HummockManagerService/RiseCtlResumeVersionCheckpoint" => {
4139                    #[allow(non_camel_case_types)]
4140                    struct RiseCtlResumeVersionCheckpointSvc<T: HummockManagerService>(
4141                        pub Arc<T>,
4142                    );
4143                    impl<
4144                        T: HummockManagerService,
4145                    > tonic::server::UnaryService<
4146                        super::RiseCtlResumeVersionCheckpointRequest,
4147                    > for RiseCtlResumeVersionCheckpointSvc<T> {
4148                        type Response = super::RiseCtlResumeVersionCheckpointResponse;
4149                        type Future = BoxFuture<
4150                            tonic::Response<Self::Response>,
4151                            tonic::Status,
4152                        >;
4153                        fn call(
4154                            &mut self,
4155                            request: tonic::Request<
4156                                super::RiseCtlResumeVersionCheckpointRequest,
4157                            >,
4158                        ) -> Self::Future {
4159                            let inner = Arc::clone(&self.0);
4160                            let fut = async move {
4161                                <T as HummockManagerService>::rise_ctl_resume_version_checkpoint(
4162                                        &inner,
4163                                        request,
4164                                    )
4165                                    .await
4166                            };
4167                            Box::pin(fut)
4168                        }
4169                    }
4170                    let accept_compression_encodings = self.accept_compression_encodings;
4171                    let send_compression_encodings = self.send_compression_encodings;
4172                    let max_decoding_message_size = self.max_decoding_message_size;
4173                    let max_encoding_message_size = self.max_encoding_message_size;
4174                    let inner = self.inner.clone();
4175                    let fut = async move {
4176                        let method = RiseCtlResumeVersionCheckpointSvc(inner);
4177                        let codec = tonic::codec::ProstCodec::default();
4178                        let mut grpc = tonic::server::Grpc::new(codec)
4179                            .apply_compression_config(
4180                                accept_compression_encodings,
4181                                send_compression_encodings,
4182                            )
4183                            .apply_max_message_size_config(
4184                                max_decoding_message_size,
4185                                max_encoding_message_size,
4186                            );
4187                        let res = grpc.unary(method, req).await;
4188                        Ok(res)
4189                    };
4190                    Box::pin(fut)
4191                }
4192                "/hummock.HummockManagerService/RiseCtlGetCheckpointVersion" => {
4193                    #[allow(non_camel_case_types)]
4194                    struct RiseCtlGetCheckpointVersionSvc<T: HummockManagerService>(
4195                        pub Arc<T>,
4196                    );
4197                    impl<
4198                        T: HummockManagerService,
4199                    > tonic::server::UnaryService<
4200                        super::RiseCtlGetCheckpointVersionRequest,
4201                    > for RiseCtlGetCheckpointVersionSvc<T> {
4202                        type Response = super::RiseCtlGetCheckpointVersionResponse;
4203                        type Future = BoxFuture<
4204                            tonic::Response<Self::Response>,
4205                            tonic::Status,
4206                        >;
4207                        fn call(
4208                            &mut self,
4209                            request: tonic::Request<
4210                                super::RiseCtlGetCheckpointVersionRequest,
4211                            >,
4212                        ) -> Self::Future {
4213                            let inner = Arc::clone(&self.0);
4214                            let fut = async move {
4215                                <T as HummockManagerService>::rise_ctl_get_checkpoint_version(
4216                                        &inner,
4217                                        request,
4218                                    )
4219                                    .await
4220                            };
4221                            Box::pin(fut)
4222                        }
4223                    }
4224                    let accept_compression_encodings = self.accept_compression_encodings;
4225                    let send_compression_encodings = self.send_compression_encodings;
4226                    let max_decoding_message_size = self.max_decoding_message_size;
4227                    let max_encoding_message_size = self.max_encoding_message_size;
4228                    let inner = self.inner.clone();
4229                    let fut = async move {
4230                        let method = RiseCtlGetCheckpointVersionSvc(inner);
4231                        let codec = tonic::codec::ProstCodec::default();
4232                        let mut grpc = tonic::server::Grpc::new(codec)
4233                            .apply_compression_config(
4234                                accept_compression_encodings,
4235                                send_compression_encodings,
4236                            )
4237                            .apply_max_message_size_config(
4238                                max_decoding_message_size,
4239                                max_encoding_message_size,
4240                            );
4241                        let res = grpc.unary(method, req).await;
4242                        Ok(res)
4243                    };
4244                    Box::pin(fut)
4245                }
4246                "/hummock.HummockManagerService/RiseCtlRebuildTableStats" => {
4247                    #[allow(non_camel_case_types)]
4248                    struct RiseCtlRebuildTableStatsSvc<T: HummockManagerService>(
4249                        pub Arc<T>,
4250                    );
4251                    impl<
4252                        T: HummockManagerService,
4253                    > tonic::server::UnaryService<super::RiseCtlRebuildTableStatsRequest>
4254                    for RiseCtlRebuildTableStatsSvc<T> {
4255                        type Response = super::RiseCtlRebuildTableStatsResponse;
4256                        type Future = BoxFuture<
4257                            tonic::Response<Self::Response>,
4258                            tonic::Status,
4259                        >;
4260                        fn call(
4261                            &mut self,
4262                            request: tonic::Request<
4263                                super::RiseCtlRebuildTableStatsRequest,
4264                            >,
4265                        ) -> Self::Future {
4266                            let inner = Arc::clone(&self.0);
4267                            let fut = async move {
4268                                <T as HummockManagerService>::rise_ctl_rebuild_table_stats(
4269                                        &inner,
4270                                        request,
4271                                    )
4272                                    .await
4273                            };
4274                            Box::pin(fut)
4275                        }
4276                    }
4277                    let accept_compression_encodings = self.accept_compression_encodings;
4278                    let send_compression_encodings = self.send_compression_encodings;
4279                    let max_decoding_message_size = self.max_decoding_message_size;
4280                    let max_encoding_message_size = self.max_encoding_message_size;
4281                    let inner = self.inner.clone();
4282                    let fut = async move {
4283                        let method = RiseCtlRebuildTableStatsSvc(inner);
4284                        let codec = tonic::codec::ProstCodec::default();
4285                        let mut grpc = tonic::server::Grpc::new(codec)
4286                            .apply_compression_config(
4287                                accept_compression_encodings,
4288                                send_compression_encodings,
4289                            )
4290                            .apply_max_message_size_config(
4291                                max_decoding_message_size,
4292                                max_encoding_message_size,
4293                            );
4294                        let res = grpc.unary(method, req).await;
4295                        Ok(res)
4296                    };
4297                    Box::pin(fut)
4298                }
4299                "/hummock.HummockManagerService/InitMetadataForReplay" => {
4300                    #[allow(non_camel_case_types)]
4301                    struct InitMetadataForReplaySvc<T: HummockManagerService>(
4302                        pub Arc<T>,
4303                    );
4304                    impl<
4305                        T: HummockManagerService,
4306                    > tonic::server::UnaryService<super::InitMetadataForReplayRequest>
4307                    for InitMetadataForReplaySvc<T> {
4308                        type Response = super::InitMetadataForReplayResponse;
4309                        type Future = BoxFuture<
4310                            tonic::Response<Self::Response>,
4311                            tonic::Status,
4312                        >;
4313                        fn call(
4314                            &mut self,
4315                            request: tonic::Request<super::InitMetadataForReplayRequest>,
4316                        ) -> Self::Future {
4317                            let inner = Arc::clone(&self.0);
4318                            let fut = async move {
4319                                <T as HummockManagerService>::init_metadata_for_replay(
4320                                        &inner,
4321                                        request,
4322                                    )
4323                                    .await
4324                            };
4325                            Box::pin(fut)
4326                        }
4327                    }
4328                    let accept_compression_encodings = self.accept_compression_encodings;
4329                    let send_compression_encodings = self.send_compression_encodings;
4330                    let max_decoding_message_size = self.max_decoding_message_size;
4331                    let max_encoding_message_size = self.max_encoding_message_size;
4332                    let inner = self.inner.clone();
4333                    let fut = async move {
4334                        let method = InitMetadataForReplaySvc(inner);
4335                        let codec = tonic::codec::ProstCodec::default();
4336                        let mut grpc = tonic::server::Grpc::new(codec)
4337                            .apply_compression_config(
4338                                accept_compression_encodings,
4339                                send_compression_encodings,
4340                            )
4341                            .apply_max_message_size_config(
4342                                max_decoding_message_size,
4343                                max_encoding_message_size,
4344                            );
4345                        let res = grpc.unary(method, req).await;
4346                        Ok(res)
4347                    };
4348                    Box::pin(fut)
4349                }
4350                "/hummock.HummockManagerService/PinVersion" => {
4351                    #[allow(non_camel_case_types)]
4352                    struct PinVersionSvc<T: HummockManagerService>(pub Arc<T>);
4353                    impl<
4354                        T: HummockManagerService,
4355                    > tonic::server::UnaryService<super::PinVersionRequest>
4356                    for PinVersionSvc<T> {
4357                        type Response = super::PinVersionResponse;
4358                        type Future = BoxFuture<
4359                            tonic::Response<Self::Response>,
4360                            tonic::Status,
4361                        >;
4362                        fn call(
4363                            &mut self,
4364                            request: tonic::Request<super::PinVersionRequest>,
4365                        ) -> Self::Future {
4366                            let inner = Arc::clone(&self.0);
4367                            let fut = async move {
4368                                <T as HummockManagerService>::pin_version(&inner, request)
4369                                    .await
4370                            };
4371                            Box::pin(fut)
4372                        }
4373                    }
4374                    let accept_compression_encodings = self.accept_compression_encodings;
4375                    let send_compression_encodings = self.send_compression_encodings;
4376                    let max_decoding_message_size = self.max_decoding_message_size;
4377                    let max_encoding_message_size = self.max_encoding_message_size;
4378                    let inner = self.inner.clone();
4379                    let fut = async move {
4380                        let method = PinVersionSvc(inner);
4381                        let codec = tonic::codec::ProstCodec::default();
4382                        let mut grpc = tonic::server::Grpc::new(codec)
4383                            .apply_compression_config(
4384                                accept_compression_encodings,
4385                                send_compression_encodings,
4386                            )
4387                            .apply_max_message_size_config(
4388                                max_decoding_message_size,
4389                                max_encoding_message_size,
4390                            );
4391                        let res = grpc.unary(method, req).await;
4392                        Ok(res)
4393                    };
4394                    Box::pin(fut)
4395                }
4396                "/hummock.HummockManagerService/SplitCompactionGroup" => {
4397                    #[allow(non_camel_case_types)]
4398                    struct SplitCompactionGroupSvc<T: HummockManagerService>(pub Arc<T>);
4399                    impl<
4400                        T: HummockManagerService,
4401                    > tonic::server::UnaryService<super::SplitCompactionGroupRequest>
4402                    for SplitCompactionGroupSvc<T> {
4403                        type Response = super::SplitCompactionGroupResponse;
4404                        type Future = BoxFuture<
4405                            tonic::Response<Self::Response>,
4406                            tonic::Status,
4407                        >;
4408                        fn call(
4409                            &mut self,
4410                            request: tonic::Request<super::SplitCompactionGroupRequest>,
4411                        ) -> Self::Future {
4412                            let inner = Arc::clone(&self.0);
4413                            let fut = async move {
4414                                <T as HummockManagerService>::split_compaction_group(
4415                                        &inner,
4416                                        request,
4417                                    )
4418                                    .await
4419                            };
4420                            Box::pin(fut)
4421                        }
4422                    }
4423                    let accept_compression_encodings = self.accept_compression_encodings;
4424                    let send_compression_encodings = self.send_compression_encodings;
4425                    let max_decoding_message_size = self.max_decoding_message_size;
4426                    let max_encoding_message_size = self.max_encoding_message_size;
4427                    let inner = self.inner.clone();
4428                    let fut = async move {
4429                        let method = SplitCompactionGroupSvc(inner);
4430                        let codec = tonic::codec::ProstCodec::default();
4431                        let mut grpc = tonic::server::Grpc::new(codec)
4432                            .apply_compression_config(
4433                                accept_compression_encodings,
4434                                send_compression_encodings,
4435                            )
4436                            .apply_max_message_size_config(
4437                                max_decoding_message_size,
4438                                max_encoding_message_size,
4439                            );
4440                        let res = grpc.unary(method, req).await;
4441                        Ok(res)
4442                    };
4443                    Box::pin(fut)
4444                }
4445                "/hummock.HummockManagerService/RiseCtlListCompactionStatus" => {
4446                    #[allow(non_camel_case_types)]
4447                    struct RiseCtlListCompactionStatusSvc<T: HummockManagerService>(
4448                        pub Arc<T>,
4449                    );
4450                    impl<
4451                        T: HummockManagerService,
4452                    > tonic::server::UnaryService<
4453                        super::RiseCtlListCompactionStatusRequest,
4454                    > for RiseCtlListCompactionStatusSvc<T> {
4455                        type Response = super::RiseCtlListCompactionStatusResponse;
4456                        type Future = BoxFuture<
4457                            tonic::Response<Self::Response>,
4458                            tonic::Status,
4459                        >;
4460                        fn call(
4461                            &mut self,
4462                            request: tonic::Request<
4463                                super::RiseCtlListCompactionStatusRequest,
4464                            >,
4465                        ) -> Self::Future {
4466                            let inner = Arc::clone(&self.0);
4467                            let fut = async move {
4468                                <T as HummockManagerService>::rise_ctl_list_compaction_status(
4469                                        &inner,
4470                                        request,
4471                                    )
4472                                    .await
4473                            };
4474                            Box::pin(fut)
4475                        }
4476                    }
4477                    let accept_compression_encodings = self.accept_compression_encodings;
4478                    let send_compression_encodings = self.send_compression_encodings;
4479                    let max_decoding_message_size = self.max_decoding_message_size;
4480                    let max_encoding_message_size = self.max_encoding_message_size;
4481                    let inner = self.inner.clone();
4482                    let fut = async move {
4483                        let method = RiseCtlListCompactionStatusSvc(inner);
4484                        let codec = tonic::codec::ProstCodec::default();
4485                        let mut grpc = tonic::server::Grpc::new(codec)
4486                            .apply_compression_config(
4487                                accept_compression_encodings,
4488                                send_compression_encodings,
4489                            )
4490                            .apply_max_message_size_config(
4491                                max_decoding_message_size,
4492                                max_encoding_message_size,
4493                            );
4494                        let res = grpc.unary(method, req).await;
4495                        Ok(res)
4496                    };
4497                    Box::pin(fut)
4498                }
4499                "/hummock.HummockManagerService/SubscribeCompactionEvent" => {
4500                    #[allow(non_camel_case_types)]
4501                    struct SubscribeCompactionEventSvc<T: HummockManagerService>(
4502                        pub Arc<T>,
4503                    );
4504                    impl<
4505                        T: HummockManagerService,
4506                    > tonic::server::StreamingService<
4507                        super::SubscribeCompactionEventRequest,
4508                    > for SubscribeCompactionEventSvc<T> {
4509                        type Response = super::SubscribeCompactionEventResponse;
4510                        type ResponseStream = T::SubscribeCompactionEventStream;
4511                        type Future = BoxFuture<
4512                            tonic::Response<Self::ResponseStream>,
4513                            tonic::Status,
4514                        >;
4515                        fn call(
4516                            &mut self,
4517                            request: tonic::Request<
4518                                tonic::Streaming<super::SubscribeCompactionEventRequest>,
4519                            >,
4520                        ) -> Self::Future {
4521                            let inner = Arc::clone(&self.0);
4522                            let fut = async move {
4523                                <T as HummockManagerService>::subscribe_compaction_event(
4524                                        &inner,
4525                                        request,
4526                                    )
4527                                    .await
4528                            };
4529                            Box::pin(fut)
4530                        }
4531                    }
4532                    let accept_compression_encodings = self.accept_compression_encodings;
4533                    let send_compression_encodings = self.send_compression_encodings;
4534                    let max_decoding_message_size = self.max_decoding_message_size;
4535                    let max_encoding_message_size = self.max_encoding_message_size;
4536                    let inner = self.inner.clone();
4537                    let fut = async move {
4538                        let method = SubscribeCompactionEventSvc(inner);
4539                        let codec = tonic::codec::ProstCodec::default();
4540                        let mut grpc = tonic::server::Grpc::new(codec)
4541                            .apply_compression_config(
4542                                accept_compression_encodings,
4543                                send_compression_encodings,
4544                            )
4545                            .apply_max_message_size_config(
4546                                max_decoding_message_size,
4547                                max_encoding_message_size,
4548                            );
4549                        let res = grpc.streaming(method, req).await;
4550                        Ok(res)
4551                    };
4552                    Box::pin(fut)
4553                }
4554                "/hummock.HummockManagerService/ReportCompactionTask" => {
4555                    #[allow(non_camel_case_types)]
4556                    struct ReportCompactionTaskSvc<T: HummockManagerService>(pub Arc<T>);
4557                    impl<
4558                        T: HummockManagerService,
4559                    > tonic::server::UnaryService<super::ReportCompactionTaskRequest>
4560                    for ReportCompactionTaskSvc<T> {
4561                        type Response = super::ReportCompactionTaskResponse;
4562                        type Future = BoxFuture<
4563                            tonic::Response<Self::Response>,
4564                            tonic::Status,
4565                        >;
4566                        fn call(
4567                            &mut self,
4568                            request: tonic::Request<super::ReportCompactionTaskRequest>,
4569                        ) -> Self::Future {
4570                            let inner = Arc::clone(&self.0);
4571                            let fut = async move {
4572                                <T as HummockManagerService>::report_compaction_task(
4573                                        &inner,
4574                                        request,
4575                                    )
4576                                    .await
4577                            };
4578                            Box::pin(fut)
4579                        }
4580                    }
4581                    let accept_compression_encodings = self.accept_compression_encodings;
4582                    let send_compression_encodings = self.send_compression_encodings;
4583                    let max_decoding_message_size = self.max_decoding_message_size;
4584                    let max_encoding_message_size = self.max_encoding_message_size;
4585                    let inner = self.inner.clone();
4586                    let fut = async move {
4587                        let method = ReportCompactionTaskSvc(inner);
4588                        let codec = tonic::codec::ProstCodec::default();
4589                        let mut grpc = tonic::server::Grpc::new(codec)
4590                            .apply_compression_config(
4591                                accept_compression_encodings,
4592                                send_compression_encodings,
4593                            )
4594                            .apply_max_message_size_config(
4595                                max_decoding_message_size,
4596                                max_encoding_message_size,
4597                            );
4598                        let res = grpc.unary(method, req).await;
4599                        Ok(res)
4600                    };
4601                    Box::pin(fut)
4602                }
4603                "/hummock.HummockManagerService/ListBranchedObject" => {
4604                    #[allow(non_camel_case_types)]
4605                    struct ListBranchedObjectSvc<T: HummockManagerService>(pub Arc<T>);
4606                    impl<
4607                        T: HummockManagerService,
4608                    > tonic::server::UnaryService<super::ListBranchedObjectRequest>
4609                    for ListBranchedObjectSvc<T> {
4610                        type Response = super::ListBranchedObjectResponse;
4611                        type Future = BoxFuture<
4612                            tonic::Response<Self::Response>,
4613                            tonic::Status,
4614                        >;
4615                        fn call(
4616                            &mut self,
4617                            request: tonic::Request<super::ListBranchedObjectRequest>,
4618                        ) -> Self::Future {
4619                            let inner = Arc::clone(&self.0);
4620                            let fut = async move {
4621                                <T as HummockManagerService>::list_branched_object(
4622                                        &inner,
4623                                        request,
4624                                    )
4625                                    .await
4626                            };
4627                            Box::pin(fut)
4628                        }
4629                    }
4630                    let accept_compression_encodings = self.accept_compression_encodings;
4631                    let send_compression_encodings = self.send_compression_encodings;
4632                    let max_decoding_message_size = self.max_decoding_message_size;
4633                    let max_encoding_message_size = self.max_encoding_message_size;
4634                    let inner = self.inner.clone();
4635                    let fut = async move {
4636                        let method = ListBranchedObjectSvc(inner);
4637                        let codec = tonic::codec::ProstCodec::default();
4638                        let mut grpc = tonic::server::Grpc::new(codec)
4639                            .apply_compression_config(
4640                                accept_compression_encodings,
4641                                send_compression_encodings,
4642                            )
4643                            .apply_max_message_size_config(
4644                                max_decoding_message_size,
4645                                max_encoding_message_size,
4646                            );
4647                        let res = grpc.unary(method, req).await;
4648                        Ok(res)
4649                    };
4650                    Box::pin(fut)
4651                }
4652                "/hummock.HummockManagerService/ListActiveWriteLimit" => {
4653                    #[allow(non_camel_case_types)]
4654                    struct ListActiveWriteLimitSvc<T: HummockManagerService>(pub Arc<T>);
4655                    impl<
4656                        T: HummockManagerService,
4657                    > tonic::server::UnaryService<super::ListActiveWriteLimitRequest>
4658                    for ListActiveWriteLimitSvc<T> {
4659                        type Response = super::ListActiveWriteLimitResponse;
4660                        type Future = BoxFuture<
4661                            tonic::Response<Self::Response>,
4662                            tonic::Status,
4663                        >;
4664                        fn call(
4665                            &mut self,
4666                            request: tonic::Request<super::ListActiveWriteLimitRequest>,
4667                        ) -> Self::Future {
4668                            let inner = Arc::clone(&self.0);
4669                            let fut = async move {
4670                                <T as HummockManagerService>::list_active_write_limit(
4671                                        &inner,
4672                                        request,
4673                                    )
4674                                    .await
4675                            };
4676                            Box::pin(fut)
4677                        }
4678                    }
4679                    let accept_compression_encodings = self.accept_compression_encodings;
4680                    let send_compression_encodings = self.send_compression_encodings;
4681                    let max_decoding_message_size = self.max_decoding_message_size;
4682                    let max_encoding_message_size = self.max_encoding_message_size;
4683                    let inner = self.inner.clone();
4684                    let fut = async move {
4685                        let method = ListActiveWriteLimitSvc(inner);
4686                        let codec = tonic::codec::ProstCodec::default();
4687                        let mut grpc = tonic::server::Grpc::new(codec)
4688                            .apply_compression_config(
4689                                accept_compression_encodings,
4690                                send_compression_encodings,
4691                            )
4692                            .apply_max_message_size_config(
4693                                max_decoding_message_size,
4694                                max_encoding_message_size,
4695                            );
4696                        let res = grpc.unary(method, req).await;
4697                        Ok(res)
4698                    };
4699                    Box::pin(fut)
4700                }
4701                "/hummock.HummockManagerService/ListHummockMetaConfig" => {
4702                    #[allow(non_camel_case_types)]
4703                    struct ListHummockMetaConfigSvc<T: HummockManagerService>(
4704                        pub Arc<T>,
4705                    );
4706                    impl<
4707                        T: HummockManagerService,
4708                    > tonic::server::UnaryService<super::ListHummockMetaConfigRequest>
4709                    for ListHummockMetaConfigSvc<T> {
4710                        type Response = super::ListHummockMetaConfigResponse;
4711                        type Future = BoxFuture<
4712                            tonic::Response<Self::Response>,
4713                            tonic::Status,
4714                        >;
4715                        fn call(
4716                            &mut self,
4717                            request: tonic::Request<super::ListHummockMetaConfigRequest>,
4718                        ) -> Self::Future {
4719                            let inner = Arc::clone(&self.0);
4720                            let fut = async move {
4721                                <T as HummockManagerService>::list_hummock_meta_config(
4722                                        &inner,
4723                                        request,
4724                                    )
4725                                    .await
4726                            };
4727                            Box::pin(fut)
4728                        }
4729                    }
4730                    let accept_compression_encodings = self.accept_compression_encodings;
4731                    let send_compression_encodings = self.send_compression_encodings;
4732                    let max_decoding_message_size = self.max_decoding_message_size;
4733                    let max_encoding_message_size = self.max_encoding_message_size;
4734                    let inner = self.inner.clone();
4735                    let fut = async move {
4736                        let method = ListHummockMetaConfigSvc(inner);
4737                        let codec = tonic::codec::ProstCodec::default();
4738                        let mut grpc = tonic::server::Grpc::new(codec)
4739                            .apply_compression_config(
4740                                accept_compression_encodings,
4741                                send_compression_encodings,
4742                            )
4743                            .apply_max_message_size_config(
4744                                max_decoding_message_size,
4745                                max_encoding_message_size,
4746                            );
4747                        let res = grpc.unary(method, req).await;
4748                        Ok(res)
4749                    };
4750                    Box::pin(fut)
4751                }
4752                "/hummock.HummockManagerService/GetCompactionScore" => {
4753                    #[allow(non_camel_case_types)]
4754                    struct GetCompactionScoreSvc<T: HummockManagerService>(pub Arc<T>);
4755                    impl<
4756                        T: HummockManagerService,
4757                    > tonic::server::UnaryService<super::GetCompactionScoreRequest>
4758                    for GetCompactionScoreSvc<T> {
4759                        type Response = super::GetCompactionScoreResponse;
4760                        type Future = BoxFuture<
4761                            tonic::Response<Self::Response>,
4762                            tonic::Status,
4763                        >;
4764                        fn call(
4765                            &mut self,
4766                            request: tonic::Request<super::GetCompactionScoreRequest>,
4767                        ) -> Self::Future {
4768                            let inner = Arc::clone(&self.0);
4769                            let fut = async move {
4770                                <T as HummockManagerService>::get_compaction_score(
4771                                        &inner,
4772                                        request,
4773                                    )
4774                                    .await
4775                            };
4776                            Box::pin(fut)
4777                        }
4778                    }
4779                    let accept_compression_encodings = self.accept_compression_encodings;
4780                    let send_compression_encodings = self.send_compression_encodings;
4781                    let max_decoding_message_size = self.max_decoding_message_size;
4782                    let max_encoding_message_size = self.max_encoding_message_size;
4783                    let inner = self.inner.clone();
4784                    let fut = async move {
4785                        let method = GetCompactionScoreSvc(inner);
4786                        let codec = tonic::codec::ProstCodec::default();
4787                        let mut grpc = tonic::server::Grpc::new(codec)
4788                            .apply_compression_config(
4789                                accept_compression_encodings,
4790                                send_compression_encodings,
4791                            )
4792                            .apply_max_message_size_config(
4793                                max_decoding_message_size,
4794                                max_encoding_message_size,
4795                            );
4796                        let res = grpc.unary(method, req).await;
4797                        Ok(res)
4798                    };
4799                    Box::pin(fut)
4800                }
4801                "/hummock.HummockManagerService/ListCompactTaskAssignment" => {
4802                    #[allow(non_camel_case_types)]
4803                    struct ListCompactTaskAssignmentSvc<T: HummockManagerService>(
4804                        pub Arc<T>,
4805                    );
4806                    impl<
4807                        T: HummockManagerService,
4808                    > tonic::server::UnaryService<
4809                        super::ListCompactTaskAssignmentRequest,
4810                    > for ListCompactTaskAssignmentSvc<T> {
4811                        type Response = super::ListCompactTaskAssignmentResponse;
4812                        type Future = BoxFuture<
4813                            tonic::Response<Self::Response>,
4814                            tonic::Status,
4815                        >;
4816                        fn call(
4817                            &mut self,
4818                            request: tonic::Request<
4819                                super::ListCompactTaskAssignmentRequest,
4820                            >,
4821                        ) -> Self::Future {
4822                            let inner = Arc::clone(&self.0);
4823                            let fut = async move {
4824                                <T as HummockManagerService>::list_compact_task_assignment(
4825                                        &inner,
4826                                        request,
4827                                    )
4828                                    .await
4829                            };
4830                            Box::pin(fut)
4831                        }
4832                    }
4833                    let accept_compression_encodings = self.accept_compression_encodings;
4834                    let send_compression_encodings = self.send_compression_encodings;
4835                    let max_decoding_message_size = self.max_decoding_message_size;
4836                    let max_encoding_message_size = self.max_encoding_message_size;
4837                    let inner = self.inner.clone();
4838                    let fut = async move {
4839                        let method = ListCompactTaskAssignmentSvc(inner);
4840                        let codec = tonic::codec::ProstCodec::default();
4841                        let mut grpc = tonic::server::Grpc::new(codec)
4842                            .apply_compression_config(
4843                                accept_compression_encodings,
4844                                send_compression_encodings,
4845                            )
4846                            .apply_max_message_size_config(
4847                                max_decoding_message_size,
4848                                max_encoding_message_size,
4849                            );
4850                        let res = grpc.unary(method, req).await;
4851                        Ok(res)
4852                    };
4853                    Box::pin(fut)
4854                }
4855                "/hummock.HummockManagerService/ListCompactTaskProgress" => {
4856                    #[allow(non_camel_case_types)]
4857                    struct ListCompactTaskProgressSvc<T: HummockManagerService>(
4858                        pub Arc<T>,
4859                    );
4860                    impl<
4861                        T: HummockManagerService,
4862                    > tonic::server::UnaryService<super::ListCompactTaskProgressRequest>
4863                    for ListCompactTaskProgressSvc<T> {
4864                        type Response = super::ListCompactTaskProgressResponse;
4865                        type Future = BoxFuture<
4866                            tonic::Response<Self::Response>,
4867                            tonic::Status,
4868                        >;
4869                        fn call(
4870                            &mut self,
4871                            request: tonic::Request<
4872                                super::ListCompactTaskProgressRequest,
4873                            >,
4874                        ) -> Self::Future {
4875                            let inner = Arc::clone(&self.0);
4876                            let fut = async move {
4877                                <T as HummockManagerService>::list_compact_task_progress(
4878                                        &inner,
4879                                        request,
4880                                    )
4881                                    .await
4882                            };
4883                            Box::pin(fut)
4884                        }
4885                    }
4886                    let accept_compression_encodings = self.accept_compression_encodings;
4887                    let send_compression_encodings = self.send_compression_encodings;
4888                    let max_decoding_message_size = self.max_decoding_message_size;
4889                    let max_encoding_message_size = self.max_encoding_message_size;
4890                    let inner = self.inner.clone();
4891                    let fut = async move {
4892                        let method = ListCompactTaskProgressSvc(inner);
4893                        let codec = tonic::codec::ProstCodec::default();
4894                        let mut grpc = tonic::server::Grpc::new(codec)
4895                            .apply_compression_config(
4896                                accept_compression_encodings,
4897                                send_compression_encodings,
4898                            )
4899                            .apply_max_message_size_config(
4900                                max_decoding_message_size,
4901                                max_encoding_message_size,
4902                            );
4903                        let res = grpc.unary(method, req).await;
4904                        Ok(res)
4905                    };
4906                    Box::pin(fut)
4907                }
4908                "/hummock.HummockManagerService/CancelCompactTask" => {
4909                    #[allow(non_camel_case_types)]
4910                    struct CancelCompactTaskSvc<T: HummockManagerService>(pub Arc<T>);
4911                    impl<
4912                        T: HummockManagerService,
4913                    > tonic::server::UnaryService<super::CancelCompactTaskRequest>
4914                    for CancelCompactTaskSvc<T> {
4915                        type Response = super::CancelCompactTaskResponse;
4916                        type Future = BoxFuture<
4917                            tonic::Response<Self::Response>,
4918                            tonic::Status,
4919                        >;
4920                        fn call(
4921                            &mut self,
4922                            request: tonic::Request<super::CancelCompactTaskRequest>,
4923                        ) -> Self::Future {
4924                            let inner = Arc::clone(&self.0);
4925                            let fut = async move {
4926                                <T as HummockManagerService>::cancel_compact_task(
4927                                        &inner,
4928                                        request,
4929                                    )
4930                                    .await
4931                            };
4932                            Box::pin(fut)
4933                        }
4934                    }
4935                    let accept_compression_encodings = self.accept_compression_encodings;
4936                    let send_compression_encodings = self.send_compression_encodings;
4937                    let max_decoding_message_size = self.max_decoding_message_size;
4938                    let max_encoding_message_size = self.max_encoding_message_size;
4939                    let inner = self.inner.clone();
4940                    let fut = async move {
4941                        let method = CancelCompactTaskSvc(inner);
4942                        let codec = tonic::codec::ProstCodec::default();
4943                        let mut grpc = tonic::server::Grpc::new(codec)
4944                            .apply_compression_config(
4945                                accept_compression_encodings,
4946                                send_compression_encodings,
4947                            )
4948                            .apply_max_message_size_config(
4949                                max_decoding_message_size,
4950                                max_encoding_message_size,
4951                            );
4952                        let res = grpc.unary(method, req).await;
4953                        Ok(res)
4954                    };
4955                    Box::pin(fut)
4956                }
4957                "/hummock.HummockManagerService/GetVersionByEpoch" => {
4958                    #[allow(non_camel_case_types)]
4959                    struct GetVersionByEpochSvc<T: HummockManagerService>(pub Arc<T>);
4960                    impl<
4961                        T: HummockManagerService,
4962                    > tonic::server::UnaryService<super::GetVersionByEpochRequest>
4963                    for GetVersionByEpochSvc<T> {
4964                        type Response = super::GetVersionByEpochResponse;
4965                        type Future = BoxFuture<
4966                            tonic::Response<Self::Response>,
4967                            tonic::Status,
4968                        >;
4969                        fn call(
4970                            &mut self,
4971                            request: tonic::Request<super::GetVersionByEpochRequest>,
4972                        ) -> Self::Future {
4973                            let inner = Arc::clone(&self.0);
4974                            let fut = async move {
4975                                <T as HummockManagerService>::get_version_by_epoch(
4976                                        &inner,
4977                                        request,
4978                                    )
4979                                    .await
4980                            };
4981                            Box::pin(fut)
4982                        }
4983                    }
4984                    let accept_compression_encodings = self.accept_compression_encodings;
4985                    let send_compression_encodings = self.send_compression_encodings;
4986                    let max_decoding_message_size = self.max_decoding_message_size;
4987                    let max_encoding_message_size = self.max_encoding_message_size;
4988                    let inner = self.inner.clone();
4989                    let fut = async move {
4990                        let method = GetVersionByEpochSvc(inner);
4991                        let codec = tonic::codec::ProstCodec::default();
4992                        let mut grpc = tonic::server::Grpc::new(codec)
4993                            .apply_compression_config(
4994                                accept_compression_encodings,
4995                                send_compression_encodings,
4996                            )
4997                            .apply_max_message_size_config(
4998                                max_decoding_message_size,
4999                                max_encoding_message_size,
5000                            );
5001                        let res = grpc.unary(method, req).await;
5002                        Ok(res)
5003                    };
5004                    Box::pin(fut)
5005                }
5006                "/hummock.HummockManagerService/MergeCompactionGroup" => {
5007                    #[allow(non_camel_case_types)]
5008                    struct MergeCompactionGroupSvc<T: HummockManagerService>(pub Arc<T>);
5009                    impl<
5010                        T: HummockManagerService,
5011                    > tonic::server::UnaryService<super::MergeCompactionGroupRequest>
5012                    for MergeCompactionGroupSvc<T> {
5013                        type Response = super::MergeCompactionGroupResponse;
5014                        type Future = BoxFuture<
5015                            tonic::Response<Self::Response>,
5016                            tonic::Status,
5017                        >;
5018                        fn call(
5019                            &mut self,
5020                            request: tonic::Request<super::MergeCompactionGroupRequest>,
5021                        ) -> Self::Future {
5022                            let inner = Arc::clone(&self.0);
5023                            let fut = async move {
5024                                <T as HummockManagerService>::merge_compaction_group(
5025                                        &inner,
5026                                        request,
5027                                    )
5028                                    .await
5029                            };
5030                            Box::pin(fut)
5031                        }
5032                    }
5033                    let accept_compression_encodings = self.accept_compression_encodings;
5034                    let send_compression_encodings = self.send_compression_encodings;
5035                    let max_decoding_message_size = self.max_decoding_message_size;
5036                    let max_encoding_message_size = self.max_encoding_message_size;
5037                    let inner = self.inner.clone();
5038                    let fut = async move {
5039                        let method = MergeCompactionGroupSvc(inner);
5040                        let codec = tonic::codec::ProstCodec::default();
5041                        let mut grpc = tonic::server::Grpc::new(codec)
5042                            .apply_compression_config(
5043                                accept_compression_encodings,
5044                                send_compression_encodings,
5045                            )
5046                            .apply_max_message_size_config(
5047                                max_decoding_message_size,
5048                                max_encoding_message_size,
5049                            );
5050                        let res = grpc.unary(method, req).await;
5051                        Ok(res)
5052                    };
5053                    Box::pin(fut)
5054                }
5055                "/hummock.HummockManagerService/SubscribeIcebergCompactionEvent" => {
5056                    #[allow(non_camel_case_types)]
5057                    struct SubscribeIcebergCompactionEventSvc<T: HummockManagerService>(
5058                        pub Arc<T>,
5059                    );
5060                    impl<
5061                        T: HummockManagerService,
5062                    > tonic::server::StreamingService<
5063                        super::super::iceberg_compaction::SubscribeIcebergCompactionEventRequest,
5064                    > for SubscribeIcebergCompactionEventSvc<T> {
5065                        type Response = super::super::iceberg_compaction::SubscribeIcebergCompactionEventResponse;
5066                        type ResponseStream = T::SubscribeIcebergCompactionEventStream;
5067                        type Future = BoxFuture<
5068                            tonic::Response<Self::ResponseStream>,
5069                            tonic::Status,
5070                        >;
5071                        fn call(
5072                            &mut self,
5073                            request: tonic::Request<
5074                                tonic::Streaming<
5075                                    super::super::iceberg_compaction::SubscribeIcebergCompactionEventRequest,
5076                                >,
5077                            >,
5078                        ) -> Self::Future {
5079                            let inner = Arc::clone(&self.0);
5080                            let fut = async move {
5081                                <T as HummockManagerService>::subscribe_iceberg_compaction_event(
5082                                        &inner,
5083                                        request,
5084                                    )
5085                                    .await
5086                            };
5087                            Box::pin(fut)
5088                        }
5089                    }
5090                    let accept_compression_encodings = self.accept_compression_encodings;
5091                    let send_compression_encodings = self.send_compression_encodings;
5092                    let max_decoding_message_size = self.max_decoding_message_size;
5093                    let max_encoding_message_size = self.max_encoding_message_size;
5094                    let inner = self.inner.clone();
5095                    let fut = async move {
5096                        let method = SubscribeIcebergCompactionEventSvc(inner);
5097                        let codec = tonic::codec::ProstCodec::default();
5098                        let mut grpc = tonic::server::Grpc::new(codec)
5099                            .apply_compression_config(
5100                                accept_compression_encodings,
5101                                send_compression_encodings,
5102                            )
5103                            .apply_max_message_size_config(
5104                                max_decoding_message_size,
5105                                max_encoding_message_size,
5106                            );
5107                        let res = grpc.streaming(method, req).await;
5108                        Ok(res)
5109                    };
5110                    Box::pin(fut)
5111                }
5112                _ => {
5113                    Box::pin(async move {
5114                        let mut response = http::Response::new(empty_body());
5115                        let headers = response.headers_mut();
5116                        headers
5117                            .insert(
5118                                tonic::Status::GRPC_STATUS,
5119                                (tonic::Code::Unimplemented as i32).into(),
5120                            );
5121                        headers
5122                            .insert(
5123                                http::header::CONTENT_TYPE,
5124                                tonic::metadata::GRPC_CONTENT_TYPE,
5125                            );
5126                        Ok(response)
5127                    })
5128                }
5129            }
5130        }
5131    }
5132    impl<T> Clone for HummockManagerServiceServer<T> {
5133        fn clone(&self) -> Self {
5134            let inner = self.inner.clone();
5135            Self {
5136                inner,
5137                accept_compression_encodings: self.accept_compression_encodings,
5138                send_compression_encodings: self.send_compression_encodings,
5139                max_decoding_message_size: self.max_decoding_message_size,
5140                max_encoding_message_size: self.max_encoding_message_size,
5141            }
5142        }
5143    }
5144    /// Generated gRPC service name
5145    pub const SERVICE_NAME: &str = "hummock.HummockManagerService";
5146    impl<T> tonic::server::NamedService for HummockManagerServiceServer<T> {
5147        const NAME: &'static str = SERVICE_NAME;
5148    }
5149}
risingwave_pb/hummock.rs

risingwave_pb/
hummock.rs
