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

risingwave_pb/
hummock.rs
