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