risingwave_pb/
hummock.rs

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

risingwave_pb/
hummock.rs
