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