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

risingwave_pb/
hummock.rs
