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

risingwave_pb/
hummock.rs
