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

risingwave_pb/
hummock.rs
