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

risingwave_pb/
hummock.rs
