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

risingwave_pb/
hummock.rs
