risingwave_pb/
hummock.rs

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

risingwave_pb/
hummock.rs
