risingwave_pb/
meta.rs

1// This file is @generated by prost-build.
2#[derive(prost_helpers::AnyPB)]
3#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
4pub struct GetTelemetryInfoRequest {}
5#[derive(prost_helpers::AnyPB)]
6#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
7pub struct TelemetryInfoResponse {
8    #[prost(string, optional, tag = "1")]
9    pub tracking_id: ::core::option::Option<::prost::alloc::string::String>,
10}
11#[derive(prost_helpers::AnyPB)]
12#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
13pub struct HeartbeatRequest {
14    #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
15    pub node_id: crate::id::WorkerId,
16    #[prost(message, optional, tag = "2")]
17    pub resource: ::core::option::Option<super::common::worker_node::Resource>,
18}
19#[derive(prost_helpers::AnyPB)]
20#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
21pub struct HeartbeatResponse {
22    #[prost(message, optional, tag = "1")]
23    pub status: ::core::option::Option<super::common::Status>,
24}
25/// Fragments of a Streaming Job.
26/// It's for all kinds of streaming jobs, and ideally should be called `StreamingJobFragments`.
27/// It's not the same as a storage table correlated with a `TableCatalog`.
28#[derive(prost_helpers::AnyPB)]
29#[derive(Clone, PartialEq, ::prost::Message)]
30pub struct TableFragments {
31    /// The id of the streaming job.
32    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
33    pub table_id: crate::id::JobId,
34    #[prost(enumeration = "table_fragments::State", tag = "2")]
35    pub state: i32,
36    #[prost(map = "uint32, message", tag = "3", wrapper = "crate::id::FragmentId")]
37    pub fragments: ::std::collections::HashMap<
38        crate::id::FragmentId,
39        table_fragments::Fragment,
40    >,
41    #[prost(map = "uint32, message", tag = "4", wrapper = "crate::id::ActorId")]
42    pub actor_status: ::std::collections::HashMap<
43        crate::id::ActorId,
44        table_fragments::ActorStatus,
45    >,
46    #[prost(message, optional, tag = "6")]
47    pub ctx: ::core::option::Option<super::stream_plan::StreamContext>,
48    /// The max parallelism specified when the streaming job was created, i.e., expected vnode count.
49    ///
50    /// The reason for persisting this value is mainly to check if a parallelism change (via `ALTER  .. SET PARALLELISM`) is valid, so that the behavior can be consistent with the creation of
51    /// the streaming job.
52    ///
53    /// Note that the actual vnode count, denoted by `vnode_count` in `fragments`, may be different
54    /// from this value (see `StreamFragmentGraph.max_parallelism` for more details.). As a result,
55    /// checking the parallelism change with this value can be inaccurate in some cases. However,
56    /// when generating resizing plans, we still take the `vnode_count` of each fragment into account.
57    ///
58    /// Can be unset if the fragment is created in older versions where variable vnode count is not
59    /// supported, in which case a default value of 256 should be used.
60    #[prost(uint32, optional, tag = "10")]
61    pub max_parallelism: ::core::option::Option<u32>,
62    /// Actors of a materialize view, sink, or table can only be scheduled on nodes with matching node_label.
63    #[prost(string, tag = "8")]
64    pub node_label: ::prost::alloc::string::String,
65    /// If this is a materialized view: True if backfill is done, else false.
66    /// If this is a regular table: Always true.
67    #[prost(bool, tag = "9")]
68    pub backfill_done: bool,
69}
70/// Nested message and enum types in `TableFragments`.
71pub mod table_fragments {
72    /// Runtime information of an actor
73    #[derive(prost_helpers::AnyPB)]
74    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
75    pub struct ActorStatus {
76        /// Current on which worker
77        #[prost(message, optional, tag = "1")]
78        pub location: ::core::option::Option<super::super::common::ActorLocation>,
79    }
80    #[derive(prost_helpers::AnyPB)]
81    #[derive(Clone, PartialEq, ::prost::Message)]
82    pub struct Fragment {
83        #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
84        pub fragment_id: crate::id::FragmentId,
85        /// Bitwise-OR of FragmentTypeFlags
86        #[prost(uint32, tag = "2")]
87        pub fragment_type_mask: u32,
88        #[prost(enumeration = "fragment::FragmentDistributionType", tag = "3")]
89        pub distribution_type: i32,
90        #[prost(message, repeated, tag = "4")]
91        pub actors: ::prost::alloc::vec::Vec<super::super::stream_plan::StreamActor>,
92        #[prost(uint32, repeated, tag = "6", wrapper = "crate::id::TableId")]
93        pub state_table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
94        /// Note that this can be derived backwards from the upstream actors of the Actor held by the Fragment,
95        /// but in some scenarios (e.g. Scaling) it will lead to a lot of duplicate code,
96        /// so we pre-generate and store it here, this member will only be initialized when creating the Fragment
97        /// and modified when creating the mv-on-mv
98        #[prost(uint32, repeated, tag = "7", wrapper = "crate::id::FragmentId")]
99        pub upstream_fragment_ids: ::prost::alloc::vec::Vec<crate::id::FragmentId>,
100        /// Total vnode count of the fragment (then all internal tables).
101        /// Duplicated from the length of the vnode bitmap in any actor of the fragment.
102        ///
103        /// Can be unset if the fragment is created in older versions where variable vnode count is not
104        /// supported, in which case a default value of 256 (or 1 for singleton) should be used.
105        /// Use `VnodeCountCompat::vnode_count` to access it.
106        #[prost(uint32, optional, tag = "8")]
107        pub maybe_vnode_count: ::core::option::Option<u32>,
108        #[prost(message, optional, tag = "9")]
109        pub nodes: ::core::option::Option<super::super::stream_plan::StreamNode>,
110    }
111    /// Nested message and enum types in `Fragment`.
112    pub mod fragment {
113        #[derive(prost_helpers::AnyPB)]
114        #[derive(
115            Clone,
116            Copy,
117            Debug,
118            PartialEq,
119            Eq,
120            Hash,
121            PartialOrd,
122            Ord,
123            ::prost::Enumeration
124        )]
125        #[repr(i32)]
126        pub enum FragmentDistributionType {
127            Unspecified = 0,
128            Single = 1,
129            Hash = 2,
130        }
131        impl FragmentDistributionType {
132            /// String value of the enum field names used in the ProtoBuf definition.
133            ///
134            /// The values are not transformed in any way and thus are considered stable
135            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
136            pub fn as_str_name(&self) -> &'static str {
137                match self {
138                    Self::Unspecified => "UNSPECIFIED",
139                    Self::Single => "SINGLE",
140                    Self::Hash => "HASH",
141                }
142            }
143            /// Creates an enum from field names used in the ProtoBuf definition.
144            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
145                match value {
146                    "UNSPECIFIED" => Some(Self::Unspecified),
147                    "SINGLE" => Some(Self::Single),
148                    "HASH" => Some(Self::Hash),
149                    _ => None,
150                }
151            }
152        }
153    }
154    /// The state of the fragments of this table
155    #[derive(prost_helpers::AnyPB)]
156    #[derive(
157        Clone,
158        Copy,
159        Debug,
160        PartialEq,
161        Eq,
162        Hash,
163        PartialOrd,
164        Ord,
165        ::prost::Enumeration
166    )]
167    #[repr(i32)]
168    pub enum State {
169        Unspecified = 0,
170        /// The streaming job is initial.
171        Initial = 1,
172        /// The streaming job is creating.
173        Creating = 2,
174        /// The streaming job has been created.
175        Created = 3,
176    }
177    impl State {
178        /// String value of the enum field names used in the ProtoBuf definition.
179        ///
180        /// The values are not transformed in any way and thus are considered stable
181        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
182        pub fn as_str_name(&self) -> &'static str {
183            match self {
184                Self::Unspecified => "UNSPECIFIED",
185                Self::Initial => "INITIAL",
186                Self::Creating => "CREATING",
187                Self::Created => "CREATED",
188            }
189        }
190        /// Creates an enum from field names used in the ProtoBuf definition.
191        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
192            match value {
193                "UNSPECIFIED" => Some(Self::Unspecified),
194                "INITIAL" => Some(Self::Initial),
195                "CREATING" => Some(Self::Creating),
196                "CREATED" => Some(Self::Created),
197                _ => None,
198            }
199        }
200    }
201}
202/// / Worker slot mapping with fragment id, used for notification.
203#[derive(prost_helpers::AnyPB)]
204#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
205pub struct FragmentWorkerSlotMapping {
206    #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
207    pub fragment_id: crate::id::FragmentId,
208    #[prost(message, optional, tag = "2")]
209    pub mapping: ::core::option::Option<super::common::WorkerSlotMapping>,
210}
211#[derive(prost_helpers::AnyPB)]
212#[derive(Clone, PartialEq, ::prost::Message)]
213pub struct FragmentWorkerSlotMappings {
214    #[prost(message, repeated, tag = "1")]
215    pub mappings: ::prost::alloc::vec::Vec<FragmentWorkerSlotMapping>,
216}
217/// TODO: remove this when dashboard refactored.
218#[derive(prost_helpers::AnyPB)]
219#[derive(Clone, PartialEq, ::prost::Message)]
220pub struct ActorLocation {
221    #[prost(message, optional, tag = "1")]
222    pub node: ::core::option::Option<super::common::WorkerNode>,
223    #[prost(message, repeated, tag = "2")]
224    pub actors: ::prost::alloc::vec::Vec<super::stream_plan::StreamActor>,
225}
226#[derive(prost_helpers::AnyPB)]
227#[derive(Clone, PartialEq, ::prost::Message)]
228pub struct MigrationPlan {
229    /// map\<src_worker_slot_id, dst_worker_slot_id>, the plan indicates that the actors will be migrated from old worker_slot to the new one.
230    #[prost(map = "uint64, uint64", tag = "2")]
231    pub worker_slot_migration_plan: ::std::collections::HashMap<u64, u64>,
232}
233#[derive(prost_helpers::AnyPB)]
234#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
235pub struct FlushRequest {
236    #[prost(uint32, tag = "1", wrapper = "crate::id::DatabaseId")]
237    pub database_id: crate::id::DatabaseId,
238}
239#[derive(prost_helpers::AnyPB)]
240#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
241pub struct FlushResponse {
242    #[prost(message, optional, tag = "1")]
243    pub status: ::core::option::Option<super::common::Status>,
244    #[prost(uint64, tag = "2", wrapper = "crate::id::HummockVersionId")]
245    pub hummock_version_id: crate::id::HummockVersionId,
246}
247#[derive(prost_helpers::AnyPB)]
248#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
249pub struct PauseRequest {}
250#[derive(prost_helpers::AnyPB)]
251#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
252pub struct PauseResponse {}
253#[derive(prost_helpers::AnyPB)]
254#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
255pub struct ResumeRequest {}
256#[derive(prost_helpers::AnyPB)]
257#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
258pub struct ResumeResponse {}
259#[derive(prost_helpers::AnyPB)]
260#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
261pub struct RefreshRequest {
262    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
263    pub table_id: crate::id::TableId,
264    #[prost(uint32, tag = "2", wrapper = "crate::id::SourceId")]
265    pub associated_source_id: crate::id::SourceId,
266}
267#[derive(prost_helpers::AnyPB)]
268#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
269pub struct RefreshResponse {
270    #[prost(message, optional, tag = "1")]
271    pub status: ::core::option::Option<super::common::Status>,
272}
273#[derive(prost_helpers::AnyPB)]
274#[derive(Clone, PartialEq, ::prost::Message)]
275pub struct CancelCreatingJobsRequest {
276    #[prost(oneof = "cancel_creating_jobs_request::Jobs", tags = "1, 2")]
277    pub jobs: ::core::option::Option<cancel_creating_jobs_request::Jobs>,
278}
279/// Nested message and enum types in `CancelCreatingJobsRequest`.
280pub mod cancel_creating_jobs_request {
281    #[derive(prost_helpers::AnyPB)]
282    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
283    pub struct CreatingJobInfo {
284        #[prost(uint32, tag = "1", wrapper = "crate::id::DatabaseId")]
285        pub database_id: crate::id::DatabaseId,
286        #[prost(uint32, tag = "2", wrapper = "crate::id::SchemaId")]
287        pub schema_id: crate::id::SchemaId,
288        #[prost(string, tag = "3")]
289        pub name: ::prost::alloc::string::String,
290    }
291    #[derive(prost_helpers::AnyPB)]
292    #[derive(Clone, PartialEq, ::prost::Message)]
293    pub struct CreatingJobInfos {
294        #[prost(message, repeated, tag = "1")]
295        pub infos: ::prost::alloc::vec::Vec<CreatingJobInfo>,
296    }
297    #[derive(prost_helpers::AnyPB)]
298    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
299    pub struct CreatingJobIds {
300        #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::JobId")]
301        pub job_ids: ::prost::alloc::vec::Vec<crate::id::JobId>,
302    }
303    #[derive(prost_helpers::AnyPB)]
304    #[derive(Clone, PartialEq, ::prost::Oneof)]
305    pub enum Jobs {
306        #[prost(message, tag = "1")]
307        Infos(CreatingJobInfos),
308        #[prost(message, tag = "2")]
309        Ids(CreatingJobIds),
310    }
311}
312#[derive(prost_helpers::AnyPB)]
313#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
314pub struct CancelCreatingJobsResponse {
315    #[prost(message, optional, tag = "1")]
316    pub status: ::core::option::Option<super::common::Status>,
317    #[prost(uint32, repeated, tag = "2")]
318    pub canceled_jobs: ::prost::alloc::vec::Vec<u32>,
319}
320#[derive(prost_helpers::AnyPB)]
321#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
322pub struct ListTableFragmentsRequest {
323    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::JobId")]
324    pub table_ids: ::prost::alloc::vec::Vec<crate::id::JobId>,
325}
326#[derive(prost_helpers::AnyPB)]
327#[derive(Clone, PartialEq, ::prost::Message)]
328pub struct ListTableFragmentsResponse {
329    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::JobId")]
330    pub table_fragments: ::std::collections::HashMap<
331        crate::id::JobId,
332        list_table_fragments_response::TableFragmentInfo,
333    >,
334}
335/// Nested message and enum types in `ListTableFragmentsResponse`.
336pub mod list_table_fragments_response {
337    #[derive(prost_helpers::AnyPB)]
338    #[derive(Clone, PartialEq, ::prost::Message)]
339    pub struct ActorInfo {
340        #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
341        pub id: crate::id::ActorId,
342        #[prost(message, optional, tag = "2")]
343        pub node: ::core::option::Option<super::super::stream_plan::StreamNode>,
344        #[prost(message, repeated, tag = "3")]
345        pub dispatcher: ::prost::alloc::vec::Vec<super::super::stream_plan::Dispatcher>,
346    }
347    #[derive(prost_helpers::AnyPB)]
348    #[derive(Clone, PartialEq, ::prost::Message)]
349    pub struct FragmentInfo {
350        #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
351        pub id: crate::id::FragmentId,
352        #[prost(message, repeated, tag = "4")]
353        pub actors: ::prost::alloc::vec::Vec<ActorInfo>,
354    }
355    #[derive(prost_helpers::AnyPB)]
356    #[derive(Clone, PartialEq, ::prost::Message)]
357    pub struct TableFragmentInfo {
358        #[prost(message, repeated, tag = "1")]
359        pub fragments: ::prost::alloc::vec::Vec<FragmentInfo>,
360        #[prost(message, optional, tag = "2")]
361        pub ctx: ::core::option::Option<super::super::stream_plan::StreamContext>,
362    }
363}
364#[derive(prost_helpers::AnyPB)]
365#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
366pub struct GetFragmentByIdRequest {
367    #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
368    pub fragment_id: crate::id::FragmentId,
369}
370#[derive(prost_helpers::AnyPB)]
371#[derive(Clone, PartialEq, ::prost::Message)]
372pub struct GetFragmentByIdResponse {
373    #[prost(message, optional, tag = "1")]
374    pub distribution: ::core::option::Option<FragmentDistribution>,
375}
376#[derive(prost_helpers::AnyPB)]
377#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
378pub struct GetFragmentVnodesRequest {
379    #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
380    pub fragment_id: crate::id::FragmentId,
381}
382#[derive(prost_helpers::AnyPB)]
383#[derive(Clone, PartialEq, ::prost::Message)]
384pub struct GetFragmentVnodesResponse {
385    #[prost(message, repeated, tag = "1")]
386    pub actor_vnodes: ::prost::alloc::vec::Vec<
387        get_fragment_vnodes_response::ActorVnodes,
388    >,
389}
390/// Nested message and enum types in `GetFragmentVnodesResponse`.
391pub mod get_fragment_vnodes_response {
392    #[derive(prost_helpers::AnyPB)]
393    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
394    pub struct ActorVnodes {
395        #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
396        pub actor_id: crate::id::ActorId,
397        #[prost(uint32, repeated, tag = "2")]
398        pub vnode_indices: ::prost::alloc::vec::Vec<u32>,
399    }
400}
401#[derive(prost_helpers::AnyPB)]
402#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
403pub struct GetActorVnodesRequest {
404    #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
405    pub actor_id: crate::id::ActorId,
406}
407#[derive(prost_helpers::AnyPB)]
408#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
409pub struct GetActorVnodesResponse {
410    #[prost(uint32, repeated, tag = "1")]
411    pub vnode_indices: ::prost::alloc::vec::Vec<u32>,
412}
413#[derive(prost_helpers::AnyPB)]
414#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
415pub struct ListStreamingJobStatesRequest {}
416#[derive(prost_helpers::AnyPB)]
417#[derive(Clone, PartialEq, ::prost::Message)]
418pub struct ListStreamingJobStatesResponse {
419    #[prost(message, repeated, tag = "1")]
420    pub states: ::prost::alloc::vec::Vec<
421        list_streaming_job_states_response::StreamingJobState,
422    >,
423}
424/// Nested message and enum types in `ListStreamingJobStatesResponse`.
425pub mod list_streaming_job_states_response {
426    #[derive(prost_helpers::AnyPB)]
427    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
428    pub struct StreamingJobState {
429        #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
430        pub table_id: crate::id::JobId,
431        #[prost(enumeration = "super::table_fragments::State", tag = "2")]
432        pub state: i32,
433        #[prost(message, optional, tag = "3")]
434        pub parallelism: ::core::option::Option<super::TableParallelism>,
435        #[prost(uint32, tag = "4")]
436        pub max_parallelism: u32,
437        #[prost(string, tag = "5")]
438        pub name: ::prost::alloc::string::String,
439        #[prost(string, tag = "6")]
440        pub resource_group: ::prost::alloc::string::String,
441        #[prost(string, tag = "9")]
442        pub config_override: ::prost::alloc::string::String,
443        #[prost(uint32, tag = "7", wrapper = "crate::id::DatabaseId")]
444        pub database_id: crate::id::DatabaseId,
445        #[prost(uint32, tag = "8", wrapper = "crate::id::SchemaId")]
446        pub schema_id: crate::id::SchemaId,
447        #[prost(string, optional, tag = "10")]
448        pub adaptive_parallelism_strategy: ::core::option::Option<
449            ::prost::alloc::string::String,
450        >,
451    }
452}
453#[derive(prost_helpers::AnyPB)]
454#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
455pub struct ListFragmentDistributionRequest {
456    #[prost(bool, optional, tag = "1")]
457    pub include_node: ::core::option::Option<bool>,
458}
459#[derive(prost_helpers::AnyPB)]
460#[derive(Clone, PartialEq, ::prost::Message)]
461pub struct FragmentDistribution {
462    #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
463    pub fragment_id: crate::id::FragmentId,
464    #[prost(uint32, tag = "2", wrapper = "crate::id::JobId")]
465    pub table_id: crate::id::JobId,
466    #[prost(
467        enumeration = "table_fragments::fragment::FragmentDistributionType",
468        tag = "3"
469    )]
470    pub distribution_type: i32,
471    #[prost(uint32, repeated, tag = "4", wrapper = "crate::id::TableId")]
472    pub state_table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
473    #[prost(uint32, repeated, tag = "5", wrapper = "crate::id::FragmentId")]
474    pub upstream_fragment_ids: ::prost::alloc::vec::Vec<crate::id::FragmentId>,
475    #[prost(uint32, tag = "6")]
476    pub fragment_type_mask: u32,
477    #[prost(uint32, tag = "7")]
478    pub parallelism: u32,
479    #[prost(uint32, tag = "8")]
480    pub vnode_count: u32,
481    #[prost(message, optional, tag = "9")]
482    pub node: ::core::option::Option<super::stream_plan::StreamNode>,
483    #[prost(string, tag = "10")]
484    pub parallelism_policy: ::prost::alloc::string::String,
485}
486#[derive(prost_helpers::AnyPB)]
487#[derive(Clone, PartialEq, ::prost::Message)]
488pub struct ListFragmentDistributionResponse {
489    #[prost(message, repeated, tag = "1")]
490    pub distributions: ::prost::alloc::vec::Vec<FragmentDistribution>,
491}
492/// List fragments containing stream scans, and corresponding
493/// to a streaming job in creation.
494#[derive(prost_helpers::AnyPB)]
495#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
496pub struct ListCreatingFragmentDistributionRequest {
497    #[prost(bool, optional, tag = "1")]
498    pub include_node: ::core::option::Option<bool>,
499}
500/// List fragments containing stream scans, and corresponding
501/// to a streaming job in creation.
502#[derive(prost_helpers::AnyPB)]
503#[derive(Clone, PartialEq, ::prost::Message)]
504pub struct ListCreatingFragmentDistributionResponse {
505    #[prost(message, repeated, tag = "1")]
506    pub distributions: ::prost::alloc::vec::Vec<FragmentDistribution>,
507}
508#[derive(prost_helpers::AnyPB)]
509#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
510pub struct ListSinkLogStoreTablesRequest {}
511#[derive(prost_helpers::AnyPB)]
512#[derive(Clone, PartialEq, ::prost::Message)]
513pub struct ListSinkLogStoreTablesResponse {
514    #[prost(message, repeated, tag = "1")]
515    pub tables: ::prost::alloc::vec::Vec<
516        list_sink_log_store_tables_response::SinkLogStoreTable,
517    >,
518}
519/// Nested message and enum types in `ListSinkLogStoreTablesResponse`.
520pub mod list_sink_log_store_tables_response {
521    #[derive(prost_helpers::AnyPB)]
522    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
523    pub struct SinkLogStoreTable {
524        #[prost(uint32, tag = "1")]
525        pub sink_id: u32,
526        #[prost(uint32, tag = "2")]
527        pub internal_table_id: u32,
528    }
529}
530#[derive(prost_helpers::AnyPB)]
531#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
532pub struct ListActorStatesRequest {}
533#[derive(prost_helpers::AnyPB)]
534#[derive(Clone, PartialEq, ::prost::Message)]
535pub struct ListActorStatesResponse {
536    #[prost(message, repeated, tag = "1")]
537    pub states: ::prost::alloc::vec::Vec<list_actor_states_response::ActorState>,
538}
539/// Nested message and enum types in `ListActorStatesResponse`.
540pub mod list_actor_states_response {
541    #[derive(prost_helpers::AnyPB)]
542    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
543    pub struct ActorState {
544        #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
545        pub actor_id: crate::id::ActorId,
546        #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
547        pub fragment_id: crate::id::FragmentId,
548        #[prost(uint32, tag = "5", wrapper = "crate::id::WorkerId")]
549        pub worker_id: crate::id::WorkerId,
550    }
551}
552#[derive(prost_helpers::AnyPB)]
553#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
554pub struct ListActorSplitsRequest {}
555#[derive(prost_helpers::AnyPB)]
556#[derive(Clone, PartialEq, ::prost::Message)]
557pub struct ListActorSplitsResponse {
558    #[prost(message, repeated, tag = "1")]
559    pub actor_splits: ::prost::alloc::vec::Vec<list_actor_splits_response::ActorSplit>,
560}
561/// Nested message and enum types in `ListActorSplitsResponse`.
562pub mod list_actor_splits_response {
563    #[derive(prost_helpers::AnyPB)]
564    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
565    pub struct ActorSplit {
566        #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
567        pub actor_id: crate::id::ActorId,
568        #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
569        pub fragment_id: crate::id::FragmentId,
570        #[prost(uint32, tag = "3", wrapper = "crate::id::SourceId")]
571        pub source_id: crate::id::SourceId,
572        #[prost(string, tag = "4")]
573        pub split_id: ::prost::alloc::string::String,
574        #[prost(enumeration = "FragmentType", tag = "5")]
575        pub fragment_type: i32,
576    }
577    #[derive(prost_helpers::AnyPB)]
578    #[derive(
579        Clone,
580        Copy,
581        Debug,
582        PartialEq,
583        Eq,
584        Hash,
585        PartialOrd,
586        Ord,
587        ::prost::Enumeration
588    )]
589    #[repr(i32)]
590    pub enum FragmentType {
591        Unspecified = 0,
592        NonSharedSource = 1,
593        SharedSource = 2,
594        SharedSourceBackfill = 3,
595    }
596    impl FragmentType {
597        /// String value of the enum field names used in the ProtoBuf definition.
598        ///
599        /// The values are not transformed in any way and thus are considered stable
600        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
601        pub fn as_str_name(&self) -> &'static str {
602            match self {
603                Self::Unspecified => "UNSPECIFIED",
604                Self::NonSharedSource => "NON_SHARED_SOURCE",
605                Self::SharedSource => "SHARED_SOURCE",
606                Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
607            }
608        }
609        /// Creates an enum from field names used in the ProtoBuf definition.
610        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
611            match value {
612                "UNSPECIFIED" => Some(Self::Unspecified),
613                "NON_SHARED_SOURCE" => Some(Self::NonSharedSource),
614                "SHARED_SOURCE" => Some(Self::SharedSource),
615                "SHARED_SOURCE_BACKFILL" => Some(Self::SharedSourceBackfill),
616                _ => None,
617            }
618        }
619    }
620}
621#[derive(prost_helpers::AnyPB)]
622#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
623pub struct ObjectDependency {
624    #[prost(uint32, tag = "1", wrapper = "crate::id::ObjectId")]
625    pub object_id: crate::id::ObjectId,
626    #[prost(uint32, tag = "2", wrapper = "crate::id::ObjectId")]
627    pub referenced_object_id: crate::id::ObjectId,
628    #[prost(enumeration = "super::common::ObjectType", tag = "3")]
629    pub referenced_object_type: i32,
630}
631#[derive(prost_helpers::AnyPB)]
632#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
633pub struct ApplyThrottleRequest {
634    #[prost(enumeration = "ThrottleTarget", tag = "1")]
635    pub throttle_target: i32,
636    #[prost(enumeration = "super::common::ThrottleType", tag = "2")]
637    pub throttle_type: i32,
638    #[prost(uint32, tag = "3")]
639    pub id: u32,
640    #[prost(uint32, optional, tag = "4")]
641    pub rate: ::core::option::Option<u32>,
642}
643#[derive(prost_helpers::AnyPB)]
644#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
645pub struct ApplyThrottleResponse {
646    #[prost(message, optional, tag = "1")]
647    pub status: ::core::option::Option<super::common::Status>,
648}
649#[derive(prost_helpers::AnyPB)]
650#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
651pub struct RecoverRequest {}
652#[derive(prost_helpers::AnyPB)]
653#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
654pub struct RecoverResponse {}
655#[derive(prost_helpers::AnyPB)]
656#[derive(Clone, PartialEq, ::prost::Message)]
657pub struct AlterConnectorPropsRequest {
658    #[prost(uint32, tag = "1")]
659    pub object_id: u32,
660    #[prost(map = "string, string", tag = "2")]
661    pub changed_props: ::std::collections::HashMap<
662        ::prost::alloc::string::String,
663        ::prost::alloc::string::String,
664    >,
665    #[prost(map = "string, message", tag = "3")]
666    pub changed_secret_refs: ::std::collections::HashMap<
667        ::prost::alloc::string::String,
668        super::secret::SecretRef,
669    >,
670    #[prost(uint32, optional, tag = "4", wrapper = "crate::id::ConnectionId")]
671    pub connector_conn_ref: ::core::option::Option<crate::id::ConnectionId>,
672    #[prost(
673        enumeration = "alter_connector_props_request::AlterConnectorPropsObject",
674        tag = "5"
675    )]
676    pub object_type: i32,
677    #[prost(oneof = "alter_connector_props_request::ExtraOptions", tags = "6")]
678    pub extra_options: ::core::option::Option<
679        alter_connector_props_request::ExtraOptions,
680    >,
681}
682/// Nested message and enum types in `AlterConnectorPropsRequest`.
683pub mod alter_connector_props_request {
684    #[derive(prost_helpers::AnyPB)]
685    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
686    pub struct AlterIcebergTableIds {
687        #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
688        pub source_id: crate::id::SourceId,
689        #[prost(uint32, tag = "2", wrapper = "crate::id::SinkId")]
690        pub sink_id: crate::id::SinkId,
691    }
692    #[derive(prost_helpers::AnyPB)]
693    #[derive(
694        Clone,
695        Copy,
696        Debug,
697        PartialEq,
698        Eq,
699        Hash,
700        PartialOrd,
701        Ord,
702        ::prost::Enumeration
703    )]
704    #[repr(i32)]
705    pub enum AlterConnectorPropsObject {
706        Unspecified = 0,
707        Source = 1,
708        Sink = 2,
709        Connection = 3,
710        IcebergTable = 4,
711    }
712    impl AlterConnectorPropsObject {
713        /// String value of the enum field names used in the ProtoBuf definition.
714        ///
715        /// The values are not transformed in any way and thus are considered stable
716        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
717        pub fn as_str_name(&self) -> &'static str {
718            match self {
719                Self::Unspecified => "UNSPECIFIED",
720                Self::Source => "SOURCE",
721                Self::Sink => "SINK",
722                Self::Connection => "CONNECTION",
723                Self::IcebergTable => "ICEBERG_TABLE",
724            }
725        }
726        /// Creates an enum from field names used in the ProtoBuf definition.
727        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
728            match value {
729                "UNSPECIFIED" => Some(Self::Unspecified),
730                "SOURCE" => Some(Self::Source),
731                "SINK" => Some(Self::Sink),
732                "CONNECTION" => Some(Self::Connection),
733                "ICEBERG_TABLE" => Some(Self::IcebergTable),
734                _ => None,
735            }
736        }
737    }
738    #[derive(prost_helpers::AnyPB)]
739    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
740    pub enum ExtraOptions {
741        #[prost(message, tag = "6")]
742        AlterIcebergTableIds(AlterIcebergTableIds),
743    }
744}
745#[derive(prost_helpers::AnyPB)]
746#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
747pub struct AlterConnectorPropsResponse {}
748/// Options for controlling the safe property update workflow
749#[derive(prost_helpers::AnyPB)]
750#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
751pub struct PropertyUpdateOptions {
752    /// If true, reset split assignments after updating properties
753    /// This causes splits to be re-discovered from upstream
754    #[prost(bool, tag = "1")]
755    pub reset_splits: bool,
756}
757/// Request for orchestrated source property update with pause/resume
758#[derive(prost_helpers::AnyPB)]
759#[derive(Clone, PartialEq, ::prost::Message)]
760pub struct AlterSourcePropertiesSafeRequest {
761    #[prost(uint32, tag = "1")]
762    pub source_id: u32,
763    #[prost(map = "string, string", tag = "2")]
764    pub changed_props: ::std::collections::HashMap<
765        ::prost::alloc::string::String,
766        ::prost::alloc::string::String,
767    >,
768    #[prost(map = "string, message", tag = "3")]
769    pub changed_secret_refs: ::std::collections::HashMap<
770        ::prost::alloc::string::String,
771        super::secret::SecretRef,
772    >,
773    #[prost(message, optional, tag = "4")]
774    pub options: ::core::option::Option<PropertyUpdateOptions>,
775}
776#[derive(prost_helpers::AnyPB)]
777#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
778pub struct AlterSourcePropertiesSafeResponse {}
779/// Request to reset source split assignments (UNSAFE - admin only)
780#[derive(prost_helpers::AnyPB)]
781#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
782pub struct ResetSourceSplitsRequest {
783    #[prost(uint32, tag = "1")]
784    pub source_id: u32,
785}
786#[derive(prost_helpers::AnyPB)]
787#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
788pub struct ResetSourceSplitsResponse {}
789/// Request to inject specific offsets into source splits (UNSAFE - admin only)
790#[derive(prost_helpers::AnyPB)]
791#[derive(Clone, PartialEq, ::prost::Message)]
792pub struct InjectSourceOffsetsRequest {
793    #[prost(uint32, tag = "1")]
794    pub source_id: u32,
795    /// Split ID -> offset (JSON-encoded based on connector type)
796    #[prost(map = "string, string", tag = "2")]
797    pub split_offsets: ::std::collections::HashMap<
798        ::prost::alloc::string::String,
799        ::prost::alloc::string::String,
800    >,
801}
802#[derive(prost_helpers::AnyPB)]
803#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
804pub struct InjectSourceOffsetsResponse {
805    #[prost(string, repeated, tag = "1")]
806    pub applied_split_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
807}
808#[derive(prost_helpers::AnyPB)]
809#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
810pub struct ListCdcProgressRequest {}
811#[derive(prost_helpers::AnyPB)]
812#[derive(Clone, PartialEq, ::prost::Message)]
813pub struct ListCdcProgressResponse {
814    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::JobId")]
815    pub cdc_progress: ::std::collections::HashMap<
816        crate::id::JobId,
817        list_cdc_progress_response::CdcProgress,
818    >,
819}
820/// Nested message and enum types in `ListCdcProgressResponse`.
821pub mod list_cdc_progress_response {
822    #[derive(prost_helpers::AnyPB)]
823    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
824    pub struct CdcProgress {
825        #[prost(uint64, tag = "1")]
826        pub split_total_count: u64,
827        #[prost(uint64, tag = "2")]
828        pub split_backfilled_count: u64,
829        #[prost(uint64, tag = "3")]
830        pub split_completed_count: u64,
831    }
832}
833#[derive(prost_helpers::AnyPB)]
834#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
835pub struct ListRefreshTableStatesRequest {}
836#[derive(prost_helpers::AnyPB)]
837#[derive(Clone, PartialEq, ::prost::Message)]
838pub struct ListRefreshTableStatesResponse {
839    #[prost(message, repeated, tag = "1")]
840    pub states: ::prost::alloc::vec::Vec<
841        list_refresh_table_states_response::RefreshTableState,
842    >,
843}
844/// Nested message and enum types in `ListRefreshTableStatesResponse`.
845pub mod list_refresh_table_states_response {
846    #[derive(prost_helpers::AnyPB)]
847    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
848    pub struct RefreshTableState {
849        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
850        pub table_id: crate::id::TableId,
851        #[prost(string, tag = "2")]
852        pub current_status: ::prost::alloc::string::String,
853        #[prost(string, optional, tag = "3")]
854        pub last_trigger_time: ::core::option::Option<::prost::alloc::string::String>,
855        #[prost(int64, optional, tag = "4")]
856        pub trigger_interval_secs: ::core::option::Option<i64>,
857        #[prost(string, optional, tag = "5")]
858        pub last_success_time: ::core::option::Option<::prost::alloc::string::String>,
859    }
860}
861#[derive(prost_helpers::AnyPB)]
862#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
863pub struct ListIcebergCompactionStatusRequest {}
864#[derive(prost_helpers::AnyPB)]
865#[derive(Clone, PartialEq, ::prost::Message)]
866pub struct ListIcebergCompactionStatusResponse {
867    #[prost(message, repeated, tag = "1")]
868    pub statuses: ::prost::alloc::vec::Vec<
869        list_iceberg_compaction_status_response::IcebergCompactionStatus,
870    >,
871}
872/// Nested message and enum types in `ListIcebergCompactionStatusResponse`.
873pub mod list_iceberg_compaction_status_response {
874    #[derive(prost_helpers::AnyPB)]
875    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
876    pub struct IcebergCompactionStatus {
877        #[prost(uint32, tag = "1")]
878        pub sink_id: u32,
879        #[prost(string, tag = "2")]
880        pub task_type: ::prost::alloc::string::String,
881        #[prost(uint64, tag = "3")]
882        pub trigger_interval_sec: u64,
883        #[prost(uint64, tag = "4")]
884        pub trigger_snapshot_count: u64,
885        #[prost(string, tag = "5")]
886        pub schedule_state: ::prost::alloc::string::String,
887        #[prost(uint64, optional, tag = "6")]
888        pub next_compaction_after_sec: ::core::option::Option<u64>,
889        /// V1 approximates pending snapshot backlog with in-memory sink commit backlog.
890        #[prost(uint64, optional, tag = "7")]
891        pub pending_snapshot_count: ::core::option::Option<u64>,
892        #[prost(bool, tag = "8")]
893        pub is_triggerable: bool,
894    }
895}
896/// Below for cluster service.
897#[derive(prost_helpers::AnyPB)]
898#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
899pub struct AddWorkerNodeRequest {
900    #[prost(enumeration = "super::common::WorkerType", tag = "1")]
901    pub worker_type: i32,
902    #[prost(message, optional, tag = "2")]
903    pub host: ::core::option::Option<super::common::HostAddress>,
904    #[prost(message, optional, tag = "5")]
905    pub resource: ::core::option::Option<super::common::worker_node::Resource>,
906    #[prost(message, optional, tag = "6")]
907    pub property: ::core::option::Option<super::common::worker_node::Property>,
908}
909#[derive(prost_helpers::AnyPB)]
910#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
911pub struct AddWorkerNodeResponse {
912    #[prost(uint32, optional, tag = "2", wrapper = "crate::id::WorkerId")]
913    pub node_id: ::core::option::Option<crate::id::WorkerId>,
914    #[prost(string, tag = "4")]
915    pub cluster_id: ::prost::alloc::string::String,
916}
917#[derive(prost_helpers::AnyPB)]
918#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
919pub struct ActivateWorkerNodeRequest {
920    #[prost(message, optional, tag = "1")]
921    pub host: ::core::option::Option<super::common::HostAddress>,
922    #[prost(uint32, tag = "2", wrapper = "crate::id::WorkerId")]
923    pub node_id: crate::id::WorkerId,
924}
925#[derive(prost_helpers::AnyPB)]
926#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
927pub struct ActivateWorkerNodeResponse {
928    #[prost(message, optional, tag = "1")]
929    pub status: ::core::option::Option<super::common::Status>,
930}
931#[derive(prost_helpers::AnyPB)]
932#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
933pub struct DeleteWorkerNodeRequest {
934    #[prost(message, optional, tag = "1")]
935    pub host: ::core::option::Option<super::common::HostAddress>,
936}
937#[derive(prost_helpers::AnyPB)]
938#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
939pub struct DeleteWorkerNodeResponse {
940    #[prost(message, optional, tag = "1")]
941    pub status: ::core::option::Option<super::common::Status>,
942}
943#[derive(prost_helpers::AnyPB)]
944#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
945pub struct ListAllNodesRequest {
946    #[prost(enumeration = "super::common::WorkerType", optional, tag = "1")]
947    pub worker_type: ::core::option::Option<i32>,
948    /// Whether to include nodes still starting
949    #[prost(bool, tag = "2")]
950    pub include_starting_nodes: bool,
951}
952#[derive(prost_helpers::AnyPB)]
953#[derive(Clone, PartialEq, ::prost::Message)]
954pub struct ListAllNodesResponse {
955    #[prost(message, optional, tag = "1")]
956    pub status: ::core::option::Option<super::common::Status>,
957    #[prost(message, repeated, tag = "2")]
958    pub nodes: ::prost::alloc::vec::Vec<super::common::WorkerNode>,
959}
960#[derive(prost_helpers::AnyPB)]
961#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
962pub struct GetClusterRecoveryStatusRequest {}
963#[derive(prost_helpers::AnyPB)]
964#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
965pub struct GetClusterRecoveryStatusResponse {
966    #[prost(enumeration = "RecoveryStatus", tag = "1")]
967    pub status: i32,
968}
969#[derive(prost_helpers::AnyPB)]
970#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
971pub struct GetMetaStoreInfoRequest {}
972#[derive(prost_helpers::AnyPB)]
973#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
974pub struct GetMetaStoreInfoResponse {
975    #[prost(string, tag = "1")]
976    pub meta_store_endpoint: ::prost::alloc::string::String,
977}
978/// Below for notification service.
979#[derive(prost_helpers::AnyPB)]
980#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
981pub struct SubscribeRequest {
982    #[prost(enumeration = "SubscribeType", tag = "1")]
983    pub subscribe_type: i32,
984    #[prost(message, optional, tag = "2")]
985    pub host: ::core::option::Option<super::common::HostAddress>,
986    #[prost(uint32, tag = "3", wrapper = "crate::id::WorkerId")]
987    pub worker_id: crate::id::WorkerId,
988}
989#[derive(prost_helpers::AnyPB)]
990#[derive(Clone, PartialEq, ::prost::Message)]
991pub struct MetaSnapshot {
992    #[prost(message, repeated, tag = "1")]
993    pub databases: ::prost::alloc::vec::Vec<super::catalog::Database>,
994    #[prost(message, repeated, tag = "2")]
995    pub schemas: ::prost::alloc::vec::Vec<super::catalog::Schema>,
996    #[prost(message, repeated, tag = "3")]
997    pub sources: ::prost::alloc::vec::Vec<super::catalog::Source>,
998    #[prost(message, repeated, tag = "4")]
999    pub sinks: ::prost::alloc::vec::Vec<super::catalog::Sink>,
1000    #[prost(message, repeated, tag = "5")]
1001    pub tables: ::prost::alloc::vec::Vec<super::catalog::Table>,
1002    #[prost(message, repeated, tag = "6")]
1003    pub indexes: ::prost::alloc::vec::Vec<super::catalog::Index>,
1004    #[prost(message, repeated, tag = "7")]
1005    pub views: ::prost::alloc::vec::Vec<super::catalog::View>,
1006    #[prost(message, repeated, tag = "15")]
1007    pub functions: ::prost::alloc::vec::Vec<super::catalog::Function>,
1008    #[prost(message, repeated, tag = "17")]
1009    pub connections: ::prost::alloc::vec::Vec<super::catalog::Connection>,
1010    #[prost(message, repeated, tag = "19")]
1011    pub subscriptions: ::prost::alloc::vec::Vec<super::catalog::Subscription>,
1012    #[prost(message, repeated, tag = "8")]
1013    pub users: ::prost::alloc::vec::Vec<super::user::UserInfo>,
1014    #[prost(message, optional, tag = "20")]
1015    pub session_params: ::core::option::Option<GetSessionParamsResponse>,
1016    #[prost(message, repeated, tag = "23")]
1017    pub secrets: ::prost::alloc::vec::Vec<super::catalog::Secret>,
1018    #[prost(message, optional, tag = "25")]
1019    pub cluster_resource: ::core::option::Option<super::common::ClusterResource>,
1020    #[prost(message, repeated, tag = "10")]
1021    pub nodes: ::prost::alloc::vec::Vec<super::common::WorkerNode>,
1022    #[prost(message, optional, tag = "12")]
1023    pub hummock_version: ::core::option::Option<super::hummock::HummockVersion>,
1024    #[prost(message, optional, tag = "14")]
1025    pub meta_backup_manifest_id: ::core::option::Option<
1026        super::backup_service::MetaBackupManifestId,
1027    >,
1028    #[prost(message, optional, tag = "16")]
1029    pub hummock_write_limits: ::core::option::Option<super::hummock::WriteLimits>,
1030    /// for streaming
1031    #[prost(message, repeated, tag = "21")]
1032    pub streaming_worker_slot_mappings: ::prost::alloc::vec::Vec<
1033        FragmentWorkerSlotMapping,
1034    >,
1035    #[prost(message, repeated, tag = "22")]
1036    pub serving_worker_slot_mappings: ::prost::alloc::vec::Vec<
1037        FragmentWorkerSlotMapping,
1038    >,
1039    #[prost(message, repeated, tag = "26")]
1040    pub object_dependencies: ::prost::alloc::vec::Vec<ObjectDependency>,
1041    #[prost(message, optional, tag = "13")]
1042    pub version: ::core::option::Option<meta_snapshot::SnapshotVersion>,
1043}
1044/// Nested message and enum types in `MetaSnapshot`.
1045pub mod meta_snapshot {
1046    #[derive(prost_helpers::AnyPB)]
1047    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1048    pub struct SnapshotVersion {
1049        #[prost(uint64, tag = "1")]
1050        pub catalog_version: u64,
1051        #[prost(uint64, tag = "3")]
1052        pub worker_node_version: u64,
1053        #[prost(uint64, tag = "4")]
1054        pub streaming_worker_slot_mapping_version: u64,
1055    }
1056}
1057#[derive(prost_helpers::AnyPB)]
1058#[derive(Clone, PartialEq, ::prost::Message)]
1059pub struct Object {
1060    #[prost(oneof = "object::ObjectInfo", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11")]
1061    pub object_info: ::core::option::Option<object::ObjectInfo>,
1062}
1063/// Nested message and enum types in `Object`.
1064pub mod object {
1065    #[derive(prost_helpers::AnyPB)]
1066    #[derive(strum::Display)]
1067    #[derive(Clone, PartialEq, ::prost::Oneof)]
1068    pub enum ObjectInfo {
1069        #[prost(message, tag = "1")]
1070        Database(super::super::catalog::Database),
1071        #[prost(message, tag = "2")]
1072        Schema(super::super::catalog::Schema),
1073        #[prost(message, tag = "3")]
1074        Table(super::super::catalog::Table),
1075        #[prost(message, tag = "4")]
1076        Index(super::super::catalog::Index),
1077        #[prost(message, tag = "5")]
1078        Source(super::super::catalog::Source),
1079        #[prost(message, tag = "6")]
1080        Sink(super::super::catalog::Sink),
1081        #[prost(message, tag = "7")]
1082        View(super::super::catalog::View),
1083        #[prost(message, tag = "8")]
1084        Function(super::super::catalog::Function),
1085        #[prost(message, tag = "9")]
1086        Connection(super::super::catalog::Connection),
1087        #[prost(message, tag = "10")]
1088        Subscription(super::super::catalog::Subscription),
1089        #[prost(message, tag = "11")]
1090        Secret(super::super::catalog::Secret),
1091    }
1092}
1093#[derive(prost_helpers::AnyPB)]
1094#[derive(Clone, PartialEq, ::prost::Message)]
1095pub struct ObjectGroup {
1096    #[prost(message, repeated, tag = "1")]
1097    pub objects: ::prost::alloc::vec::Vec<Object>,
1098    #[prost(message, repeated, tag = "2")]
1099    pub dependencies: ::prost::alloc::vec::Vec<ObjectDependency>,
1100}
1101#[derive(prost_helpers::AnyPB)]
1102#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1103pub struct Recovery {}
1104#[derive(prost_helpers::AnyPB)]
1105#[derive(Clone, PartialEq, ::prost::Message)]
1106pub struct SubscribeResponse {
1107    #[prost(message, optional, tag = "1")]
1108    pub status: ::core::option::Option<super::common::Status>,
1109    #[prost(enumeration = "subscribe_response::Operation", tag = "2")]
1110    pub operation: i32,
1111    /// Catalog version
1112    #[prost(uint64, tag = "3")]
1113    pub version: u64,
1114    #[prost(
1115        oneof = "subscribe_response::Info",
1116        tags = "4, 5, 6, 11, 26, 13, 15, 16, 17, 19, 20, 21, 22, 24, 25, 27, 28, 29, 31"
1117    )]
1118    pub info: ::core::option::Option<subscribe_response::Info>,
1119}
1120/// Nested message and enum types in `SubscribeResponse`.
1121pub mod subscribe_response {
1122    #[derive(prost_helpers::AnyPB)]
1123    #[derive(
1124        Clone,
1125        Copy,
1126        Debug,
1127        PartialEq,
1128        Eq,
1129        Hash,
1130        PartialOrd,
1131        Ord,
1132        ::prost::Enumeration
1133    )]
1134    #[repr(i32)]
1135    pub enum Operation {
1136        Unspecified = 0,
1137        Add = 1,
1138        Delete = 2,
1139        Update = 3,
1140        Snapshot = 4,
1141    }
1142    impl Operation {
1143        /// String value of the enum field names used in the ProtoBuf definition.
1144        ///
1145        /// The values are not transformed in any way and thus are considered stable
1146        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1147        pub fn as_str_name(&self) -> &'static str {
1148            match self {
1149                Self::Unspecified => "UNSPECIFIED",
1150                Self::Add => "ADD",
1151                Self::Delete => "DELETE",
1152                Self::Update => "UPDATE",
1153                Self::Snapshot => "SNAPSHOT",
1154            }
1155        }
1156        /// Creates an enum from field names used in the ProtoBuf definition.
1157        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1158            match value {
1159                "UNSPECIFIED" => Some(Self::Unspecified),
1160                "ADD" => Some(Self::Add),
1161                "DELETE" => Some(Self::Delete),
1162                "UPDATE" => Some(Self::Update),
1163                "SNAPSHOT" => Some(Self::Snapshot),
1164                _ => None,
1165            }
1166        }
1167    }
1168    #[derive(prost_helpers::AnyPB)]
1169    #[derive(strum::Display)]
1170    #[derive(Clone, PartialEq, ::prost::Oneof)]
1171    pub enum Info {
1172        #[prost(message, tag = "4")]
1173        Database(super::super::catalog::Database),
1174        #[prost(message, tag = "5")]
1175        Schema(super::super::catalog::Schema),
1176        #[prost(message, tag = "6")]
1177        Function(super::super::catalog::Function),
1178        #[prost(message, tag = "11")]
1179        User(super::super::user::UserInfo),
1180        #[prost(message, tag = "26")]
1181        SessionParam(super::SetSessionParamRequest),
1182        #[prost(message, tag = "13")]
1183        Node(super::super::common::WorkerNode),
1184        #[prost(message, tag = "15")]
1185        HummockVersionDeltas(super::super::hummock::HummockVersionDeltas),
1186        #[prost(message, tag = "16")]
1187        Snapshot(super::MetaSnapshot),
1188        #[prost(message, tag = "17")]
1189        MetaBackupManifestId(super::super::backup_service::MetaBackupManifestId),
1190        #[prost(message, tag = "19")]
1191        SystemParams(super::SystemParams),
1192        #[prost(message, tag = "20")]
1193        HummockWriteLimits(super::super::hummock::WriteLimits),
1194        #[prost(message, tag = "21")]
1195        ObjectGroup(super::ObjectGroup),
1196        #[prost(message, tag = "22")]
1197        Connection(super::super::catalog::Connection),
1198        #[prost(message, tag = "24")]
1199        HummockStats(super::super::hummock::HummockVersionStats),
1200        #[prost(message, tag = "25")]
1201        Recovery(super::Recovery),
1202        #[prost(message, tag = "27")]
1203        StreamingWorkerSlotMapping(super::FragmentWorkerSlotMapping),
1204        #[prost(message, tag = "28")]
1205        ServingWorkerSlotMappings(super::FragmentWorkerSlotMappings),
1206        #[prost(message, tag = "29")]
1207        Secret(super::super::catalog::Secret),
1208        #[prost(message, tag = "31")]
1209        ClusterResource(super::super::common::ClusterResource),
1210    }
1211}
1212#[derive(prost_helpers::AnyPB)]
1213#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1214pub struct GetClusterInfoRequest {}
1215#[derive(prost_helpers::AnyPB)]
1216#[derive(Clone, PartialEq, ::prost::Message)]
1217pub struct GetClusterInfoResponse {
1218    #[prost(message, repeated, tag = "1")]
1219    pub worker_nodes: ::prost::alloc::vec::Vec<super::common::WorkerNode>,
1220    #[prost(message, repeated, tag = "2")]
1221    pub table_fragments: ::prost::alloc::vec::Vec<TableFragments>,
1222    /// `Source` and `SourceBackfill` are handled together here.
1223    #[prost(map = "uint32, message", tag = "3", wrapper = "crate::id::ActorId")]
1224    pub actor_splits: ::std::collections::HashMap<
1225        crate::id::ActorId,
1226        super::source::ConnectorSplits,
1227    >,
1228    #[prost(map = "uint32, message", tag = "4", wrapper = "crate::id::SourceId")]
1229    pub source_infos: ::std::collections::HashMap<
1230        crate::id::SourceId,
1231        super::catalog::Source,
1232    >,
1233    #[prost(uint64, tag = "5")]
1234    pub revision: u64,
1235}
1236/// For each fragment that needs to be rescheduled, there will be a WorkerReschedule,
1237/// indicating on which workers the actors of this fragment need to be changed and by how many.
1238#[derive(prost_helpers::AnyPB)]
1239#[derive(Clone, PartialEq, ::prost::Message)]
1240pub struct WorkerReschedule {
1241    /// worker_id -> actor_diff
1242    #[prost(map = "uint32, int32", tag = "1", wrapper = "crate::id::WorkerId")]
1243    pub worker_actor_diff: ::std::collections::HashMap<crate::id::WorkerId, i32>,
1244}
1245#[derive(prost_helpers::AnyPB)]
1246#[derive(Clone, PartialEq, ::prost::Message)]
1247pub struct RescheduleRequest {
1248    #[prost(uint64, tag = "2")]
1249    pub revision: u64,
1250    #[prost(bool, tag = "3")]
1251    pub resolve_no_shuffle_upstream: bool,
1252    #[prost(map = "uint32, message", tag = "4")]
1253    pub worker_reschedules: ::std::collections::HashMap<u32, WorkerReschedule>,
1254}
1255#[derive(prost_helpers::AnyPB)]
1256#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1257pub struct RescheduleResponse {
1258    #[prost(bool, tag = "1")]
1259    pub success: bool,
1260    #[prost(uint64, tag = "2")]
1261    pub revision: u64,
1262}
1263#[derive(prost_helpers::AnyPB)]
1264#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1265pub struct TableParallelism {
1266    #[prost(oneof = "table_parallelism::Parallelism", tags = "1, 2, 3, 4")]
1267    pub parallelism: ::core::option::Option<table_parallelism::Parallelism>,
1268}
1269/// Nested message and enum types in `TableParallelism`.
1270pub mod table_parallelism {
1271    #[derive(prost_helpers::AnyPB)]
1272    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1273    pub struct FixedParallelism {
1274        #[prost(uint32, tag = "1")]
1275        pub parallelism: u32,
1276    }
1277    /// deprecated, treated as AdaptiveParallelism
1278    #[derive(prost_helpers::AnyPB)]
1279    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1280    pub struct AutoParallelism {}
1281    #[derive(prost_helpers::AnyPB)]
1282    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1283    pub struct AdaptiveParallelism {}
1284    #[derive(prost_helpers::AnyPB)]
1285    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1286    pub struct CustomParallelism {}
1287    #[derive(prost_helpers::AnyPB)]
1288    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
1289    pub enum Parallelism {
1290        #[prost(message, tag = "1")]
1291        Fixed(FixedParallelism),
1292        #[prost(message, tag = "2")]
1293        Auto(AutoParallelism),
1294        #[prost(message, tag = "3")]
1295        Custom(CustomParallelism),
1296        #[prost(message, tag = "4")]
1297        Adaptive(AdaptiveParallelism),
1298    }
1299}
1300/// Changes a streaming job in place by overwriting its node_label.
1301/// This may cause the re-scheduling of the streaming job actors.
1302#[derive(prost_helpers::AnyPB)]
1303#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1304pub struct UpdateStreamingJobNodeLabelsRequest {
1305    /// Id of the materialized view, table, or sink which we want to update
1306    #[prost(uint32, tag = "1")]
1307    pub id: u32,
1308    /// replace the node_label of the streaming job with a given id with below value
1309    #[prost(string, tag = "2")]
1310    pub node_label: ::prost::alloc::string::String,
1311}
1312/// We do not need to add an explicit status field here, we can just use the RPC status
1313#[derive(prost_helpers::AnyPB)]
1314#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1315pub struct UpdateStreamingJobNodeLabelsResponse {}
1316#[derive(prost_helpers::AnyPB)]
1317#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1318pub struct GetServerlessStreamingJobsStatusRequest {}
1319/// Descriptions of MVs and sinks
1320#[derive(prost_helpers::AnyPB)]
1321#[derive(Clone, PartialEq, ::prost::Message)]
1322pub struct GetServerlessStreamingJobsStatusResponse {
1323    #[prost(message, repeated, tag = "1")]
1324    pub streaming_job_statuses: ::prost::alloc::vec::Vec<
1325        get_serverless_streaming_jobs_status_response::Status,
1326    >,
1327}
1328/// Nested message and enum types in `GetServerlessStreamingJobsStatusResponse`.
1329pub mod get_serverless_streaming_jobs_status_response {
1330    #[derive(prost_helpers::AnyPB)]
1331    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1332    pub struct Status {
1333        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
1334        pub table_id: crate::id::TableId,
1335        #[prost(string, tag = "2")]
1336        pub node_label: ::prost::alloc::string::String,
1337        #[prost(bool, tag = "3")]
1338        pub backfill_done: bool,
1339    }
1340}
1341#[derive(prost_helpers::AnyPB)]
1342#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1343pub struct MembersRequest {}
1344#[derive(prost_helpers::AnyPB)]
1345#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1346pub struct MetaMember {
1347    #[prost(message, optional, tag = "1")]
1348    pub address: ::core::option::Option<super::common::HostAddress>,
1349    #[prost(bool, tag = "2")]
1350    pub is_leader: bool,
1351}
1352#[derive(prost_helpers::AnyPB)]
1353#[derive(Clone, PartialEq, ::prost::Message)]
1354pub struct MembersResponse {
1355    #[prost(message, repeated, tag = "1")]
1356    pub members: ::prost::alloc::vec::Vec<MetaMember>,
1357}
1358/// The schema for persisted system parameters.
1359/// Note on backward compatibility:
1360///
1361/// * Do not remove deprecated fields. Mark them as deprecated instead.
1362/// * Do not rename existing fields, since each field is stored separately in the meta store with the field name as the key.
1363/// * To modify (rename, change the type or semantic of) a field, introduce a new field suffixed by the version.
1364#[derive(prost_helpers::AnyPB)]
1365#[derive(Clone, PartialEq, ::prost::Message)]
1366#[prost(skip_debug)]
1367pub struct SystemParams {
1368    #[prost(uint32, optional, tag = "1")]
1369    pub barrier_interval_ms: ::core::option::Option<u32>,
1370    #[prost(uint64, optional, tag = "2")]
1371    pub checkpoint_frequency: ::core::option::Option<u64>,
1372    #[prost(uint32, optional, tag = "3")]
1373    pub sstable_size_mb: ::core::option::Option<u32>,
1374    #[prost(uint32, optional, tag = "4")]
1375    pub block_size_kb: ::core::option::Option<u32>,
1376    /// Deprecated. Bloom filter is no longer a supported SST filter implementation; the field is
1377    /// kept for backward compatibility and no longer controls whether SST filters are emitted.
1378    #[deprecated]
1379    #[prost(double, optional, tag = "5")]
1380    pub bloom_false_positive: ::core::option::Option<f64>,
1381    #[prost(string, optional, tag = "6")]
1382    pub state_store: ::core::option::Option<::prost::alloc::string::String>,
1383    #[prost(string, optional, tag = "7")]
1384    pub data_directory: ::core::option::Option<::prost::alloc::string::String>,
1385    #[prost(string, optional, tag = "8")]
1386    pub backup_storage_url: ::core::option::Option<::prost::alloc::string::String>,
1387    #[prost(string, optional, tag = "9")]
1388    pub backup_storage_directory: ::core::option::Option<::prost::alloc::string::String>,
1389    /// Deprecated. Use config file instead.
1390    #[deprecated]
1391    #[prost(bool, optional, tag = "10")]
1392    pub telemetry_enabled: ::core::option::Option<bool>,
1393    #[prost(uint32, optional, tag = "11")]
1394    pub parallel_compact_size_mb: ::core::option::Option<u32>,
1395    #[prost(uint32, optional, tag = "12")]
1396    pub max_concurrent_creating_streaming_jobs: ::core::option::Option<u32>,
1397    #[prost(bool, optional, tag = "13")]
1398    pub pause_on_next_bootstrap: ::core::option::Option<bool>,
1399    #[deprecated]
1400    #[prost(string, optional, tag = "14")]
1401    pub wasm_storage_url: ::core::option::Option<::prost::alloc::string::String>,
1402    #[prost(bool, optional, tag = "15")]
1403    pub enable_tracing: ::core::option::Option<bool>,
1404    #[prost(bool, optional, tag = "16")]
1405    pub use_new_object_prefix_strategy: ::core::option::Option<bool>,
1406    #[prost(string, optional, tag = "17")]
1407    pub license_key: ::core::option::Option<::prost::alloc::string::String>,
1408    #[prost(uint64, optional, tag = "18")]
1409    pub time_travel_retention_ms: ::core::option::Option<u64>,
1410    #[prost(string, optional, tag = "19")]
1411    pub adaptive_parallelism_strategy: ::core::option::Option<
1412        ::prost::alloc::string::String,
1413    >,
1414    #[prost(bool, optional, tag = "20")]
1415    pub per_database_isolation: ::core::option::Option<bool>,
1416    #[prost(bool, optional, tag = "21")]
1417    pub enforce_secret: ::core::option::Option<bool>,
1418}
1419#[derive(prost_helpers::AnyPB)]
1420#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1421pub struct GetSystemParamsRequest {}
1422#[derive(prost_helpers::AnyPB)]
1423#[derive(Clone, PartialEq, ::prost::Message)]
1424pub struct GetSystemParamsResponse {
1425    #[prost(message, optional, tag = "1")]
1426    pub params: ::core::option::Option<SystemParams>,
1427}
1428#[derive(prost_helpers::AnyPB)]
1429#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1430pub struct SetSystemParamRequest {
1431    #[prost(string, tag = "1")]
1432    pub param: ::prost::alloc::string::String,
1433    /// None means set to default value.
1434    #[prost(string, optional, tag = "2")]
1435    pub value: ::core::option::Option<::prost::alloc::string::String>,
1436}
1437#[derive(prost_helpers::AnyPB)]
1438#[derive(Clone, PartialEq, ::prost::Message)]
1439pub struct SetSystemParamResponse {
1440    #[prost(message, optional, tag = "1")]
1441    pub params: ::core::option::Option<SystemParams>,
1442}
1443#[derive(prost_helpers::AnyPB)]
1444#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1445pub struct GetSessionParamsRequest {}
1446#[derive(prost_helpers::AnyPB)]
1447#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1448pub struct GetSessionParamsResponse {
1449    #[prost(string, tag = "1")]
1450    pub params: ::prost::alloc::string::String,
1451}
1452#[derive(prost_helpers::AnyPB)]
1453#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1454pub struct SetSessionParamRequest {
1455    #[prost(string, tag = "1")]
1456    pub param: ::prost::alloc::string::String,
1457    /// None means set to default value.
1458    #[prost(string, optional, tag = "2")]
1459    pub value: ::core::option::Option<::prost::alloc::string::String>,
1460}
1461#[derive(prost_helpers::AnyPB)]
1462#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1463pub struct SetSessionParamResponse {
1464    #[prost(string, tag = "1")]
1465    pub param: ::prost::alloc::string::String,
1466}
1467#[derive(prost_helpers::AnyPB)]
1468#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1469pub struct GetServingVnodeMappingsRequest {}
1470#[derive(prost_helpers::AnyPB)]
1471#[derive(Clone, PartialEq, ::prost::Message)]
1472pub struct GetServingVnodeMappingsResponse {
1473    #[prost(
1474        map = "uint32, uint32",
1475        tag = "2",
1476        wrapper = "crate::id::FragmentId ->crate::id:: JobId"
1477    )]
1478    pub fragment_to_table: ::std::collections::HashMap<
1479        crate::id::FragmentId,
1480        crate::id::JobId,
1481    >,
1482    #[prost(message, repeated, tag = "3")]
1483    pub worker_slot_mappings: ::prost::alloc::vec::Vec<FragmentWorkerSlotMapping>,
1484}
1485#[derive(prost_helpers::AnyPB)]
1486#[derive(Clone, PartialEq, ::prost::Message)]
1487pub struct EventLog {
1488    /// Event logs identifier, which should be populated by event log service.
1489    #[prost(string, optional, tag = "1")]
1490    pub unique_id: ::core::option::Option<::prost::alloc::string::String>,
1491    /// Processing time, which should be populated by event log service.
1492    #[prost(uint64, optional, tag = "2")]
1493    pub timestamp: ::core::option::Option<u64>,
1494    #[prost(oneof = "event_log::Event", tags = "3, 4, 5, 6, 7, 8, 9, 10, 11, 12")]
1495    pub event: ::core::option::Option<event_log::Event>,
1496}
1497/// Nested message and enum types in `EventLog`.
1498pub mod event_log {
1499    #[derive(prost_helpers::AnyPB)]
1500    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1501    pub struct EventMetaNodeStart {
1502        #[prost(string, tag = "1")]
1503        pub advertise_addr: ::prost::alloc::string::String,
1504        #[prost(string, tag = "2")]
1505        pub listen_addr: ::prost::alloc::string::String,
1506        #[prost(string, tag = "3")]
1507        pub opts: ::prost::alloc::string::String,
1508    }
1509    #[derive(prost_helpers::AnyPB)]
1510    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1511    pub struct EventCreateStreamJobFail {
1512        #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
1513        pub id: crate::id::JobId,
1514        #[prost(string, tag = "2")]
1515        pub name: ::prost::alloc::string::String,
1516        #[prost(string, tag = "3")]
1517        pub definition: ::prost::alloc::string::String,
1518        #[prost(string, tag = "4")]
1519        pub error: ::prost::alloc::string::String,
1520    }
1521    #[derive(prost_helpers::AnyPB)]
1522    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1523    pub struct EventDirtyStreamJobClear {
1524        #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
1525        pub id: crate::id::JobId,
1526        #[prost(string, tag = "2")]
1527        pub name: ::prost::alloc::string::String,
1528        #[prost(string, tag = "3")]
1529        pub definition: ::prost::alloc::string::String,
1530        #[prost(string, tag = "4")]
1531        pub error: ::prost::alloc::string::String,
1532    }
1533    #[derive(prost_helpers::AnyPB)]
1534    #[derive(Clone, PartialEq, ::prost::Message)]
1535    pub struct EventBarrierComplete {
1536        #[prost(uint64, tag = "1")]
1537        pub prev_epoch: u64,
1538        #[prost(uint64, tag = "2")]
1539        pub cur_epoch: u64,
1540        #[prost(double, tag = "3")]
1541        pub duration_sec: f64,
1542        #[prost(string, tag = "4")]
1543        pub command: ::prost::alloc::string::String,
1544        #[prost(string, tag = "5")]
1545        pub barrier_kind: ::prost::alloc::string::String,
1546        #[prost(uint32, tag = "6")]
1547        pub database_id: u32,
1548    }
1549    #[derive(prost_helpers::AnyPB)]
1550    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1551    pub struct EventInjectBarrierFail {
1552        #[prost(uint64, tag = "1")]
1553        pub prev_epoch: u64,
1554        #[prost(uint64, tag = "2")]
1555        pub cur_epoch: u64,
1556        #[prost(string, tag = "3")]
1557        pub error: ::prost::alloc::string::String,
1558    }
1559    #[derive(prost_helpers::AnyPB)]
1560    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1561    pub struct EventCollectBarrierFail {
1562        #[prost(string, tag = "3")]
1563        pub error: ::prost::alloc::string::String,
1564    }
1565    #[derive(prost_helpers::AnyPB)]
1566    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1567    pub struct EventWorkerNodePanic {
1568        #[prost(uint32, tag = "1", wrapper = "crate::id::WorkerId")]
1569        pub worker_id: crate::id::WorkerId,
1570        #[prost(enumeration = "super::super::common::WorkerType", tag = "2")]
1571        pub worker_type: i32,
1572        #[prost(message, optional, tag = "3")]
1573        pub host_addr: ::core::option::Option<super::super::common::HostAddress>,
1574        #[prost(string, tag = "4")]
1575        pub panic_info: ::prost::alloc::string::String,
1576    }
1577    #[derive(prost_helpers::AnyPB)]
1578    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1579    pub struct EventAutoSchemaChangeFail {
1580        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
1581        pub table_id: crate::id::TableId,
1582        #[prost(string, tag = "2")]
1583        pub table_name: ::prost::alloc::string::String,
1584        #[prost(string, tag = "3")]
1585        pub cdc_table_id: ::prost::alloc::string::String,
1586        #[prost(string, tag = "4")]
1587        pub upstream_ddl: ::prost::alloc::string::String,
1588        #[prost(string, tag = "5")]
1589        pub fail_info: ::prost::alloc::string::String,
1590    }
1591    #[derive(prost_helpers::AnyPB)]
1592    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1593    pub struct EventSinkFail {
1594        #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
1595        pub sink_id: crate::id::SinkId,
1596        #[prost(string, tag = "2")]
1597        pub sink_name: ::prost::alloc::string::String,
1598        #[prost(string, tag = "3")]
1599        pub connector: ::prost::alloc::string::String,
1600        #[prost(string, tag = "4")]
1601        pub error: ::prost::alloc::string::String,
1602    }
1603    #[derive(prost_helpers::AnyPB)]
1604    #[derive(Clone, PartialEq, ::prost::Message)]
1605    pub struct EventRecovery {
1606        #[prost(oneof = "event_recovery::RecoveryEvent", tags = "1, 2, 3, 4, 5, 6")]
1607        pub recovery_event: ::core::option::Option<event_recovery::RecoveryEvent>,
1608    }
1609    /// Nested message and enum types in `EventRecovery`.
1610    pub mod event_recovery {
1611        #[derive(prost_helpers::AnyPB)]
1612        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1613        pub struct GlobalRecoveryStart {
1614            #[prost(string, tag = "1")]
1615            pub reason: ::prost::alloc::string::String,
1616        }
1617        #[derive(prost_helpers::AnyPB)]
1618        #[derive(Clone, PartialEq, ::prost::Message)]
1619        pub struct GlobalRecoverySuccess {
1620            #[prost(string, tag = "1")]
1621            pub reason: ::prost::alloc::string::String,
1622            #[prost(float, tag = "2")]
1623            pub duration_secs: f32,
1624            #[prost(uint32, repeated, tag = "3")]
1625            pub running_database_ids: ::prost::alloc::vec::Vec<u32>,
1626            #[prost(uint32, repeated, tag = "4")]
1627            pub recovering_database_ids: ::prost::alloc::vec::Vec<u32>,
1628        }
1629        #[derive(prost_helpers::AnyPB)]
1630        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1631        pub struct GlobalRecoveryFailure {
1632            #[prost(string, tag = "1")]
1633            pub reason: ::prost::alloc::string::String,
1634            #[prost(string, tag = "2")]
1635            pub error: ::prost::alloc::string::String,
1636        }
1637        #[derive(prost_helpers::AnyPB)]
1638        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1639        pub struct DatabaseRecoveryStart {
1640            #[prost(uint32, tag = "1")]
1641            pub database_id: u32,
1642        }
1643        #[derive(prost_helpers::AnyPB)]
1644        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1645        pub struct DatabaseRecoveryFailure {
1646            #[prost(uint32, tag = "1")]
1647            pub database_id: u32,
1648        }
1649        #[derive(prost_helpers::AnyPB)]
1650        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1651        pub struct DatabaseRecoverySuccess {
1652            #[prost(uint32, tag = "1")]
1653            pub database_id: u32,
1654        }
1655        #[derive(prost_helpers::AnyPB)]
1656        #[derive(Clone, PartialEq, ::prost::Oneof)]
1657        pub enum RecoveryEvent {
1658            #[prost(message, tag = "1")]
1659            GlobalStart(GlobalRecoveryStart),
1660            #[prost(message, tag = "2")]
1661            GlobalSuccess(GlobalRecoverySuccess),
1662            #[prost(message, tag = "3")]
1663            GlobalFailure(GlobalRecoveryFailure),
1664            #[prost(message, tag = "4")]
1665            DatabaseStart(DatabaseRecoveryStart),
1666            #[prost(message, tag = "5")]
1667            DatabaseFailure(DatabaseRecoveryFailure),
1668            #[prost(message, tag = "6")]
1669            DatabaseSuccess(DatabaseRecoverySuccess),
1670        }
1671    }
1672    #[derive(prost_helpers::AnyPB)]
1673    #[derive(Clone, PartialEq, ::prost::Oneof)]
1674    pub enum Event {
1675        #[prost(message, tag = "3")]
1676        CreateStreamJobFail(EventCreateStreamJobFail),
1677        #[prost(message, tag = "4")]
1678        DirtyStreamJobClear(EventDirtyStreamJobClear),
1679        #[prost(message, tag = "5")]
1680        MetaNodeStart(EventMetaNodeStart),
1681        #[prost(message, tag = "6")]
1682        BarrierComplete(EventBarrierComplete),
1683        #[prost(message, tag = "7")]
1684        InjectBarrierFail(EventInjectBarrierFail),
1685        #[prost(message, tag = "8")]
1686        CollectBarrierFail(EventCollectBarrierFail),
1687        #[prost(message, tag = "9")]
1688        WorkerNodePanic(EventWorkerNodePanic),
1689        #[prost(message, tag = "10")]
1690        AutoSchemaChangeFail(EventAutoSchemaChangeFail),
1691        #[prost(message, tag = "11")]
1692        SinkFail(EventSinkFail),
1693        #[prost(message, tag = "12")]
1694        Recovery(EventRecovery),
1695    }
1696}
1697#[derive(prost_helpers::AnyPB)]
1698#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1699pub struct ListEventLogRequest {}
1700#[derive(prost_helpers::AnyPB)]
1701#[derive(Clone, PartialEq, ::prost::Message)]
1702pub struct ListEventLogResponse {
1703    #[prost(message, repeated, tag = "1")]
1704    pub event_logs: ::prost::alloc::vec::Vec<EventLog>,
1705}
1706#[derive(prost_helpers::AnyPB)]
1707#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1708pub struct AddEventLogRequest {
1709    /// A subset of EventLog.event that can be added by non meta node.
1710    #[prost(oneof = "add_event_log_request::Event", tags = "1, 2, 3")]
1711    pub event: ::core::option::Option<add_event_log_request::Event>,
1712}
1713/// Nested message and enum types in `AddEventLogRequest`.
1714pub mod add_event_log_request {
1715    /// A subset of EventLog.event that can be added by non meta node.
1716    #[derive(prost_helpers::AnyPB)]
1717    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
1718    pub enum Event {
1719        #[prost(message, tag = "1")]
1720        WorkerNodePanic(super::event_log::EventWorkerNodePanic),
1721        #[prost(message, tag = "2")]
1722        SinkFail(super::event_log::EventSinkFail),
1723        #[prost(message, tag = "3")]
1724        AutoSchemaChangeFail(super::event_log::EventAutoSchemaChangeFail),
1725    }
1726}
1727#[derive(prost_helpers::AnyPB)]
1728#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1729pub struct AddEventLogResponse {}
1730#[derive(prost_helpers::AnyPB)]
1731#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1732pub struct ActorIds {
1733    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::ActorId")]
1734    pub ids: ::prost::alloc::vec::Vec<crate::id::ActorId>,
1735}
1736#[derive(prost_helpers::AnyPB)]
1737#[derive(Clone, PartialEq, ::prost::Message)]
1738pub struct FragmentIdToActorIdMap {
1739    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::FragmentId")]
1740    pub map: ::std::collections::HashMap<crate::id::FragmentId, ActorIds>,
1741}
1742/// / Provides all the ids: relation_id, fragment_id, actor_id
1743/// / in an hierarchical format.
1744/// / relation_id -> \[fragment_id\]
1745/// / fragment_id -> \[actor_id\]
1746#[derive(prost_helpers::AnyPB)]
1747#[derive(Clone, PartialEq, ::prost::Message)]
1748pub struct RelationIdInfos {
1749    /// relation_id -> FragmentIdToActorIdMap
1750    #[prost(map = "uint32, message", tag = "1")]
1751    pub map: ::std::collections::HashMap<u32, FragmentIdToActorIdMap>,
1752}
1753#[derive(prost_helpers::AnyPB)]
1754#[derive(Clone, PartialEq, ::prost::Message)]
1755pub struct FragmentToRelationMap {
1756    /// / fragment_id -> relation_id mapping for all fragments
1757    #[prost(
1758        map = "uint32, uint32",
1759        tag = "1",
1760        wrapper = "crate::id::FragmentId ->crate::id:: JobId"
1761    )]
1762    pub fragment_to_relation_map: ::std::collections::HashMap<
1763        crate::id::FragmentId,
1764        crate::id::JobId,
1765    >,
1766}
1767#[derive(prost_helpers::AnyPB)]
1768#[derive(Clone, PartialEq, ::prost::Message)]
1769pub struct ActorCountPerParallelism {
1770    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::WorkerId")]
1771    pub worker_id_to_actor_count: ::std::collections::HashMap<
1772        crate::id::WorkerId,
1773        actor_count_per_parallelism::WorkerActorCount,
1774    >,
1775    #[prost(uint64, tag = "2")]
1776    pub hard_limit: u64,
1777    #[prost(uint64, tag = "3")]
1778    pub soft_limit: u64,
1779}
1780/// Nested message and enum types in `ActorCountPerParallelism`.
1781pub mod actor_count_per_parallelism {
1782    #[derive(prost_helpers::AnyPB)]
1783    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1784    pub struct WorkerActorCount {
1785        #[prost(uint64, tag = "1")]
1786        pub actor_count: u64,
1787        #[prost(uint64, tag = "2")]
1788        pub parallelism: u64,
1789    }
1790}
1791#[derive(prost_helpers::AnyPB)]
1792#[derive(Clone, PartialEq, ::prost::Message)]
1793pub struct ClusterLimit {
1794    #[prost(oneof = "cluster_limit::Limit", tags = "1")]
1795    pub limit: ::core::option::Option<cluster_limit::Limit>,
1796}
1797/// Nested message and enum types in `ClusterLimit`.
1798pub mod cluster_limit {
1799    #[derive(prost_helpers::AnyPB)]
1800    #[derive(Clone, PartialEq, ::prost::Oneof)]
1801    pub enum Limit {
1802        /// TODO: limit DDL using compaction pending bytes
1803        #[prost(message, tag = "1")]
1804        ActorCount(super::ActorCountPerParallelism),
1805    }
1806}
1807#[derive(prost_helpers::AnyPB)]
1808#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1809pub struct GetClusterLimitsRequest {}
1810#[derive(prost_helpers::AnyPB)]
1811#[derive(Clone, PartialEq, ::prost::Message)]
1812pub struct GetClusterLimitsResponse {
1813    #[prost(message, repeated, tag = "1")]
1814    pub active_limits: ::prost::alloc::vec::Vec<ClusterLimit>,
1815}
1816#[derive(prost_helpers::AnyPB)]
1817#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1818pub struct ListRateLimitsRequest {}
1819#[derive(prost_helpers::AnyPB)]
1820#[derive(Clone, PartialEq, ::prost::Message)]
1821pub struct ListRateLimitsResponse {
1822    #[prost(message, repeated, tag = "1")]
1823    pub rate_limits: ::prost::alloc::vec::Vec<list_rate_limits_response::RateLimitInfo>,
1824}
1825/// Nested message and enum types in `ListRateLimitsResponse`.
1826pub mod list_rate_limits_response {
1827    #[derive(prost_helpers::AnyPB)]
1828    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1829    pub struct RateLimitInfo {
1830        #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
1831        pub fragment_id: crate::id::FragmentId,
1832        #[prost(uint32, tag = "2", wrapper = "crate::id::JobId")]
1833        pub job_id: crate::id::JobId,
1834        #[prost(uint32, tag = "3")]
1835        pub fragment_type_mask: u32,
1836        #[prost(uint32, tag = "4")]
1837        pub rate_limit: u32,
1838        #[prost(string, tag = "5")]
1839        pub node_name: ::prost::alloc::string::String,
1840    }
1841}
1842#[derive(prost_helpers::AnyPB)]
1843#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1844pub struct ListIcebergTablesRequest {}
1845#[derive(prost_helpers::AnyPB)]
1846#[derive(Clone, PartialEq, ::prost::Message)]
1847pub struct ListIcebergTablesResponse {
1848    #[prost(message, repeated, tag = "1")]
1849    pub iceberg_tables: ::prost::alloc::vec::Vec<
1850        list_iceberg_tables_response::IcebergTable,
1851    >,
1852}
1853/// Nested message and enum types in `ListIcebergTablesResponse`.
1854pub mod list_iceberg_tables_response {
1855    #[derive(prost_helpers::AnyPB)]
1856    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1857    pub struct IcebergTable {
1858        #[prost(string, tag = "1")]
1859        pub catalog_name: ::prost::alloc::string::String,
1860        #[prost(string, tag = "2")]
1861        pub table_namespace: ::prost::alloc::string::String,
1862        #[prost(string, tag = "3")]
1863        pub table_name: ::prost::alloc::string::String,
1864        #[prost(string, optional, tag = "4")]
1865        pub metadata_location: ::core::option::Option<::prost::alloc::string::String>,
1866        #[prost(string, optional, tag = "5")]
1867        pub previous_metadata_location: ::core::option::Option<
1868            ::prost::alloc::string::String,
1869        >,
1870        #[prost(string, optional, tag = "6")]
1871        pub iceberg_type: ::core::option::Option<::prost::alloc::string::String>,
1872    }
1873}
1874#[derive(prost_helpers::AnyPB)]
1875#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1876pub struct SetSyncLogStoreAlignedRequest {
1877    #[prost(uint32, tag = "1", wrapper = "crate::id::JobId")]
1878    pub job_id: crate::id::JobId,
1879    #[prost(bool, tag = "2")]
1880    pub aligned: bool,
1881}
1882#[derive(prost_helpers::AnyPB)]
1883#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1884pub struct SetSyncLogStoreAlignedResponse {}
1885#[derive(prost_helpers::AnyPB)]
1886#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1887pub struct ListUnmigratedTablesRequest {}
1888#[derive(prost_helpers::AnyPB)]
1889#[derive(Clone, PartialEq, ::prost::Message)]
1890pub struct ListUnmigratedTablesResponse {
1891    #[prost(message, repeated, tag = "1")]
1892    pub tables: ::prost::alloc::vec::Vec<
1893        list_unmigrated_tables_response::UnmigratedTable,
1894    >,
1895}
1896/// Nested message and enum types in `ListUnmigratedTablesResponse`.
1897pub mod list_unmigrated_tables_response {
1898    #[derive(prost_helpers::AnyPB)]
1899    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1900    pub struct UnmigratedTable {
1901        #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
1902        pub table_id: crate::id::TableId,
1903        #[prost(string, tag = "2")]
1904        pub table_name: ::prost::alloc::string::String,
1905    }
1906}
1907#[derive(prost_helpers::AnyPB)]
1908#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1909#[repr(i32)]
1910pub enum ThrottleTarget {
1911    Unspecified = 0,
1912    Source = 1,
1913    Mv = 2,
1914    Table = 3,
1915    Sink = 4,
1916    Fragment = 5,
1917}
1918impl ThrottleTarget {
1919    /// String value of the enum field names used in the ProtoBuf definition.
1920    ///
1921    /// The values are not transformed in any way and thus are considered stable
1922    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1923    pub fn as_str_name(&self) -> &'static str {
1924        match self {
1925            Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
1926            Self::Source => "SOURCE",
1927            Self::Mv => "MV",
1928            Self::Table => "TABLE",
1929            Self::Sink => "SINK",
1930            Self::Fragment => "FRAGMENT",
1931        }
1932    }
1933    /// Creates an enum from field names used in the ProtoBuf definition.
1934    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1935        match value {
1936            "THROTTLE_TARGET_UNSPECIFIED" => Some(Self::Unspecified),
1937            "SOURCE" => Some(Self::Source),
1938            "MV" => Some(Self::Mv),
1939            "TABLE" => Some(Self::Table),
1940            "SINK" => Some(Self::Sink),
1941            "FRAGMENT" => Some(Self::Fragment),
1942            _ => None,
1943        }
1944    }
1945}
1946#[derive(prost_helpers::AnyPB)]
1947#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1948#[repr(i32)]
1949pub enum RecoveryStatus {
1950    StatusUnspecified = 0,
1951    StatusStarting = 1,
1952    StatusRecovering = 2,
1953    StatusRunning = 3,
1954}
1955impl RecoveryStatus {
1956    /// String value of the enum field names used in the ProtoBuf definition.
1957    ///
1958    /// The values are not transformed in any way and thus are considered stable
1959    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1960    pub fn as_str_name(&self) -> &'static str {
1961        match self {
1962            Self::StatusUnspecified => "STATUS_UNSPECIFIED",
1963            Self::StatusStarting => "STATUS_STARTING",
1964            Self::StatusRecovering => "STATUS_RECOVERING",
1965            Self::StatusRunning => "STATUS_RUNNING",
1966        }
1967    }
1968    /// Creates an enum from field names used in the ProtoBuf definition.
1969    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1970        match value {
1971            "STATUS_UNSPECIFIED" => Some(Self::StatusUnspecified),
1972            "STATUS_STARTING" => Some(Self::StatusStarting),
1973            "STATUS_RECOVERING" => Some(Self::StatusRecovering),
1974            "STATUS_RUNNING" => Some(Self::StatusRunning),
1975            _ => None,
1976        }
1977    }
1978}
1979#[derive(prost_helpers::AnyPB)]
1980#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1981#[repr(i32)]
1982pub enum SubscribeType {
1983    Unspecified = 0,
1984    Frontend = 1,
1985    Hummock = 2,
1986    Compactor = 3,
1987    Compute = 4,
1988}
1989impl SubscribeType {
1990    /// String value of the enum field names used in the ProtoBuf definition.
1991    ///
1992    /// The values are not transformed in any way and thus are considered stable
1993    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1994    pub fn as_str_name(&self) -> &'static str {
1995        match self {
1996            Self::Unspecified => "UNSPECIFIED",
1997            Self::Frontend => "FRONTEND",
1998            Self::Hummock => "HUMMOCK",
1999            Self::Compactor => "COMPACTOR",
2000            Self::Compute => "COMPUTE",
2001        }
2002    }
2003    /// Creates an enum from field names used in the ProtoBuf definition.
2004    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2005        match value {
2006            "UNSPECIFIED" => Some(Self::Unspecified),
2007            "FRONTEND" => Some(Self::Frontend),
2008            "HUMMOCK" => Some(Self::Hummock),
2009            "COMPACTOR" => Some(Self::Compactor),
2010            "COMPUTE" => Some(Self::Compute),
2011            _ => None,
2012        }
2013    }
2014}
2015/// Generated client implementations.
2016pub mod telemetry_info_service_client {
2017    #![allow(
2018        unused_variables,
2019        dead_code,
2020        missing_docs,
2021        clippy::wildcard_imports,
2022        clippy::let_unit_value,
2023    )]
2024    use tonic::codegen::*;
2025    use tonic::codegen::http::Uri;
2026    #[derive(Debug, Clone)]
2027    pub struct TelemetryInfoServiceClient<T> {
2028        inner: tonic::client::Grpc<T>,
2029    }
2030    impl TelemetryInfoServiceClient<tonic::transport::Channel> {
2031        /// Attempt to create a new client by connecting to a given endpoint.
2032        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
2033        where
2034            D: TryInto<tonic::transport::Endpoint>,
2035            D::Error: Into<StdError>,
2036        {
2037            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
2038            Ok(Self::new(conn))
2039        }
2040    }
2041    impl<T> TelemetryInfoServiceClient<T>
2042    where
2043        T: tonic::client::GrpcService<tonic::body::Body>,
2044        T::Error: Into<StdError>,
2045        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
2046        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
2047    {
2048        pub fn new(inner: T) -> Self {
2049            let inner = tonic::client::Grpc::new(inner);
2050            Self { inner }
2051        }
2052        pub fn with_origin(inner: T, origin: Uri) -> Self {
2053            let inner = tonic::client::Grpc::with_origin(inner, origin);
2054            Self { inner }
2055        }
2056        pub fn with_interceptor<F>(
2057            inner: T,
2058            interceptor: F,
2059        ) -> TelemetryInfoServiceClient<InterceptedService<T, F>>
2060        where
2061            F: tonic::service::Interceptor,
2062            T::ResponseBody: Default,
2063            T: tonic::codegen::Service<
2064                http::Request<tonic::body::Body>,
2065                Response = http::Response<
2066                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
2067                >,
2068            >,
2069            <T as tonic::codegen::Service<
2070                http::Request<tonic::body::Body>,
2071            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2072        {
2073            TelemetryInfoServiceClient::new(InterceptedService::new(inner, interceptor))
2074        }
2075        /// Compress requests with the given encoding.
2076        ///
2077        /// This requires the server to support it otherwise it might respond with an
2078        /// error.
2079        #[must_use]
2080        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2081            self.inner = self.inner.send_compressed(encoding);
2082            self
2083        }
2084        /// Enable decompressing responses.
2085        #[must_use]
2086        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2087            self.inner = self.inner.accept_compressed(encoding);
2088            self
2089        }
2090        /// Limits the maximum size of a decoded message.
2091        ///
2092        /// Default: `4MB`
2093        #[must_use]
2094        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2095            self.inner = self.inner.max_decoding_message_size(limit);
2096            self
2097        }
2098        /// Limits the maximum size of an encoded message.
2099        ///
2100        /// Default: `usize::MAX`
2101        #[must_use]
2102        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2103            self.inner = self.inner.max_encoding_message_size(limit);
2104            self
2105        }
2106        /// Request telemetry info from meta node
2107        pub async fn get_telemetry_info(
2108            &mut self,
2109            request: impl tonic::IntoRequest<super::GetTelemetryInfoRequest>,
2110        ) -> std::result::Result<
2111            tonic::Response<super::TelemetryInfoResponse>,
2112            tonic::Status,
2113        > {
2114            self.inner
2115                .ready()
2116                .await
2117                .map_err(|e| {
2118                    tonic::Status::unknown(
2119                        format!("Service was not ready: {}", e.into()),
2120                    )
2121                })?;
2122            let codec = tonic_prost::ProstCodec::default();
2123            let path = http::uri::PathAndQuery::from_static(
2124                "/meta.TelemetryInfoService/GetTelemetryInfo",
2125            );
2126            let mut req = request.into_request();
2127            req.extensions_mut()
2128                .insert(
2129                    GrpcMethod::new("meta.TelemetryInfoService", "GetTelemetryInfo"),
2130                );
2131            self.inner.unary(req, path, codec).await
2132        }
2133    }
2134}
2135/// Generated server implementations.
2136pub mod telemetry_info_service_server {
2137    #![allow(
2138        unused_variables,
2139        dead_code,
2140        missing_docs,
2141        clippy::wildcard_imports,
2142        clippy::let_unit_value,
2143    )]
2144    use tonic::codegen::*;
2145    /// Generated trait containing gRPC methods that should be implemented for use with TelemetryInfoServiceServer.
2146    #[async_trait]
2147    pub trait TelemetryInfoService: std::marker::Send + std::marker::Sync + 'static {
2148        /// Request telemetry info from meta node
2149        async fn get_telemetry_info(
2150            &self,
2151            request: tonic::Request<super::GetTelemetryInfoRequest>,
2152        ) -> std::result::Result<
2153            tonic::Response<super::TelemetryInfoResponse>,
2154            tonic::Status,
2155        >;
2156    }
2157    #[derive(Debug)]
2158    pub struct TelemetryInfoServiceServer<T> {
2159        inner: Arc<T>,
2160        accept_compression_encodings: EnabledCompressionEncodings,
2161        send_compression_encodings: EnabledCompressionEncodings,
2162        max_decoding_message_size: Option<usize>,
2163        max_encoding_message_size: Option<usize>,
2164    }
2165    impl<T> TelemetryInfoServiceServer<T> {
2166        pub fn new(inner: T) -> Self {
2167            Self::from_arc(Arc::new(inner))
2168        }
2169        pub fn from_arc(inner: Arc<T>) -> Self {
2170            Self {
2171                inner,
2172                accept_compression_encodings: Default::default(),
2173                send_compression_encodings: Default::default(),
2174                max_decoding_message_size: None,
2175                max_encoding_message_size: None,
2176            }
2177        }
2178        pub fn with_interceptor<F>(
2179            inner: T,
2180            interceptor: F,
2181        ) -> InterceptedService<Self, F>
2182        where
2183            F: tonic::service::Interceptor,
2184        {
2185            InterceptedService::new(Self::new(inner), interceptor)
2186        }
2187        /// Enable decompressing requests with the given encoding.
2188        #[must_use]
2189        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2190            self.accept_compression_encodings.enable(encoding);
2191            self
2192        }
2193        /// Compress responses with the given encoding, if the client supports it.
2194        #[must_use]
2195        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2196            self.send_compression_encodings.enable(encoding);
2197            self
2198        }
2199        /// Limits the maximum size of a decoded message.
2200        ///
2201        /// Default: `4MB`
2202        #[must_use]
2203        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2204            self.max_decoding_message_size = Some(limit);
2205            self
2206        }
2207        /// Limits the maximum size of an encoded message.
2208        ///
2209        /// Default: `usize::MAX`
2210        #[must_use]
2211        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2212            self.max_encoding_message_size = Some(limit);
2213            self
2214        }
2215    }
2216    impl<T, B> tonic::codegen::Service<http::Request<B>>
2217    for TelemetryInfoServiceServer<T>
2218    where
2219        T: TelemetryInfoService,
2220        B: Body + std::marker::Send + 'static,
2221        B::Error: Into<StdError> + std::marker::Send + 'static,
2222    {
2223        type Response = http::Response<tonic::body::Body>;
2224        type Error = std::convert::Infallible;
2225        type Future = BoxFuture<Self::Response, Self::Error>;
2226        fn poll_ready(
2227            &mut self,
2228            _cx: &mut Context<'_>,
2229        ) -> Poll<std::result::Result<(), Self::Error>> {
2230            Poll::Ready(Ok(()))
2231        }
2232        fn call(&mut self, req: http::Request<B>) -> Self::Future {
2233            match req.uri().path() {
2234                "/meta.TelemetryInfoService/GetTelemetryInfo" => {
2235                    #[allow(non_camel_case_types)]
2236                    struct GetTelemetryInfoSvc<T: TelemetryInfoService>(pub Arc<T>);
2237                    impl<
2238                        T: TelemetryInfoService,
2239                    > tonic::server::UnaryService<super::GetTelemetryInfoRequest>
2240                    for GetTelemetryInfoSvc<T> {
2241                        type Response = super::TelemetryInfoResponse;
2242                        type Future = BoxFuture<
2243                            tonic::Response<Self::Response>,
2244                            tonic::Status,
2245                        >;
2246                        fn call(
2247                            &mut self,
2248                            request: tonic::Request<super::GetTelemetryInfoRequest>,
2249                        ) -> Self::Future {
2250                            let inner = Arc::clone(&self.0);
2251                            let fut = async move {
2252                                <T as TelemetryInfoService>::get_telemetry_info(
2253                                        &inner,
2254                                        request,
2255                                    )
2256                                    .await
2257                            };
2258                            Box::pin(fut)
2259                        }
2260                    }
2261                    let accept_compression_encodings = self.accept_compression_encodings;
2262                    let send_compression_encodings = self.send_compression_encodings;
2263                    let max_decoding_message_size = self.max_decoding_message_size;
2264                    let max_encoding_message_size = self.max_encoding_message_size;
2265                    let inner = self.inner.clone();
2266                    let fut = async move {
2267                        let method = GetTelemetryInfoSvc(inner);
2268                        let codec = tonic_prost::ProstCodec::default();
2269                        let mut grpc = tonic::server::Grpc::new(codec)
2270                            .apply_compression_config(
2271                                accept_compression_encodings,
2272                                send_compression_encodings,
2273                            )
2274                            .apply_max_message_size_config(
2275                                max_decoding_message_size,
2276                                max_encoding_message_size,
2277                            );
2278                        let res = grpc.unary(method, req).await;
2279                        Ok(res)
2280                    };
2281                    Box::pin(fut)
2282                }
2283                _ => {
2284                    Box::pin(async move {
2285                        let mut response = http::Response::new(
2286                            tonic::body::Body::default(),
2287                        );
2288                        let headers = response.headers_mut();
2289                        headers
2290                            .insert(
2291                                tonic::Status::GRPC_STATUS,
2292                                (tonic::Code::Unimplemented as i32).into(),
2293                            );
2294                        headers
2295                            .insert(
2296                                http::header::CONTENT_TYPE,
2297                                tonic::metadata::GRPC_CONTENT_TYPE,
2298                            );
2299                        Ok(response)
2300                    })
2301                }
2302            }
2303        }
2304    }
2305    impl<T> Clone for TelemetryInfoServiceServer<T> {
2306        fn clone(&self) -> Self {
2307            let inner = self.inner.clone();
2308            Self {
2309                inner,
2310                accept_compression_encodings: self.accept_compression_encodings,
2311                send_compression_encodings: self.send_compression_encodings,
2312                max_decoding_message_size: self.max_decoding_message_size,
2313                max_encoding_message_size: self.max_encoding_message_size,
2314            }
2315        }
2316    }
2317    /// Generated gRPC service name
2318    pub const SERVICE_NAME: &str = "meta.TelemetryInfoService";
2319    impl<T> tonic::server::NamedService for TelemetryInfoServiceServer<T> {
2320        const NAME: &'static str = SERVICE_NAME;
2321    }
2322}
2323/// Generated client implementations.
2324pub mod heartbeat_service_client {
2325    #![allow(
2326        unused_variables,
2327        dead_code,
2328        missing_docs,
2329        clippy::wildcard_imports,
2330        clippy::let_unit_value,
2331    )]
2332    use tonic::codegen::*;
2333    use tonic::codegen::http::Uri;
2334    #[derive(Debug, Clone)]
2335    pub struct HeartbeatServiceClient<T> {
2336        inner: tonic::client::Grpc<T>,
2337    }
2338    impl HeartbeatServiceClient<tonic::transport::Channel> {
2339        /// Attempt to create a new client by connecting to a given endpoint.
2340        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
2341        where
2342            D: TryInto<tonic::transport::Endpoint>,
2343            D::Error: Into<StdError>,
2344        {
2345            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
2346            Ok(Self::new(conn))
2347        }
2348    }
2349    impl<T> HeartbeatServiceClient<T>
2350    where
2351        T: tonic::client::GrpcService<tonic::body::Body>,
2352        T::Error: Into<StdError>,
2353        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
2354        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
2355    {
2356        pub fn new(inner: T) -> Self {
2357            let inner = tonic::client::Grpc::new(inner);
2358            Self { inner }
2359        }
2360        pub fn with_origin(inner: T, origin: Uri) -> Self {
2361            let inner = tonic::client::Grpc::with_origin(inner, origin);
2362            Self { inner }
2363        }
2364        pub fn with_interceptor<F>(
2365            inner: T,
2366            interceptor: F,
2367        ) -> HeartbeatServiceClient<InterceptedService<T, F>>
2368        where
2369            F: tonic::service::Interceptor,
2370            T::ResponseBody: Default,
2371            T: tonic::codegen::Service<
2372                http::Request<tonic::body::Body>,
2373                Response = http::Response<
2374                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
2375                >,
2376            >,
2377            <T as tonic::codegen::Service<
2378                http::Request<tonic::body::Body>,
2379            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2380        {
2381            HeartbeatServiceClient::new(InterceptedService::new(inner, interceptor))
2382        }
2383        /// Compress requests with the given encoding.
2384        ///
2385        /// This requires the server to support it otherwise it might respond with an
2386        /// error.
2387        #[must_use]
2388        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2389            self.inner = self.inner.send_compressed(encoding);
2390            self
2391        }
2392        /// Enable decompressing responses.
2393        #[must_use]
2394        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2395            self.inner = self.inner.accept_compressed(encoding);
2396            self
2397        }
2398        /// Limits the maximum size of a decoded message.
2399        ///
2400        /// Default: `4MB`
2401        #[must_use]
2402        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2403            self.inner = self.inner.max_decoding_message_size(limit);
2404            self
2405        }
2406        /// Limits the maximum size of an encoded message.
2407        ///
2408        /// Default: `usize::MAX`
2409        #[must_use]
2410        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2411            self.inner = self.inner.max_encoding_message_size(limit);
2412            self
2413        }
2414        pub async fn heartbeat(
2415            &mut self,
2416            request: impl tonic::IntoRequest<super::HeartbeatRequest>,
2417        ) -> std::result::Result<
2418            tonic::Response<super::HeartbeatResponse>,
2419            tonic::Status,
2420        > {
2421            self.inner
2422                .ready()
2423                .await
2424                .map_err(|e| {
2425                    tonic::Status::unknown(
2426                        format!("Service was not ready: {}", e.into()),
2427                    )
2428                })?;
2429            let codec = tonic_prost::ProstCodec::default();
2430            let path = http::uri::PathAndQuery::from_static(
2431                "/meta.HeartbeatService/Heartbeat",
2432            );
2433            let mut req = request.into_request();
2434            req.extensions_mut()
2435                .insert(GrpcMethod::new("meta.HeartbeatService", "Heartbeat"));
2436            self.inner.unary(req, path, codec).await
2437        }
2438    }
2439}
2440/// Generated server implementations.
2441pub mod heartbeat_service_server {
2442    #![allow(
2443        unused_variables,
2444        dead_code,
2445        missing_docs,
2446        clippy::wildcard_imports,
2447        clippy::let_unit_value,
2448    )]
2449    use tonic::codegen::*;
2450    /// Generated trait containing gRPC methods that should be implemented for use with HeartbeatServiceServer.
2451    #[async_trait]
2452    pub trait HeartbeatService: std::marker::Send + std::marker::Sync + 'static {
2453        async fn heartbeat(
2454            &self,
2455            request: tonic::Request<super::HeartbeatRequest>,
2456        ) -> std::result::Result<
2457            tonic::Response<super::HeartbeatResponse>,
2458            tonic::Status,
2459        >;
2460    }
2461    #[derive(Debug)]
2462    pub struct HeartbeatServiceServer<T> {
2463        inner: Arc<T>,
2464        accept_compression_encodings: EnabledCompressionEncodings,
2465        send_compression_encodings: EnabledCompressionEncodings,
2466        max_decoding_message_size: Option<usize>,
2467        max_encoding_message_size: Option<usize>,
2468    }
2469    impl<T> HeartbeatServiceServer<T> {
2470        pub fn new(inner: T) -> Self {
2471            Self::from_arc(Arc::new(inner))
2472        }
2473        pub fn from_arc(inner: Arc<T>) -> Self {
2474            Self {
2475                inner,
2476                accept_compression_encodings: Default::default(),
2477                send_compression_encodings: Default::default(),
2478                max_decoding_message_size: None,
2479                max_encoding_message_size: None,
2480            }
2481        }
2482        pub fn with_interceptor<F>(
2483            inner: T,
2484            interceptor: F,
2485        ) -> InterceptedService<Self, F>
2486        where
2487            F: tonic::service::Interceptor,
2488        {
2489            InterceptedService::new(Self::new(inner), interceptor)
2490        }
2491        /// Enable decompressing requests with the given encoding.
2492        #[must_use]
2493        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2494            self.accept_compression_encodings.enable(encoding);
2495            self
2496        }
2497        /// Compress responses with the given encoding, if the client supports it.
2498        #[must_use]
2499        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2500            self.send_compression_encodings.enable(encoding);
2501            self
2502        }
2503        /// Limits the maximum size of a decoded message.
2504        ///
2505        /// Default: `4MB`
2506        #[must_use]
2507        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2508            self.max_decoding_message_size = Some(limit);
2509            self
2510        }
2511        /// Limits the maximum size of an encoded message.
2512        ///
2513        /// Default: `usize::MAX`
2514        #[must_use]
2515        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2516            self.max_encoding_message_size = Some(limit);
2517            self
2518        }
2519    }
2520    impl<T, B> tonic::codegen::Service<http::Request<B>> for HeartbeatServiceServer<T>
2521    where
2522        T: HeartbeatService,
2523        B: Body + std::marker::Send + 'static,
2524        B::Error: Into<StdError> + std::marker::Send + 'static,
2525    {
2526        type Response = http::Response<tonic::body::Body>;
2527        type Error = std::convert::Infallible;
2528        type Future = BoxFuture<Self::Response, Self::Error>;
2529        fn poll_ready(
2530            &mut self,
2531            _cx: &mut Context<'_>,
2532        ) -> Poll<std::result::Result<(), Self::Error>> {
2533            Poll::Ready(Ok(()))
2534        }
2535        fn call(&mut self, req: http::Request<B>) -> Self::Future {
2536            match req.uri().path() {
2537                "/meta.HeartbeatService/Heartbeat" => {
2538                    #[allow(non_camel_case_types)]
2539                    struct HeartbeatSvc<T: HeartbeatService>(pub Arc<T>);
2540                    impl<
2541                        T: HeartbeatService,
2542                    > tonic::server::UnaryService<super::HeartbeatRequest>
2543                    for HeartbeatSvc<T> {
2544                        type Response = super::HeartbeatResponse;
2545                        type Future = BoxFuture<
2546                            tonic::Response<Self::Response>,
2547                            tonic::Status,
2548                        >;
2549                        fn call(
2550                            &mut self,
2551                            request: tonic::Request<super::HeartbeatRequest>,
2552                        ) -> Self::Future {
2553                            let inner = Arc::clone(&self.0);
2554                            let fut = async move {
2555                                <T as HeartbeatService>::heartbeat(&inner, request).await
2556                            };
2557                            Box::pin(fut)
2558                        }
2559                    }
2560                    let accept_compression_encodings = self.accept_compression_encodings;
2561                    let send_compression_encodings = self.send_compression_encodings;
2562                    let max_decoding_message_size = self.max_decoding_message_size;
2563                    let max_encoding_message_size = self.max_encoding_message_size;
2564                    let inner = self.inner.clone();
2565                    let fut = async move {
2566                        let method = HeartbeatSvc(inner);
2567                        let codec = tonic_prost::ProstCodec::default();
2568                        let mut grpc = tonic::server::Grpc::new(codec)
2569                            .apply_compression_config(
2570                                accept_compression_encodings,
2571                                send_compression_encodings,
2572                            )
2573                            .apply_max_message_size_config(
2574                                max_decoding_message_size,
2575                                max_encoding_message_size,
2576                            );
2577                        let res = grpc.unary(method, req).await;
2578                        Ok(res)
2579                    };
2580                    Box::pin(fut)
2581                }
2582                _ => {
2583                    Box::pin(async move {
2584                        let mut response = http::Response::new(
2585                            tonic::body::Body::default(),
2586                        );
2587                        let headers = response.headers_mut();
2588                        headers
2589                            .insert(
2590                                tonic::Status::GRPC_STATUS,
2591                                (tonic::Code::Unimplemented as i32).into(),
2592                            );
2593                        headers
2594                            .insert(
2595                                http::header::CONTENT_TYPE,
2596                                tonic::metadata::GRPC_CONTENT_TYPE,
2597                            );
2598                        Ok(response)
2599                    })
2600                }
2601            }
2602        }
2603    }
2604    impl<T> Clone for HeartbeatServiceServer<T> {
2605        fn clone(&self) -> Self {
2606            let inner = self.inner.clone();
2607            Self {
2608                inner,
2609                accept_compression_encodings: self.accept_compression_encodings,
2610                send_compression_encodings: self.send_compression_encodings,
2611                max_decoding_message_size: self.max_decoding_message_size,
2612                max_encoding_message_size: self.max_encoding_message_size,
2613            }
2614        }
2615    }
2616    /// Generated gRPC service name
2617    pub const SERVICE_NAME: &str = "meta.HeartbeatService";
2618    impl<T> tonic::server::NamedService for HeartbeatServiceServer<T> {
2619        const NAME: &'static str = SERVICE_NAME;
2620    }
2621}
2622/// Generated client implementations.
2623pub mod stream_manager_service_client {
2624    #![allow(
2625        unused_variables,
2626        dead_code,
2627        missing_docs,
2628        clippy::wildcard_imports,
2629        clippy::let_unit_value,
2630    )]
2631    use tonic::codegen::*;
2632    use tonic::codegen::http::Uri;
2633    #[derive(Debug, Clone)]
2634    pub struct StreamManagerServiceClient<T> {
2635        inner: tonic::client::Grpc<T>,
2636    }
2637    impl StreamManagerServiceClient<tonic::transport::Channel> {
2638        /// Attempt to create a new client by connecting to a given endpoint.
2639        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
2640        where
2641            D: TryInto<tonic::transport::Endpoint>,
2642            D::Error: Into<StdError>,
2643        {
2644            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
2645            Ok(Self::new(conn))
2646        }
2647    }
2648    impl<T> StreamManagerServiceClient<T>
2649    where
2650        T: tonic::client::GrpcService<tonic::body::Body>,
2651        T::Error: Into<StdError>,
2652        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
2653        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
2654    {
2655        pub fn new(inner: T) -> Self {
2656            let inner = tonic::client::Grpc::new(inner);
2657            Self { inner }
2658        }
2659        pub fn with_origin(inner: T, origin: Uri) -> Self {
2660            let inner = tonic::client::Grpc::with_origin(inner, origin);
2661            Self { inner }
2662        }
2663        pub fn with_interceptor<F>(
2664            inner: T,
2665            interceptor: F,
2666        ) -> StreamManagerServiceClient<InterceptedService<T, F>>
2667        where
2668            F: tonic::service::Interceptor,
2669            T::ResponseBody: Default,
2670            T: tonic::codegen::Service<
2671                http::Request<tonic::body::Body>,
2672                Response = http::Response<
2673                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
2674                >,
2675            >,
2676            <T as tonic::codegen::Service<
2677                http::Request<tonic::body::Body>,
2678            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
2679        {
2680            StreamManagerServiceClient::new(InterceptedService::new(inner, interceptor))
2681        }
2682        /// Compress requests with the given encoding.
2683        ///
2684        /// This requires the server to support it otherwise it might respond with an
2685        /// error.
2686        #[must_use]
2687        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
2688            self.inner = self.inner.send_compressed(encoding);
2689            self
2690        }
2691        /// Enable decompressing responses.
2692        #[must_use]
2693        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
2694            self.inner = self.inner.accept_compressed(encoding);
2695            self
2696        }
2697        /// Limits the maximum size of a decoded message.
2698        ///
2699        /// Default: `4MB`
2700        #[must_use]
2701        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
2702            self.inner = self.inner.max_decoding_message_size(limit);
2703            self
2704        }
2705        /// Limits the maximum size of an encoded message.
2706        ///
2707        /// Default: `usize::MAX`
2708        #[must_use]
2709        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
2710            self.inner = self.inner.max_encoding_message_size(limit);
2711            self
2712        }
2713        pub async fn flush(
2714            &mut self,
2715            request: impl tonic::IntoRequest<super::FlushRequest>,
2716        ) -> std::result::Result<tonic::Response<super::FlushResponse>, tonic::Status> {
2717            self.inner
2718                .ready()
2719                .await
2720                .map_err(|e| {
2721                    tonic::Status::unknown(
2722                        format!("Service was not ready: {}", e.into()),
2723                    )
2724                })?;
2725            let codec = tonic_prost::ProstCodec::default();
2726            let path = http::uri::PathAndQuery::from_static(
2727                "/meta.StreamManagerService/Flush",
2728            );
2729            let mut req = request.into_request();
2730            req.extensions_mut()
2731                .insert(GrpcMethod::new("meta.StreamManagerService", "Flush"));
2732            self.inner.unary(req, path, codec).await
2733        }
2734        pub async fn pause(
2735            &mut self,
2736            request: impl tonic::IntoRequest<super::PauseRequest>,
2737        ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status> {
2738            self.inner
2739                .ready()
2740                .await
2741                .map_err(|e| {
2742                    tonic::Status::unknown(
2743                        format!("Service was not ready: {}", e.into()),
2744                    )
2745                })?;
2746            let codec = tonic_prost::ProstCodec::default();
2747            let path = http::uri::PathAndQuery::from_static(
2748                "/meta.StreamManagerService/Pause",
2749            );
2750            let mut req = request.into_request();
2751            req.extensions_mut()
2752                .insert(GrpcMethod::new("meta.StreamManagerService", "Pause"));
2753            self.inner.unary(req, path, codec).await
2754        }
2755        pub async fn resume(
2756            &mut self,
2757            request: impl tonic::IntoRequest<super::ResumeRequest>,
2758        ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> {
2759            self.inner
2760                .ready()
2761                .await
2762                .map_err(|e| {
2763                    tonic::Status::unknown(
2764                        format!("Service was not ready: {}", e.into()),
2765                    )
2766                })?;
2767            let codec = tonic_prost::ProstCodec::default();
2768            let path = http::uri::PathAndQuery::from_static(
2769                "/meta.StreamManagerService/Resume",
2770            );
2771            let mut req = request.into_request();
2772            req.extensions_mut()
2773                .insert(GrpcMethod::new("meta.StreamManagerService", "Resume"));
2774            self.inner.unary(req, path, codec).await
2775        }
2776        pub async fn refresh(
2777            &mut self,
2778            request: impl tonic::IntoRequest<super::RefreshRequest>,
2779        ) -> std::result::Result<
2780            tonic::Response<super::RefreshResponse>,
2781            tonic::Status,
2782        > {
2783            self.inner
2784                .ready()
2785                .await
2786                .map_err(|e| {
2787                    tonic::Status::unknown(
2788                        format!("Service was not ready: {}", e.into()),
2789                    )
2790                })?;
2791            let codec = tonic_prost::ProstCodec::default();
2792            let path = http::uri::PathAndQuery::from_static(
2793                "/meta.StreamManagerService/Refresh",
2794            );
2795            let mut req = request.into_request();
2796            req.extensions_mut()
2797                .insert(GrpcMethod::new("meta.StreamManagerService", "Refresh"));
2798            self.inner.unary(req, path, codec).await
2799        }
2800        pub async fn cancel_creating_jobs(
2801            &mut self,
2802            request: impl tonic::IntoRequest<super::CancelCreatingJobsRequest>,
2803        ) -> std::result::Result<
2804            tonic::Response<super::CancelCreatingJobsResponse>,
2805            tonic::Status,
2806        > {
2807            self.inner
2808                .ready()
2809                .await
2810                .map_err(|e| {
2811                    tonic::Status::unknown(
2812                        format!("Service was not ready: {}", e.into()),
2813                    )
2814                })?;
2815            let codec = tonic_prost::ProstCodec::default();
2816            let path = http::uri::PathAndQuery::from_static(
2817                "/meta.StreamManagerService/CancelCreatingJobs",
2818            );
2819            let mut req = request.into_request();
2820            req.extensions_mut()
2821                .insert(
2822                    GrpcMethod::new("meta.StreamManagerService", "CancelCreatingJobs"),
2823                );
2824            self.inner.unary(req, path, codec).await
2825        }
2826        pub async fn list_table_fragments(
2827            &mut self,
2828            request: impl tonic::IntoRequest<super::ListTableFragmentsRequest>,
2829        ) -> std::result::Result<
2830            tonic::Response<super::ListTableFragmentsResponse>,
2831            tonic::Status,
2832        > {
2833            self.inner
2834                .ready()
2835                .await
2836                .map_err(|e| {
2837                    tonic::Status::unknown(
2838                        format!("Service was not ready: {}", e.into()),
2839                    )
2840                })?;
2841            let codec = tonic_prost::ProstCodec::default();
2842            let path = http::uri::PathAndQuery::from_static(
2843                "/meta.StreamManagerService/ListTableFragments",
2844            );
2845            let mut req = request.into_request();
2846            req.extensions_mut()
2847                .insert(
2848                    GrpcMethod::new("meta.StreamManagerService", "ListTableFragments"),
2849                );
2850            self.inner.unary(req, path, codec).await
2851        }
2852        pub async fn list_streaming_job_states(
2853            &mut self,
2854            request: impl tonic::IntoRequest<super::ListStreamingJobStatesRequest>,
2855        ) -> std::result::Result<
2856            tonic::Response<super::ListStreamingJobStatesResponse>,
2857            tonic::Status,
2858        > {
2859            self.inner
2860                .ready()
2861                .await
2862                .map_err(|e| {
2863                    tonic::Status::unknown(
2864                        format!("Service was not ready: {}", e.into()),
2865                    )
2866                })?;
2867            let codec = tonic_prost::ProstCodec::default();
2868            let path = http::uri::PathAndQuery::from_static(
2869                "/meta.StreamManagerService/ListStreamingJobStates",
2870            );
2871            let mut req = request.into_request();
2872            req.extensions_mut()
2873                .insert(
2874                    GrpcMethod::new(
2875                        "meta.StreamManagerService",
2876                        "ListStreamingJobStates",
2877                    ),
2878                );
2879            self.inner.unary(req, path, codec).await
2880        }
2881        pub async fn list_fragment_distribution(
2882            &mut self,
2883            request: impl tonic::IntoRequest<super::ListFragmentDistributionRequest>,
2884        ) -> std::result::Result<
2885            tonic::Response<super::ListFragmentDistributionResponse>,
2886            tonic::Status,
2887        > {
2888            self.inner
2889                .ready()
2890                .await
2891                .map_err(|e| {
2892                    tonic::Status::unknown(
2893                        format!("Service was not ready: {}", e.into()),
2894                    )
2895                })?;
2896            let codec = tonic_prost::ProstCodec::default();
2897            let path = http::uri::PathAndQuery::from_static(
2898                "/meta.StreamManagerService/ListFragmentDistribution",
2899            );
2900            let mut req = request.into_request();
2901            req.extensions_mut()
2902                .insert(
2903                    GrpcMethod::new(
2904                        "meta.StreamManagerService",
2905                        "ListFragmentDistribution",
2906                    ),
2907                );
2908            self.inner.unary(req, path, codec).await
2909        }
2910        pub async fn list_creating_fragment_distribution(
2911            &mut self,
2912            request: impl tonic::IntoRequest<
2913                super::ListCreatingFragmentDistributionRequest,
2914            >,
2915        ) -> std::result::Result<
2916            tonic::Response<super::ListCreatingFragmentDistributionResponse>,
2917            tonic::Status,
2918        > {
2919            self.inner
2920                .ready()
2921                .await
2922                .map_err(|e| {
2923                    tonic::Status::unknown(
2924                        format!("Service was not ready: {}", e.into()),
2925                    )
2926                })?;
2927            let codec = tonic_prost::ProstCodec::default();
2928            let path = http::uri::PathAndQuery::from_static(
2929                "/meta.StreamManagerService/ListCreatingFragmentDistribution",
2930            );
2931            let mut req = request.into_request();
2932            req.extensions_mut()
2933                .insert(
2934                    GrpcMethod::new(
2935                        "meta.StreamManagerService",
2936                        "ListCreatingFragmentDistribution",
2937                    ),
2938                );
2939            self.inner.unary(req, path, codec).await
2940        }
2941        pub async fn list_sink_log_store_tables(
2942            &mut self,
2943            request: impl tonic::IntoRequest<super::ListSinkLogStoreTablesRequest>,
2944        ) -> std::result::Result<
2945            tonic::Response<super::ListSinkLogStoreTablesResponse>,
2946            tonic::Status,
2947        > {
2948            self.inner
2949                .ready()
2950                .await
2951                .map_err(|e| {
2952                    tonic::Status::unknown(
2953                        format!("Service was not ready: {}", e.into()),
2954                    )
2955                })?;
2956            let codec = tonic_prost::ProstCodec::default();
2957            let path = http::uri::PathAndQuery::from_static(
2958                "/meta.StreamManagerService/ListSinkLogStoreTables",
2959            );
2960            let mut req = request.into_request();
2961            req.extensions_mut()
2962                .insert(
2963                    GrpcMethod::new(
2964                        "meta.StreamManagerService",
2965                        "ListSinkLogStoreTables",
2966                    ),
2967                );
2968            self.inner.unary(req, path, codec).await
2969        }
2970        pub async fn list_actor_states(
2971            &mut self,
2972            request: impl tonic::IntoRequest<super::ListActorStatesRequest>,
2973        ) -> std::result::Result<
2974            tonic::Response<super::ListActorStatesResponse>,
2975            tonic::Status,
2976        > {
2977            self.inner
2978                .ready()
2979                .await
2980                .map_err(|e| {
2981                    tonic::Status::unknown(
2982                        format!("Service was not ready: {}", e.into()),
2983                    )
2984                })?;
2985            let codec = tonic_prost::ProstCodec::default();
2986            let path = http::uri::PathAndQuery::from_static(
2987                "/meta.StreamManagerService/ListActorStates",
2988            );
2989            let mut req = request.into_request();
2990            req.extensions_mut()
2991                .insert(GrpcMethod::new("meta.StreamManagerService", "ListActorStates"));
2992            self.inner.unary(req, path, codec).await
2993        }
2994        pub async fn list_actor_splits(
2995            &mut self,
2996            request: impl tonic::IntoRequest<super::ListActorSplitsRequest>,
2997        ) -> std::result::Result<
2998            tonic::Response<super::ListActorSplitsResponse>,
2999            tonic::Status,
3000        > {
3001            self.inner
3002                .ready()
3003                .await
3004                .map_err(|e| {
3005                    tonic::Status::unknown(
3006                        format!("Service was not ready: {}", e.into()),
3007                    )
3008                })?;
3009            let codec = tonic_prost::ProstCodec::default();
3010            let path = http::uri::PathAndQuery::from_static(
3011                "/meta.StreamManagerService/ListActorSplits",
3012            );
3013            let mut req = request.into_request();
3014            req.extensions_mut()
3015                .insert(GrpcMethod::new("meta.StreamManagerService", "ListActorSplits"));
3016            self.inner.unary(req, path, codec).await
3017        }
3018        pub async fn apply_throttle(
3019            &mut self,
3020            request: impl tonic::IntoRequest<super::ApplyThrottleRequest>,
3021        ) -> std::result::Result<
3022            tonic::Response<super::ApplyThrottleResponse>,
3023            tonic::Status,
3024        > {
3025            self.inner
3026                .ready()
3027                .await
3028                .map_err(|e| {
3029                    tonic::Status::unknown(
3030                        format!("Service was not ready: {}", e.into()),
3031                    )
3032                })?;
3033            let codec = tonic_prost::ProstCodec::default();
3034            let path = http::uri::PathAndQuery::from_static(
3035                "/meta.StreamManagerService/ApplyThrottle",
3036            );
3037            let mut req = request.into_request();
3038            req.extensions_mut()
3039                .insert(GrpcMethod::new("meta.StreamManagerService", "ApplyThrottle"));
3040            self.inner.unary(req, path, codec).await
3041        }
3042        pub async fn recover(
3043            &mut self,
3044            request: impl tonic::IntoRequest<super::RecoverRequest>,
3045        ) -> std::result::Result<
3046            tonic::Response<super::RecoverResponse>,
3047            tonic::Status,
3048        > {
3049            self.inner
3050                .ready()
3051                .await
3052                .map_err(|e| {
3053                    tonic::Status::unknown(
3054                        format!("Service was not ready: {}", e.into()),
3055                    )
3056                })?;
3057            let codec = tonic_prost::ProstCodec::default();
3058            let path = http::uri::PathAndQuery::from_static(
3059                "/meta.StreamManagerService/Recover",
3060            );
3061            let mut req = request.into_request();
3062            req.extensions_mut()
3063                .insert(GrpcMethod::new("meta.StreamManagerService", "Recover"));
3064            self.inner.unary(req, path, codec).await
3065        }
3066        pub async fn list_rate_limits(
3067            &mut self,
3068            request: impl tonic::IntoRequest<super::ListRateLimitsRequest>,
3069        ) -> std::result::Result<
3070            tonic::Response<super::ListRateLimitsResponse>,
3071            tonic::Status,
3072        > {
3073            self.inner
3074                .ready()
3075                .await
3076                .map_err(|e| {
3077                    tonic::Status::unknown(
3078                        format!("Service was not ready: {}", e.into()),
3079                    )
3080                })?;
3081            let codec = tonic_prost::ProstCodec::default();
3082            let path = http::uri::PathAndQuery::from_static(
3083                "/meta.StreamManagerService/ListRateLimits",
3084            );
3085            let mut req = request.into_request();
3086            req.extensions_mut()
3087                .insert(GrpcMethod::new("meta.StreamManagerService", "ListRateLimits"));
3088            self.inner.unary(req, path, codec).await
3089        }
3090        pub async fn alter_connector_props(
3091            &mut self,
3092            request: impl tonic::IntoRequest<super::AlterConnectorPropsRequest>,
3093        ) -> std::result::Result<
3094            tonic::Response<super::AlterConnectorPropsResponse>,
3095            tonic::Status,
3096        > {
3097            self.inner
3098                .ready()
3099                .await
3100                .map_err(|e| {
3101                    tonic::Status::unknown(
3102                        format!("Service was not ready: {}", e.into()),
3103                    )
3104                })?;
3105            let codec = tonic_prost::ProstCodec::default();
3106            let path = http::uri::PathAndQuery::from_static(
3107                "/meta.StreamManagerService/AlterConnectorProps",
3108            );
3109            let mut req = request.into_request();
3110            req.extensions_mut()
3111                .insert(
3112                    GrpcMethod::new("meta.StreamManagerService", "AlterConnectorProps"),
3113                );
3114            self.inner.unary(req, path, codec).await
3115        }
3116        pub async fn alter_source_properties_safe(
3117            &mut self,
3118            request: impl tonic::IntoRequest<super::AlterSourcePropertiesSafeRequest>,
3119        ) -> std::result::Result<
3120            tonic::Response<super::AlterSourcePropertiesSafeResponse>,
3121            tonic::Status,
3122        > {
3123            self.inner
3124                .ready()
3125                .await
3126                .map_err(|e| {
3127                    tonic::Status::unknown(
3128                        format!("Service was not ready: {}", e.into()),
3129                    )
3130                })?;
3131            let codec = tonic_prost::ProstCodec::default();
3132            let path = http::uri::PathAndQuery::from_static(
3133                "/meta.StreamManagerService/AlterSourcePropertiesSafe",
3134            );
3135            let mut req = request.into_request();
3136            req.extensions_mut()
3137                .insert(
3138                    GrpcMethod::new(
3139                        "meta.StreamManagerService",
3140                        "AlterSourcePropertiesSafe",
3141                    ),
3142                );
3143            self.inner.unary(req, path, codec).await
3144        }
3145        pub async fn reset_source_splits(
3146            &mut self,
3147            request: impl tonic::IntoRequest<super::ResetSourceSplitsRequest>,
3148        ) -> std::result::Result<
3149            tonic::Response<super::ResetSourceSplitsResponse>,
3150            tonic::Status,
3151        > {
3152            self.inner
3153                .ready()
3154                .await
3155                .map_err(|e| {
3156                    tonic::Status::unknown(
3157                        format!("Service was not ready: {}", e.into()),
3158                    )
3159                })?;
3160            let codec = tonic_prost::ProstCodec::default();
3161            let path = http::uri::PathAndQuery::from_static(
3162                "/meta.StreamManagerService/ResetSourceSplits",
3163            );
3164            let mut req = request.into_request();
3165            req.extensions_mut()
3166                .insert(
3167                    GrpcMethod::new("meta.StreamManagerService", "ResetSourceSplits"),
3168                );
3169            self.inner.unary(req, path, codec).await
3170        }
3171        pub async fn inject_source_offsets(
3172            &mut self,
3173            request: impl tonic::IntoRequest<super::InjectSourceOffsetsRequest>,
3174        ) -> std::result::Result<
3175            tonic::Response<super::InjectSourceOffsetsResponse>,
3176            tonic::Status,
3177        > {
3178            self.inner
3179                .ready()
3180                .await
3181                .map_err(|e| {
3182                    tonic::Status::unknown(
3183                        format!("Service was not ready: {}", e.into()),
3184                    )
3185                })?;
3186            let codec = tonic_prost::ProstCodec::default();
3187            let path = http::uri::PathAndQuery::from_static(
3188                "/meta.StreamManagerService/InjectSourceOffsets",
3189            );
3190            let mut req = request.into_request();
3191            req.extensions_mut()
3192                .insert(
3193                    GrpcMethod::new("meta.StreamManagerService", "InjectSourceOffsets"),
3194                );
3195            self.inner.unary(req, path, codec).await
3196        }
3197        pub async fn get_fragment_by_id(
3198            &mut self,
3199            request: impl tonic::IntoRequest<super::GetFragmentByIdRequest>,
3200        ) -> std::result::Result<
3201            tonic::Response<super::GetFragmentByIdResponse>,
3202            tonic::Status,
3203        > {
3204            self.inner
3205                .ready()
3206                .await
3207                .map_err(|e| {
3208                    tonic::Status::unknown(
3209                        format!("Service was not ready: {}", e.into()),
3210                    )
3211                })?;
3212            let codec = tonic_prost::ProstCodec::default();
3213            let path = http::uri::PathAndQuery::from_static(
3214                "/meta.StreamManagerService/GetFragmentById",
3215            );
3216            let mut req = request.into_request();
3217            req.extensions_mut()
3218                .insert(GrpcMethod::new("meta.StreamManagerService", "GetFragmentById"));
3219            self.inner.unary(req, path, codec).await
3220        }
3221        pub async fn get_fragment_vnodes(
3222            &mut self,
3223            request: impl tonic::IntoRequest<super::GetFragmentVnodesRequest>,
3224        ) -> std::result::Result<
3225            tonic::Response<super::GetFragmentVnodesResponse>,
3226            tonic::Status,
3227        > {
3228            self.inner
3229                .ready()
3230                .await
3231                .map_err(|e| {
3232                    tonic::Status::unknown(
3233                        format!("Service was not ready: {}", e.into()),
3234                    )
3235                })?;
3236            let codec = tonic_prost::ProstCodec::default();
3237            let path = http::uri::PathAndQuery::from_static(
3238                "/meta.StreamManagerService/GetFragmentVnodes",
3239            );
3240            let mut req = request.into_request();
3241            req.extensions_mut()
3242                .insert(
3243                    GrpcMethod::new("meta.StreamManagerService", "GetFragmentVnodes"),
3244                );
3245            self.inner.unary(req, path, codec).await
3246        }
3247        pub async fn get_actor_vnodes(
3248            &mut self,
3249            request: impl tonic::IntoRequest<super::GetActorVnodesRequest>,
3250        ) -> std::result::Result<
3251            tonic::Response<super::GetActorVnodesResponse>,
3252            tonic::Status,
3253        > {
3254            self.inner
3255                .ready()
3256                .await
3257                .map_err(|e| {
3258                    tonic::Status::unknown(
3259                        format!("Service was not ready: {}", e.into()),
3260                    )
3261                })?;
3262            let codec = tonic_prost::ProstCodec::default();
3263            let path = http::uri::PathAndQuery::from_static(
3264                "/meta.StreamManagerService/GetActorVnodes",
3265            );
3266            let mut req = request.into_request();
3267            req.extensions_mut()
3268                .insert(GrpcMethod::new("meta.StreamManagerService", "GetActorVnodes"));
3269            self.inner.unary(req, path, codec).await
3270        }
3271        pub async fn set_sync_log_store_aligned(
3272            &mut self,
3273            request: impl tonic::IntoRequest<super::SetSyncLogStoreAlignedRequest>,
3274        ) -> std::result::Result<
3275            tonic::Response<super::SetSyncLogStoreAlignedResponse>,
3276            tonic::Status,
3277        > {
3278            self.inner
3279                .ready()
3280                .await
3281                .map_err(|e| {
3282                    tonic::Status::unknown(
3283                        format!("Service was not ready: {}", e.into()),
3284                    )
3285                })?;
3286            let codec = tonic_prost::ProstCodec::default();
3287            let path = http::uri::PathAndQuery::from_static(
3288                "/meta.StreamManagerService/SetSyncLogStoreAligned",
3289            );
3290            let mut req = request.into_request();
3291            req.extensions_mut()
3292                .insert(
3293                    GrpcMethod::new(
3294                        "meta.StreamManagerService",
3295                        "SetSyncLogStoreAligned",
3296                    ),
3297                );
3298            self.inner.unary(req, path, codec).await
3299        }
3300        pub async fn list_cdc_progress(
3301            &mut self,
3302            request: impl tonic::IntoRequest<super::ListCdcProgressRequest>,
3303        ) -> std::result::Result<
3304            tonic::Response<super::ListCdcProgressResponse>,
3305            tonic::Status,
3306        > {
3307            self.inner
3308                .ready()
3309                .await
3310                .map_err(|e| {
3311                    tonic::Status::unknown(
3312                        format!("Service was not ready: {}", e.into()),
3313                    )
3314                })?;
3315            let codec = tonic_prost::ProstCodec::default();
3316            let path = http::uri::PathAndQuery::from_static(
3317                "/meta.StreamManagerService/ListCdcProgress",
3318            );
3319            let mut req = request.into_request();
3320            req.extensions_mut()
3321                .insert(GrpcMethod::new("meta.StreamManagerService", "ListCdcProgress"));
3322            self.inner.unary(req, path, codec).await
3323        }
3324        pub async fn list_unmigrated_tables(
3325            &mut self,
3326            request: impl tonic::IntoRequest<super::ListUnmigratedTablesRequest>,
3327        ) -> std::result::Result<
3328            tonic::Response<super::ListUnmigratedTablesResponse>,
3329            tonic::Status,
3330        > {
3331            self.inner
3332                .ready()
3333                .await
3334                .map_err(|e| {
3335                    tonic::Status::unknown(
3336                        format!("Service was not ready: {}", e.into()),
3337                    )
3338                })?;
3339            let codec = tonic_prost::ProstCodec::default();
3340            let path = http::uri::PathAndQuery::from_static(
3341                "/meta.StreamManagerService/ListUnmigratedTables",
3342            );
3343            let mut req = request.into_request();
3344            req.extensions_mut()
3345                .insert(
3346                    GrpcMethod::new("meta.StreamManagerService", "ListUnmigratedTables"),
3347                );
3348            self.inner.unary(req, path, codec).await
3349        }
3350        pub async fn list_refresh_table_states(
3351            &mut self,
3352            request: impl tonic::IntoRequest<super::ListRefreshTableStatesRequest>,
3353        ) -> std::result::Result<
3354            tonic::Response<super::ListRefreshTableStatesResponse>,
3355            tonic::Status,
3356        > {
3357            self.inner
3358                .ready()
3359                .await
3360                .map_err(|e| {
3361                    tonic::Status::unknown(
3362                        format!("Service was not ready: {}", e.into()),
3363                    )
3364                })?;
3365            let codec = tonic_prost::ProstCodec::default();
3366            let path = http::uri::PathAndQuery::from_static(
3367                "/meta.StreamManagerService/ListRefreshTableStates",
3368            );
3369            let mut req = request.into_request();
3370            req.extensions_mut()
3371                .insert(
3372                    GrpcMethod::new(
3373                        "meta.StreamManagerService",
3374                        "ListRefreshTableStates",
3375                    ),
3376                );
3377            self.inner.unary(req, path, codec).await
3378        }
3379        pub async fn list_iceberg_compaction_status(
3380            &mut self,
3381            request: impl tonic::IntoRequest<super::ListIcebergCompactionStatusRequest>,
3382        ) -> std::result::Result<
3383            tonic::Response<super::ListIcebergCompactionStatusResponse>,
3384            tonic::Status,
3385        > {
3386            self.inner
3387                .ready()
3388                .await
3389                .map_err(|e| {
3390                    tonic::Status::unknown(
3391                        format!("Service was not ready: {}", e.into()),
3392                    )
3393                })?;
3394            let codec = tonic_prost::ProstCodec::default();
3395            let path = http::uri::PathAndQuery::from_static(
3396                "/meta.StreamManagerService/ListIcebergCompactionStatus",
3397            );
3398            let mut req = request.into_request();
3399            req.extensions_mut()
3400                .insert(
3401                    GrpcMethod::new(
3402                        "meta.StreamManagerService",
3403                        "ListIcebergCompactionStatus",
3404                    ),
3405                );
3406            self.inner.unary(req, path, codec).await
3407        }
3408    }
3409}
3410/// Generated server implementations.
3411pub mod stream_manager_service_server {
3412    #![allow(
3413        unused_variables,
3414        dead_code,
3415        missing_docs,
3416        clippy::wildcard_imports,
3417        clippy::let_unit_value,
3418    )]
3419    use tonic::codegen::*;
3420    /// Generated trait containing gRPC methods that should be implemented for use with StreamManagerServiceServer.
3421    #[async_trait]
3422    pub trait StreamManagerService: std::marker::Send + std::marker::Sync + 'static {
3423        async fn flush(
3424            &self,
3425            request: tonic::Request<super::FlushRequest>,
3426        ) -> std::result::Result<tonic::Response<super::FlushResponse>, tonic::Status>;
3427        async fn pause(
3428            &self,
3429            request: tonic::Request<super::PauseRequest>,
3430        ) -> std::result::Result<tonic::Response<super::PauseResponse>, tonic::Status>;
3431        async fn resume(
3432            &self,
3433            request: tonic::Request<super::ResumeRequest>,
3434        ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status>;
3435        async fn refresh(
3436            &self,
3437            request: tonic::Request<super::RefreshRequest>,
3438        ) -> std::result::Result<tonic::Response<super::RefreshResponse>, tonic::Status>;
3439        async fn cancel_creating_jobs(
3440            &self,
3441            request: tonic::Request<super::CancelCreatingJobsRequest>,
3442        ) -> std::result::Result<
3443            tonic::Response<super::CancelCreatingJobsResponse>,
3444            tonic::Status,
3445        >;
3446        async fn list_table_fragments(
3447            &self,
3448            request: tonic::Request<super::ListTableFragmentsRequest>,
3449        ) -> std::result::Result<
3450            tonic::Response<super::ListTableFragmentsResponse>,
3451            tonic::Status,
3452        >;
3453        async fn list_streaming_job_states(
3454            &self,
3455            request: tonic::Request<super::ListStreamingJobStatesRequest>,
3456        ) -> std::result::Result<
3457            tonic::Response<super::ListStreamingJobStatesResponse>,
3458            tonic::Status,
3459        >;
3460        async fn list_fragment_distribution(
3461            &self,
3462            request: tonic::Request<super::ListFragmentDistributionRequest>,
3463        ) -> std::result::Result<
3464            tonic::Response<super::ListFragmentDistributionResponse>,
3465            tonic::Status,
3466        >;
3467        async fn list_creating_fragment_distribution(
3468            &self,
3469            request: tonic::Request<super::ListCreatingFragmentDistributionRequest>,
3470        ) -> std::result::Result<
3471            tonic::Response<super::ListCreatingFragmentDistributionResponse>,
3472            tonic::Status,
3473        >;
3474        async fn list_sink_log_store_tables(
3475            &self,
3476            request: tonic::Request<super::ListSinkLogStoreTablesRequest>,
3477        ) -> std::result::Result<
3478            tonic::Response<super::ListSinkLogStoreTablesResponse>,
3479            tonic::Status,
3480        >;
3481        async fn list_actor_states(
3482            &self,
3483            request: tonic::Request<super::ListActorStatesRequest>,
3484        ) -> std::result::Result<
3485            tonic::Response<super::ListActorStatesResponse>,
3486            tonic::Status,
3487        >;
3488        async fn list_actor_splits(
3489            &self,
3490            request: tonic::Request<super::ListActorSplitsRequest>,
3491        ) -> std::result::Result<
3492            tonic::Response<super::ListActorSplitsResponse>,
3493            tonic::Status,
3494        >;
3495        async fn apply_throttle(
3496            &self,
3497            request: tonic::Request<super::ApplyThrottleRequest>,
3498        ) -> std::result::Result<
3499            tonic::Response<super::ApplyThrottleResponse>,
3500            tonic::Status,
3501        >;
3502        async fn recover(
3503            &self,
3504            request: tonic::Request<super::RecoverRequest>,
3505        ) -> std::result::Result<tonic::Response<super::RecoverResponse>, tonic::Status>;
3506        async fn list_rate_limits(
3507            &self,
3508            request: tonic::Request<super::ListRateLimitsRequest>,
3509        ) -> std::result::Result<
3510            tonic::Response<super::ListRateLimitsResponse>,
3511            tonic::Status,
3512        >;
3513        async fn alter_connector_props(
3514            &self,
3515            request: tonic::Request<super::AlterConnectorPropsRequest>,
3516        ) -> std::result::Result<
3517            tonic::Response<super::AlterConnectorPropsResponse>,
3518            tonic::Status,
3519        >;
3520        async fn alter_source_properties_safe(
3521            &self,
3522            request: tonic::Request<super::AlterSourcePropertiesSafeRequest>,
3523        ) -> std::result::Result<
3524            tonic::Response<super::AlterSourcePropertiesSafeResponse>,
3525            tonic::Status,
3526        >;
3527        async fn reset_source_splits(
3528            &self,
3529            request: tonic::Request<super::ResetSourceSplitsRequest>,
3530        ) -> std::result::Result<
3531            tonic::Response<super::ResetSourceSplitsResponse>,
3532            tonic::Status,
3533        >;
3534        async fn inject_source_offsets(
3535            &self,
3536            request: tonic::Request<super::InjectSourceOffsetsRequest>,
3537        ) -> std::result::Result<
3538            tonic::Response<super::InjectSourceOffsetsResponse>,
3539            tonic::Status,
3540        >;
3541        async fn get_fragment_by_id(
3542            &self,
3543            request: tonic::Request<super::GetFragmentByIdRequest>,
3544        ) -> std::result::Result<
3545            tonic::Response<super::GetFragmentByIdResponse>,
3546            tonic::Status,
3547        >;
3548        async fn get_fragment_vnodes(
3549            &self,
3550            request: tonic::Request<super::GetFragmentVnodesRequest>,
3551        ) -> std::result::Result<
3552            tonic::Response<super::GetFragmentVnodesResponse>,
3553            tonic::Status,
3554        >;
3555        async fn get_actor_vnodes(
3556            &self,
3557            request: tonic::Request<super::GetActorVnodesRequest>,
3558        ) -> std::result::Result<
3559            tonic::Response<super::GetActorVnodesResponse>,
3560            tonic::Status,
3561        >;
3562        async fn set_sync_log_store_aligned(
3563            &self,
3564            request: tonic::Request<super::SetSyncLogStoreAlignedRequest>,
3565        ) -> std::result::Result<
3566            tonic::Response<super::SetSyncLogStoreAlignedResponse>,
3567            tonic::Status,
3568        >;
3569        async fn list_cdc_progress(
3570            &self,
3571            request: tonic::Request<super::ListCdcProgressRequest>,
3572        ) -> std::result::Result<
3573            tonic::Response<super::ListCdcProgressResponse>,
3574            tonic::Status,
3575        >;
3576        async fn list_unmigrated_tables(
3577            &self,
3578            request: tonic::Request<super::ListUnmigratedTablesRequest>,
3579        ) -> std::result::Result<
3580            tonic::Response<super::ListUnmigratedTablesResponse>,
3581            tonic::Status,
3582        >;
3583        async fn list_refresh_table_states(
3584            &self,
3585            request: tonic::Request<super::ListRefreshTableStatesRequest>,
3586        ) -> std::result::Result<
3587            tonic::Response<super::ListRefreshTableStatesResponse>,
3588            tonic::Status,
3589        >;
3590        async fn list_iceberg_compaction_status(
3591            &self,
3592            request: tonic::Request<super::ListIcebergCompactionStatusRequest>,
3593        ) -> std::result::Result<
3594            tonic::Response<super::ListIcebergCompactionStatusResponse>,
3595            tonic::Status,
3596        >;
3597    }
3598    #[derive(Debug)]
3599    pub struct StreamManagerServiceServer<T> {
3600        inner: Arc<T>,
3601        accept_compression_encodings: EnabledCompressionEncodings,
3602        send_compression_encodings: EnabledCompressionEncodings,
3603        max_decoding_message_size: Option<usize>,
3604        max_encoding_message_size: Option<usize>,
3605    }
3606    impl<T> StreamManagerServiceServer<T> {
3607        pub fn new(inner: T) -> Self {
3608            Self::from_arc(Arc::new(inner))
3609        }
3610        pub fn from_arc(inner: Arc<T>) -> Self {
3611            Self {
3612                inner,
3613                accept_compression_encodings: Default::default(),
3614                send_compression_encodings: Default::default(),
3615                max_decoding_message_size: None,
3616                max_encoding_message_size: None,
3617            }
3618        }
3619        pub fn with_interceptor<F>(
3620            inner: T,
3621            interceptor: F,
3622        ) -> InterceptedService<Self, F>
3623        where
3624            F: tonic::service::Interceptor,
3625        {
3626            InterceptedService::new(Self::new(inner), interceptor)
3627        }
3628        /// Enable decompressing requests with the given encoding.
3629        #[must_use]
3630        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
3631            self.accept_compression_encodings.enable(encoding);
3632            self
3633        }
3634        /// Compress responses with the given encoding, if the client supports it.
3635        #[must_use]
3636        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
3637            self.send_compression_encodings.enable(encoding);
3638            self
3639        }
3640        /// Limits the maximum size of a decoded message.
3641        ///
3642        /// Default: `4MB`
3643        #[must_use]
3644        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
3645            self.max_decoding_message_size = Some(limit);
3646            self
3647        }
3648        /// Limits the maximum size of an encoded message.
3649        ///
3650        /// Default: `usize::MAX`
3651        #[must_use]
3652        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
3653            self.max_encoding_message_size = Some(limit);
3654            self
3655        }
3656    }
3657    impl<T, B> tonic::codegen::Service<http::Request<B>>
3658    for StreamManagerServiceServer<T>
3659    where
3660        T: StreamManagerService,
3661        B: Body + std::marker::Send + 'static,
3662        B::Error: Into<StdError> + std::marker::Send + 'static,
3663    {
3664        type Response = http::Response<tonic::body::Body>;
3665        type Error = std::convert::Infallible;
3666        type Future = BoxFuture<Self::Response, Self::Error>;
3667        fn poll_ready(
3668            &mut self,
3669            _cx: &mut Context<'_>,
3670        ) -> Poll<std::result::Result<(), Self::Error>> {
3671            Poll::Ready(Ok(()))
3672        }
3673        fn call(&mut self, req: http::Request<B>) -> Self::Future {
3674            match req.uri().path() {
3675                "/meta.StreamManagerService/Flush" => {
3676                    #[allow(non_camel_case_types)]
3677                    struct FlushSvc<T: StreamManagerService>(pub Arc<T>);
3678                    impl<
3679                        T: StreamManagerService,
3680                    > tonic::server::UnaryService<super::FlushRequest> for FlushSvc<T> {
3681                        type Response = super::FlushResponse;
3682                        type Future = BoxFuture<
3683                            tonic::Response<Self::Response>,
3684                            tonic::Status,
3685                        >;
3686                        fn call(
3687                            &mut self,
3688                            request: tonic::Request<super::FlushRequest>,
3689                        ) -> Self::Future {
3690                            let inner = Arc::clone(&self.0);
3691                            let fut = async move {
3692                                <T as StreamManagerService>::flush(&inner, request).await
3693                            };
3694                            Box::pin(fut)
3695                        }
3696                    }
3697                    let accept_compression_encodings = self.accept_compression_encodings;
3698                    let send_compression_encodings = self.send_compression_encodings;
3699                    let max_decoding_message_size = self.max_decoding_message_size;
3700                    let max_encoding_message_size = self.max_encoding_message_size;
3701                    let inner = self.inner.clone();
3702                    let fut = async move {
3703                        let method = FlushSvc(inner);
3704                        let codec = tonic_prost::ProstCodec::default();
3705                        let mut grpc = tonic::server::Grpc::new(codec)
3706                            .apply_compression_config(
3707                                accept_compression_encodings,
3708                                send_compression_encodings,
3709                            )
3710                            .apply_max_message_size_config(
3711                                max_decoding_message_size,
3712                                max_encoding_message_size,
3713                            );
3714                        let res = grpc.unary(method, req).await;
3715                        Ok(res)
3716                    };
3717                    Box::pin(fut)
3718                }
3719                "/meta.StreamManagerService/Pause" => {
3720                    #[allow(non_camel_case_types)]
3721                    struct PauseSvc<T: StreamManagerService>(pub Arc<T>);
3722                    impl<
3723                        T: StreamManagerService,
3724                    > tonic::server::UnaryService<super::PauseRequest> for PauseSvc<T> {
3725                        type Response = super::PauseResponse;
3726                        type Future = BoxFuture<
3727                            tonic::Response<Self::Response>,
3728                            tonic::Status,
3729                        >;
3730                        fn call(
3731                            &mut self,
3732                            request: tonic::Request<super::PauseRequest>,
3733                        ) -> Self::Future {
3734                            let inner = Arc::clone(&self.0);
3735                            let fut = async move {
3736                                <T as StreamManagerService>::pause(&inner, request).await
3737                            };
3738                            Box::pin(fut)
3739                        }
3740                    }
3741                    let accept_compression_encodings = self.accept_compression_encodings;
3742                    let send_compression_encodings = self.send_compression_encodings;
3743                    let max_decoding_message_size = self.max_decoding_message_size;
3744                    let max_encoding_message_size = self.max_encoding_message_size;
3745                    let inner = self.inner.clone();
3746                    let fut = async move {
3747                        let method = PauseSvc(inner);
3748                        let codec = tonic_prost::ProstCodec::default();
3749                        let mut grpc = tonic::server::Grpc::new(codec)
3750                            .apply_compression_config(
3751                                accept_compression_encodings,
3752                                send_compression_encodings,
3753                            )
3754                            .apply_max_message_size_config(
3755                                max_decoding_message_size,
3756                                max_encoding_message_size,
3757                            );
3758                        let res = grpc.unary(method, req).await;
3759                        Ok(res)
3760                    };
3761                    Box::pin(fut)
3762                }
3763                "/meta.StreamManagerService/Resume" => {
3764                    #[allow(non_camel_case_types)]
3765                    struct ResumeSvc<T: StreamManagerService>(pub Arc<T>);
3766                    impl<
3767                        T: StreamManagerService,
3768                    > tonic::server::UnaryService<super::ResumeRequest>
3769                    for ResumeSvc<T> {
3770                        type Response = super::ResumeResponse;
3771                        type Future = BoxFuture<
3772                            tonic::Response<Self::Response>,
3773                            tonic::Status,
3774                        >;
3775                        fn call(
3776                            &mut self,
3777                            request: tonic::Request<super::ResumeRequest>,
3778                        ) -> Self::Future {
3779                            let inner = Arc::clone(&self.0);
3780                            let fut = async move {
3781                                <T as StreamManagerService>::resume(&inner, request).await
3782                            };
3783                            Box::pin(fut)
3784                        }
3785                    }
3786                    let accept_compression_encodings = self.accept_compression_encodings;
3787                    let send_compression_encodings = self.send_compression_encodings;
3788                    let max_decoding_message_size = self.max_decoding_message_size;
3789                    let max_encoding_message_size = self.max_encoding_message_size;
3790                    let inner = self.inner.clone();
3791                    let fut = async move {
3792                        let method = ResumeSvc(inner);
3793                        let codec = tonic_prost::ProstCodec::default();
3794                        let mut grpc = tonic::server::Grpc::new(codec)
3795                            .apply_compression_config(
3796                                accept_compression_encodings,
3797                                send_compression_encodings,
3798                            )
3799                            .apply_max_message_size_config(
3800                                max_decoding_message_size,
3801                                max_encoding_message_size,
3802                            );
3803                        let res = grpc.unary(method, req).await;
3804                        Ok(res)
3805                    };
3806                    Box::pin(fut)
3807                }
3808                "/meta.StreamManagerService/Refresh" => {
3809                    #[allow(non_camel_case_types)]
3810                    struct RefreshSvc<T: StreamManagerService>(pub Arc<T>);
3811                    impl<
3812                        T: StreamManagerService,
3813                    > tonic::server::UnaryService<super::RefreshRequest>
3814                    for RefreshSvc<T> {
3815                        type Response = super::RefreshResponse;
3816                        type Future = BoxFuture<
3817                            tonic::Response<Self::Response>,
3818                            tonic::Status,
3819                        >;
3820                        fn call(
3821                            &mut self,
3822                            request: tonic::Request<super::RefreshRequest>,
3823                        ) -> Self::Future {
3824                            let inner = Arc::clone(&self.0);
3825                            let fut = async move {
3826                                <T as StreamManagerService>::refresh(&inner, request).await
3827                            };
3828                            Box::pin(fut)
3829                        }
3830                    }
3831                    let accept_compression_encodings = self.accept_compression_encodings;
3832                    let send_compression_encodings = self.send_compression_encodings;
3833                    let max_decoding_message_size = self.max_decoding_message_size;
3834                    let max_encoding_message_size = self.max_encoding_message_size;
3835                    let inner = self.inner.clone();
3836                    let fut = async move {
3837                        let method = RefreshSvc(inner);
3838                        let codec = tonic_prost::ProstCodec::default();
3839                        let mut grpc = tonic::server::Grpc::new(codec)
3840                            .apply_compression_config(
3841                                accept_compression_encodings,
3842                                send_compression_encodings,
3843                            )
3844                            .apply_max_message_size_config(
3845                                max_decoding_message_size,
3846                                max_encoding_message_size,
3847                            );
3848                        let res = grpc.unary(method, req).await;
3849                        Ok(res)
3850                    };
3851                    Box::pin(fut)
3852                }
3853                "/meta.StreamManagerService/CancelCreatingJobs" => {
3854                    #[allow(non_camel_case_types)]
3855                    struct CancelCreatingJobsSvc<T: StreamManagerService>(pub Arc<T>);
3856                    impl<
3857                        T: StreamManagerService,
3858                    > tonic::server::UnaryService<super::CancelCreatingJobsRequest>
3859                    for CancelCreatingJobsSvc<T> {
3860                        type Response = super::CancelCreatingJobsResponse;
3861                        type Future = BoxFuture<
3862                            tonic::Response<Self::Response>,
3863                            tonic::Status,
3864                        >;
3865                        fn call(
3866                            &mut self,
3867                            request: tonic::Request<super::CancelCreatingJobsRequest>,
3868                        ) -> Self::Future {
3869                            let inner = Arc::clone(&self.0);
3870                            let fut = async move {
3871                                <T as StreamManagerService>::cancel_creating_jobs(
3872                                        &inner,
3873                                        request,
3874                                    )
3875                                    .await
3876                            };
3877                            Box::pin(fut)
3878                        }
3879                    }
3880                    let accept_compression_encodings = self.accept_compression_encodings;
3881                    let send_compression_encodings = self.send_compression_encodings;
3882                    let max_decoding_message_size = self.max_decoding_message_size;
3883                    let max_encoding_message_size = self.max_encoding_message_size;
3884                    let inner = self.inner.clone();
3885                    let fut = async move {
3886                        let method = CancelCreatingJobsSvc(inner);
3887                        let codec = tonic_prost::ProstCodec::default();
3888                        let mut grpc = tonic::server::Grpc::new(codec)
3889                            .apply_compression_config(
3890                                accept_compression_encodings,
3891                                send_compression_encodings,
3892                            )
3893                            .apply_max_message_size_config(
3894                                max_decoding_message_size,
3895                                max_encoding_message_size,
3896                            );
3897                        let res = grpc.unary(method, req).await;
3898                        Ok(res)
3899                    };
3900                    Box::pin(fut)
3901                }
3902                "/meta.StreamManagerService/ListTableFragments" => {
3903                    #[allow(non_camel_case_types)]
3904                    struct ListTableFragmentsSvc<T: StreamManagerService>(pub Arc<T>);
3905                    impl<
3906                        T: StreamManagerService,
3907                    > tonic::server::UnaryService<super::ListTableFragmentsRequest>
3908                    for ListTableFragmentsSvc<T> {
3909                        type Response = super::ListTableFragmentsResponse;
3910                        type Future = BoxFuture<
3911                            tonic::Response<Self::Response>,
3912                            tonic::Status,
3913                        >;
3914                        fn call(
3915                            &mut self,
3916                            request: tonic::Request<super::ListTableFragmentsRequest>,
3917                        ) -> Self::Future {
3918                            let inner = Arc::clone(&self.0);
3919                            let fut = async move {
3920                                <T as StreamManagerService>::list_table_fragments(
3921                                        &inner,
3922                                        request,
3923                                    )
3924                                    .await
3925                            };
3926                            Box::pin(fut)
3927                        }
3928                    }
3929                    let accept_compression_encodings = self.accept_compression_encodings;
3930                    let send_compression_encodings = self.send_compression_encodings;
3931                    let max_decoding_message_size = self.max_decoding_message_size;
3932                    let max_encoding_message_size = self.max_encoding_message_size;
3933                    let inner = self.inner.clone();
3934                    let fut = async move {
3935                        let method = ListTableFragmentsSvc(inner);
3936                        let codec = tonic_prost::ProstCodec::default();
3937                        let mut grpc = tonic::server::Grpc::new(codec)
3938                            .apply_compression_config(
3939                                accept_compression_encodings,
3940                                send_compression_encodings,
3941                            )
3942                            .apply_max_message_size_config(
3943                                max_decoding_message_size,
3944                                max_encoding_message_size,
3945                            );
3946                        let res = grpc.unary(method, req).await;
3947                        Ok(res)
3948                    };
3949                    Box::pin(fut)
3950                }
3951                "/meta.StreamManagerService/ListStreamingJobStates" => {
3952                    #[allow(non_camel_case_types)]
3953                    struct ListStreamingJobStatesSvc<T: StreamManagerService>(
3954                        pub Arc<T>,
3955                    );
3956                    impl<
3957                        T: StreamManagerService,
3958                    > tonic::server::UnaryService<super::ListStreamingJobStatesRequest>
3959                    for ListStreamingJobStatesSvc<T> {
3960                        type Response = super::ListStreamingJobStatesResponse;
3961                        type Future = BoxFuture<
3962                            tonic::Response<Self::Response>,
3963                            tonic::Status,
3964                        >;
3965                        fn call(
3966                            &mut self,
3967                            request: tonic::Request<super::ListStreamingJobStatesRequest>,
3968                        ) -> Self::Future {
3969                            let inner = Arc::clone(&self.0);
3970                            let fut = async move {
3971                                <T as StreamManagerService>::list_streaming_job_states(
3972                                        &inner,
3973                                        request,
3974                                    )
3975                                    .await
3976                            };
3977                            Box::pin(fut)
3978                        }
3979                    }
3980                    let accept_compression_encodings = self.accept_compression_encodings;
3981                    let send_compression_encodings = self.send_compression_encodings;
3982                    let max_decoding_message_size = self.max_decoding_message_size;
3983                    let max_encoding_message_size = self.max_encoding_message_size;
3984                    let inner = self.inner.clone();
3985                    let fut = async move {
3986                        let method = ListStreamingJobStatesSvc(inner);
3987                        let codec = tonic_prost::ProstCodec::default();
3988                        let mut grpc = tonic::server::Grpc::new(codec)
3989                            .apply_compression_config(
3990                                accept_compression_encodings,
3991                                send_compression_encodings,
3992                            )
3993                            .apply_max_message_size_config(
3994                                max_decoding_message_size,
3995                                max_encoding_message_size,
3996                            );
3997                        let res = grpc.unary(method, req).await;
3998                        Ok(res)
3999                    };
4000                    Box::pin(fut)
4001                }
4002                "/meta.StreamManagerService/ListFragmentDistribution" => {
4003                    #[allow(non_camel_case_types)]
4004                    struct ListFragmentDistributionSvc<T: StreamManagerService>(
4005                        pub Arc<T>,
4006                    );
4007                    impl<
4008                        T: StreamManagerService,
4009                    > tonic::server::UnaryService<super::ListFragmentDistributionRequest>
4010                    for ListFragmentDistributionSvc<T> {
4011                        type Response = super::ListFragmentDistributionResponse;
4012                        type Future = BoxFuture<
4013                            tonic::Response<Self::Response>,
4014                            tonic::Status,
4015                        >;
4016                        fn call(
4017                            &mut self,
4018                            request: tonic::Request<
4019                                super::ListFragmentDistributionRequest,
4020                            >,
4021                        ) -> Self::Future {
4022                            let inner = Arc::clone(&self.0);
4023                            let fut = async move {
4024                                <T as StreamManagerService>::list_fragment_distribution(
4025                                        &inner,
4026                                        request,
4027                                    )
4028                                    .await
4029                            };
4030                            Box::pin(fut)
4031                        }
4032                    }
4033                    let accept_compression_encodings = self.accept_compression_encodings;
4034                    let send_compression_encodings = self.send_compression_encodings;
4035                    let max_decoding_message_size = self.max_decoding_message_size;
4036                    let max_encoding_message_size = self.max_encoding_message_size;
4037                    let inner = self.inner.clone();
4038                    let fut = async move {
4039                        let method = ListFragmentDistributionSvc(inner);
4040                        let codec = tonic_prost::ProstCodec::default();
4041                        let mut grpc = tonic::server::Grpc::new(codec)
4042                            .apply_compression_config(
4043                                accept_compression_encodings,
4044                                send_compression_encodings,
4045                            )
4046                            .apply_max_message_size_config(
4047                                max_decoding_message_size,
4048                                max_encoding_message_size,
4049                            );
4050                        let res = grpc.unary(method, req).await;
4051                        Ok(res)
4052                    };
4053                    Box::pin(fut)
4054                }
4055                "/meta.StreamManagerService/ListCreatingFragmentDistribution" => {
4056                    #[allow(non_camel_case_types)]
4057                    struct ListCreatingFragmentDistributionSvc<T: StreamManagerService>(
4058                        pub Arc<T>,
4059                    );
4060                    impl<
4061                        T: StreamManagerService,
4062                    > tonic::server::UnaryService<
4063                        super::ListCreatingFragmentDistributionRequest,
4064                    > for ListCreatingFragmentDistributionSvc<T> {
4065                        type Response = super::ListCreatingFragmentDistributionResponse;
4066                        type Future = BoxFuture<
4067                            tonic::Response<Self::Response>,
4068                            tonic::Status,
4069                        >;
4070                        fn call(
4071                            &mut self,
4072                            request: tonic::Request<
4073                                super::ListCreatingFragmentDistributionRequest,
4074                            >,
4075                        ) -> Self::Future {
4076                            let inner = Arc::clone(&self.0);
4077                            let fut = async move {
4078                                <T as StreamManagerService>::list_creating_fragment_distribution(
4079                                        &inner,
4080                                        request,
4081                                    )
4082                                    .await
4083                            };
4084                            Box::pin(fut)
4085                        }
4086                    }
4087                    let accept_compression_encodings = self.accept_compression_encodings;
4088                    let send_compression_encodings = self.send_compression_encodings;
4089                    let max_decoding_message_size = self.max_decoding_message_size;
4090                    let max_encoding_message_size = self.max_encoding_message_size;
4091                    let inner = self.inner.clone();
4092                    let fut = async move {
4093                        let method = ListCreatingFragmentDistributionSvc(inner);
4094                        let codec = tonic_prost::ProstCodec::default();
4095                        let mut grpc = tonic::server::Grpc::new(codec)
4096                            .apply_compression_config(
4097                                accept_compression_encodings,
4098                                send_compression_encodings,
4099                            )
4100                            .apply_max_message_size_config(
4101                                max_decoding_message_size,
4102                                max_encoding_message_size,
4103                            );
4104                        let res = grpc.unary(method, req).await;
4105                        Ok(res)
4106                    };
4107                    Box::pin(fut)
4108                }
4109                "/meta.StreamManagerService/ListSinkLogStoreTables" => {
4110                    #[allow(non_camel_case_types)]
4111                    struct ListSinkLogStoreTablesSvc<T: StreamManagerService>(
4112                        pub Arc<T>,
4113                    );
4114                    impl<
4115                        T: StreamManagerService,
4116                    > tonic::server::UnaryService<super::ListSinkLogStoreTablesRequest>
4117                    for ListSinkLogStoreTablesSvc<T> {
4118                        type Response = super::ListSinkLogStoreTablesResponse;
4119                        type Future = BoxFuture<
4120                            tonic::Response<Self::Response>,
4121                            tonic::Status,
4122                        >;
4123                        fn call(
4124                            &mut self,
4125                            request: tonic::Request<super::ListSinkLogStoreTablesRequest>,
4126                        ) -> Self::Future {
4127                            let inner = Arc::clone(&self.0);
4128                            let fut = async move {
4129                                <T as StreamManagerService>::list_sink_log_store_tables(
4130                                        &inner,
4131                                        request,
4132                                    )
4133                                    .await
4134                            };
4135                            Box::pin(fut)
4136                        }
4137                    }
4138                    let accept_compression_encodings = self.accept_compression_encodings;
4139                    let send_compression_encodings = self.send_compression_encodings;
4140                    let max_decoding_message_size = self.max_decoding_message_size;
4141                    let max_encoding_message_size = self.max_encoding_message_size;
4142                    let inner = self.inner.clone();
4143                    let fut = async move {
4144                        let method = ListSinkLogStoreTablesSvc(inner);
4145                        let codec = tonic_prost::ProstCodec::default();
4146                        let mut grpc = tonic::server::Grpc::new(codec)
4147                            .apply_compression_config(
4148                                accept_compression_encodings,
4149                                send_compression_encodings,
4150                            )
4151                            .apply_max_message_size_config(
4152                                max_decoding_message_size,
4153                                max_encoding_message_size,
4154                            );
4155                        let res = grpc.unary(method, req).await;
4156                        Ok(res)
4157                    };
4158                    Box::pin(fut)
4159                }
4160                "/meta.StreamManagerService/ListActorStates" => {
4161                    #[allow(non_camel_case_types)]
4162                    struct ListActorStatesSvc<T: StreamManagerService>(pub Arc<T>);
4163                    impl<
4164                        T: StreamManagerService,
4165                    > tonic::server::UnaryService<super::ListActorStatesRequest>
4166                    for ListActorStatesSvc<T> {
4167                        type Response = super::ListActorStatesResponse;
4168                        type Future = BoxFuture<
4169                            tonic::Response<Self::Response>,
4170                            tonic::Status,
4171                        >;
4172                        fn call(
4173                            &mut self,
4174                            request: tonic::Request<super::ListActorStatesRequest>,
4175                        ) -> Self::Future {
4176                            let inner = Arc::clone(&self.0);
4177                            let fut = async move {
4178                                <T as StreamManagerService>::list_actor_states(
4179                                        &inner,
4180                                        request,
4181                                    )
4182                                    .await
4183                            };
4184                            Box::pin(fut)
4185                        }
4186                    }
4187                    let accept_compression_encodings = self.accept_compression_encodings;
4188                    let send_compression_encodings = self.send_compression_encodings;
4189                    let max_decoding_message_size = self.max_decoding_message_size;
4190                    let max_encoding_message_size = self.max_encoding_message_size;
4191                    let inner = self.inner.clone();
4192                    let fut = async move {
4193                        let method = ListActorStatesSvc(inner);
4194                        let codec = tonic_prost::ProstCodec::default();
4195                        let mut grpc = tonic::server::Grpc::new(codec)
4196                            .apply_compression_config(
4197                                accept_compression_encodings,
4198                                send_compression_encodings,
4199                            )
4200                            .apply_max_message_size_config(
4201                                max_decoding_message_size,
4202                                max_encoding_message_size,
4203                            );
4204                        let res = grpc.unary(method, req).await;
4205                        Ok(res)
4206                    };
4207                    Box::pin(fut)
4208                }
4209                "/meta.StreamManagerService/ListActorSplits" => {
4210                    #[allow(non_camel_case_types)]
4211                    struct ListActorSplitsSvc<T: StreamManagerService>(pub Arc<T>);
4212                    impl<
4213                        T: StreamManagerService,
4214                    > tonic::server::UnaryService<super::ListActorSplitsRequest>
4215                    for ListActorSplitsSvc<T> {
4216                        type Response = super::ListActorSplitsResponse;
4217                        type Future = BoxFuture<
4218                            tonic::Response<Self::Response>,
4219                            tonic::Status,
4220                        >;
4221                        fn call(
4222                            &mut self,
4223                            request: tonic::Request<super::ListActorSplitsRequest>,
4224                        ) -> Self::Future {
4225                            let inner = Arc::clone(&self.0);
4226                            let fut = async move {
4227                                <T as StreamManagerService>::list_actor_splits(
4228                                        &inner,
4229                                        request,
4230                                    )
4231                                    .await
4232                            };
4233                            Box::pin(fut)
4234                        }
4235                    }
4236                    let accept_compression_encodings = self.accept_compression_encodings;
4237                    let send_compression_encodings = self.send_compression_encodings;
4238                    let max_decoding_message_size = self.max_decoding_message_size;
4239                    let max_encoding_message_size = self.max_encoding_message_size;
4240                    let inner = self.inner.clone();
4241                    let fut = async move {
4242                        let method = ListActorSplitsSvc(inner);
4243                        let codec = tonic_prost::ProstCodec::default();
4244                        let mut grpc = tonic::server::Grpc::new(codec)
4245                            .apply_compression_config(
4246                                accept_compression_encodings,
4247                                send_compression_encodings,
4248                            )
4249                            .apply_max_message_size_config(
4250                                max_decoding_message_size,
4251                                max_encoding_message_size,
4252                            );
4253                        let res = grpc.unary(method, req).await;
4254                        Ok(res)
4255                    };
4256                    Box::pin(fut)
4257                }
4258                "/meta.StreamManagerService/ApplyThrottle" => {
4259                    #[allow(non_camel_case_types)]
4260                    struct ApplyThrottleSvc<T: StreamManagerService>(pub Arc<T>);
4261                    impl<
4262                        T: StreamManagerService,
4263                    > tonic::server::UnaryService<super::ApplyThrottleRequest>
4264                    for ApplyThrottleSvc<T> {
4265                        type Response = super::ApplyThrottleResponse;
4266                        type Future = BoxFuture<
4267                            tonic::Response<Self::Response>,
4268                            tonic::Status,
4269                        >;
4270                        fn call(
4271                            &mut self,
4272                            request: tonic::Request<super::ApplyThrottleRequest>,
4273                        ) -> Self::Future {
4274                            let inner = Arc::clone(&self.0);
4275                            let fut = async move {
4276                                <T as StreamManagerService>::apply_throttle(&inner, request)
4277                                    .await
4278                            };
4279                            Box::pin(fut)
4280                        }
4281                    }
4282                    let accept_compression_encodings = self.accept_compression_encodings;
4283                    let send_compression_encodings = self.send_compression_encodings;
4284                    let max_decoding_message_size = self.max_decoding_message_size;
4285                    let max_encoding_message_size = self.max_encoding_message_size;
4286                    let inner = self.inner.clone();
4287                    let fut = async move {
4288                        let method = ApplyThrottleSvc(inner);
4289                        let codec = tonic_prost::ProstCodec::default();
4290                        let mut grpc = tonic::server::Grpc::new(codec)
4291                            .apply_compression_config(
4292                                accept_compression_encodings,
4293                                send_compression_encodings,
4294                            )
4295                            .apply_max_message_size_config(
4296                                max_decoding_message_size,
4297                                max_encoding_message_size,
4298                            );
4299                        let res = grpc.unary(method, req).await;
4300                        Ok(res)
4301                    };
4302                    Box::pin(fut)
4303                }
4304                "/meta.StreamManagerService/Recover" => {
4305                    #[allow(non_camel_case_types)]
4306                    struct RecoverSvc<T: StreamManagerService>(pub Arc<T>);
4307                    impl<
4308                        T: StreamManagerService,
4309                    > tonic::server::UnaryService<super::RecoverRequest>
4310                    for RecoverSvc<T> {
4311                        type Response = super::RecoverResponse;
4312                        type Future = BoxFuture<
4313                            tonic::Response<Self::Response>,
4314                            tonic::Status,
4315                        >;
4316                        fn call(
4317                            &mut self,
4318                            request: tonic::Request<super::RecoverRequest>,
4319                        ) -> Self::Future {
4320                            let inner = Arc::clone(&self.0);
4321                            let fut = async move {
4322                                <T as StreamManagerService>::recover(&inner, request).await
4323                            };
4324                            Box::pin(fut)
4325                        }
4326                    }
4327                    let accept_compression_encodings = self.accept_compression_encodings;
4328                    let send_compression_encodings = self.send_compression_encodings;
4329                    let max_decoding_message_size = self.max_decoding_message_size;
4330                    let max_encoding_message_size = self.max_encoding_message_size;
4331                    let inner = self.inner.clone();
4332                    let fut = async move {
4333                        let method = RecoverSvc(inner);
4334                        let codec = tonic_prost::ProstCodec::default();
4335                        let mut grpc = tonic::server::Grpc::new(codec)
4336                            .apply_compression_config(
4337                                accept_compression_encodings,
4338                                send_compression_encodings,
4339                            )
4340                            .apply_max_message_size_config(
4341                                max_decoding_message_size,
4342                                max_encoding_message_size,
4343                            );
4344                        let res = grpc.unary(method, req).await;
4345                        Ok(res)
4346                    };
4347                    Box::pin(fut)
4348                }
4349                "/meta.StreamManagerService/ListRateLimits" => {
4350                    #[allow(non_camel_case_types)]
4351                    struct ListRateLimitsSvc<T: StreamManagerService>(pub Arc<T>);
4352                    impl<
4353                        T: StreamManagerService,
4354                    > tonic::server::UnaryService<super::ListRateLimitsRequest>
4355                    for ListRateLimitsSvc<T> {
4356                        type Response = super::ListRateLimitsResponse;
4357                        type Future = BoxFuture<
4358                            tonic::Response<Self::Response>,
4359                            tonic::Status,
4360                        >;
4361                        fn call(
4362                            &mut self,
4363                            request: tonic::Request<super::ListRateLimitsRequest>,
4364                        ) -> Self::Future {
4365                            let inner = Arc::clone(&self.0);
4366                            let fut = async move {
4367                                <T as StreamManagerService>::list_rate_limits(
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 = ListRateLimitsSvc(inner);
4383                        let codec = tonic_prost::ProstCodec::default();
4384                        let mut grpc = tonic::server::Grpc::new(codec)
4385                            .apply_compression_config(
4386                                accept_compression_encodings,
4387                                send_compression_encodings,
4388                            )
4389                            .apply_max_message_size_config(
4390                                max_decoding_message_size,
4391                                max_encoding_message_size,
4392                            );
4393                        let res = grpc.unary(method, req).await;
4394                        Ok(res)
4395                    };
4396                    Box::pin(fut)
4397                }
4398                "/meta.StreamManagerService/AlterConnectorProps" => {
4399                    #[allow(non_camel_case_types)]
4400                    struct AlterConnectorPropsSvc<T: StreamManagerService>(pub Arc<T>);
4401                    impl<
4402                        T: StreamManagerService,
4403                    > tonic::server::UnaryService<super::AlterConnectorPropsRequest>
4404                    for AlterConnectorPropsSvc<T> {
4405                        type Response = super::AlterConnectorPropsResponse;
4406                        type Future = BoxFuture<
4407                            tonic::Response<Self::Response>,
4408                            tonic::Status,
4409                        >;
4410                        fn call(
4411                            &mut self,
4412                            request: tonic::Request<super::AlterConnectorPropsRequest>,
4413                        ) -> Self::Future {
4414                            let inner = Arc::clone(&self.0);
4415                            let fut = async move {
4416                                <T as StreamManagerService>::alter_connector_props(
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 = AlterConnectorPropsSvc(inner);
4432                        let codec = tonic_prost::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                "/meta.StreamManagerService/AlterSourcePropertiesSafe" => {
4448                    #[allow(non_camel_case_types)]
4449                    struct AlterSourcePropertiesSafeSvc<T: StreamManagerService>(
4450                        pub Arc<T>,
4451                    );
4452                    impl<
4453                        T: StreamManagerService,
4454                    > tonic::server::UnaryService<
4455                        super::AlterSourcePropertiesSafeRequest,
4456                    > for AlterSourcePropertiesSafeSvc<T> {
4457                        type Response = super::AlterSourcePropertiesSafeResponse;
4458                        type Future = BoxFuture<
4459                            tonic::Response<Self::Response>,
4460                            tonic::Status,
4461                        >;
4462                        fn call(
4463                            &mut self,
4464                            request: tonic::Request<
4465                                super::AlterSourcePropertiesSafeRequest,
4466                            >,
4467                        ) -> Self::Future {
4468                            let inner = Arc::clone(&self.0);
4469                            let fut = async move {
4470                                <T as StreamManagerService>::alter_source_properties_safe(
4471                                        &inner,
4472                                        request,
4473                                    )
4474                                    .await
4475                            };
4476                            Box::pin(fut)
4477                        }
4478                    }
4479                    let accept_compression_encodings = self.accept_compression_encodings;
4480                    let send_compression_encodings = self.send_compression_encodings;
4481                    let max_decoding_message_size = self.max_decoding_message_size;
4482                    let max_encoding_message_size = self.max_encoding_message_size;
4483                    let inner = self.inner.clone();
4484                    let fut = async move {
4485                        let method = AlterSourcePropertiesSafeSvc(inner);
4486                        let codec = tonic_prost::ProstCodec::default();
4487                        let mut grpc = tonic::server::Grpc::new(codec)
4488                            .apply_compression_config(
4489                                accept_compression_encodings,
4490                                send_compression_encodings,
4491                            )
4492                            .apply_max_message_size_config(
4493                                max_decoding_message_size,
4494                                max_encoding_message_size,
4495                            );
4496                        let res = grpc.unary(method, req).await;
4497                        Ok(res)
4498                    };
4499                    Box::pin(fut)
4500                }
4501                "/meta.StreamManagerService/ResetSourceSplits" => {
4502                    #[allow(non_camel_case_types)]
4503                    struct ResetSourceSplitsSvc<T: StreamManagerService>(pub Arc<T>);
4504                    impl<
4505                        T: StreamManagerService,
4506                    > tonic::server::UnaryService<super::ResetSourceSplitsRequest>
4507                    for ResetSourceSplitsSvc<T> {
4508                        type Response = super::ResetSourceSplitsResponse;
4509                        type Future = BoxFuture<
4510                            tonic::Response<Self::Response>,
4511                            tonic::Status,
4512                        >;
4513                        fn call(
4514                            &mut self,
4515                            request: tonic::Request<super::ResetSourceSplitsRequest>,
4516                        ) -> Self::Future {
4517                            let inner = Arc::clone(&self.0);
4518                            let fut = async move {
4519                                <T as StreamManagerService>::reset_source_splits(
4520                                        &inner,
4521                                        request,
4522                                    )
4523                                    .await
4524                            };
4525                            Box::pin(fut)
4526                        }
4527                    }
4528                    let accept_compression_encodings = self.accept_compression_encodings;
4529                    let send_compression_encodings = self.send_compression_encodings;
4530                    let max_decoding_message_size = self.max_decoding_message_size;
4531                    let max_encoding_message_size = self.max_encoding_message_size;
4532                    let inner = self.inner.clone();
4533                    let fut = async move {
4534                        let method = ResetSourceSplitsSvc(inner);
4535                        let codec = tonic_prost::ProstCodec::default();
4536                        let mut grpc = tonic::server::Grpc::new(codec)
4537                            .apply_compression_config(
4538                                accept_compression_encodings,
4539                                send_compression_encodings,
4540                            )
4541                            .apply_max_message_size_config(
4542                                max_decoding_message_size,
4543                                max_encoding_message_size,
4544                            );
4545                        let res = grpc.unary(method, req).await;
4546                        Ok(res)
4547                    };
4548                    Box::pin(fut)
4549                }
4550                "/meta.StreamManagerService/InjectSourceOffsets" => {
4551                    #[allow(non_camel_case_types)]
4552                    struct InjectSourceOffsetsSvc<T: StreamManagerService>(pub Arc<T>);
4553                    impl<
4554                        T: StreamManagerService,
4555                    > tonic::server::UnaryService<super::InjectSourceOffsetsRequest>
4556                    for InjectSourceOffsetsSvc<T> {
4557                        type Response = super::InjectSourceOffsetsResponse;
4558                        type Future = BoxFuture<
4559                            tonic::Response<Self::Response>,
4560                            tonic::Status,
4561                        >;
4562                        fn call(
4563                            &mut self,
4564                            request: tonic::Request<super::InjectSourceOffsetsRequest>,
4565                        ) -> Self::Future {
4566                            let inner = Arc::clone(&self.0);
4567                            let fut = async move {
4568                                <T as StreamManagerService>::inject_source_offsets(
4569                                        &inner,
4570                                        request,
4571                                    )
4572                                    .await
4573                            };
4574                            Box::pin(fut)
4575                        }
4576                    }
4577                    let accept_compression_encodings = self.accept_compression_encodings;
4578                    let send_compression_encodings = self.send_compression_encodings;
4579                    let max_decoding_message_size = self.max_decoding_message_size;
4580                    let max_encoding_message_size = self.max_encoding_message_size;
4581                    let inner = self.inner.clone();
4582                    let fut = async move {
4583                        let method = InjectSourceOffsetsSvc(inner);
4584                        let codec = tonic_prost::ProstCodec::default();
4585                        let mut grpc = tonic::server::Grpc::new(codec)
4586                            .apply_compression_config(
4587                                accept_compression_encodings,
4588                                send_compression_encodings,
4589                            )
4590                            .apply_max_message_size_config(
4591                                max_decoding_message_size,
4592                                max_encoding_message_size,
4593                            );
4594                        let res = grpc.unary(method, req).await;
4595                        Ok(res)
4596                    };
4597                    Box::pin(fut)
4598                }
4599                "/meta.StreamManagerService/GetFragmentById" => {
4600                    #[allow(non_camel_case_types)]
4601                    struct GetFragmentByIdSvc<T: StreamManagerService>(pub Arc<T>);
4602                    impl<
4603                        T: StreamManagerService,
4604                    > tonic::server::UnaryService<super::GetFragmentByIdRequest>
4605                    for GetFragmentByIdSvc<T> {
4606                        type Response = super::GetFragmentByIdResponse;
4607                        type Future = BoxFuture<
4608                            tonic::Response<Self::Response>,
4609                            tonic::Status,
4610                        >;
4611                        fn call(
4612                            &mut self,
4613                            request: tonic::Request<super::GetFragmentByIdRequest>,
4614                        ) -> Self::Future {
4615                            let inner = Arc::clone(&self.0);
4616                            let fut = async move {
4617                                <T as StreamManagerService>::get_fragment_by_id(
4618                                        &inner,
4619                                        request,
4620                                    )
4621                                    .await
4622                            };
4623                            Box::pin(fut)
4624                        }
4625                    }
4626                    let accept_compression_encodings = self.accept_compression_encodings;
4627                    let send_compression_encodings = self.send_compression_encodings;
4628                    let max_decoding_message_size = self.max_decoding_message_size;
4629                    let max_encoding_message_size = self.max_encoding_message_size;
4630                    let inner = self.inner.clone();
4631                    let fut = async move {
4632                        let method = GetFragmentByIdSvc(inner);
4633                        let codec = tonic_prost::ProstCodec::default();
4634                        let mut grpc = tonic::server::Grpc::new(codec)
4635                            .apply_compression_config(
4636                                accept_compression_encodings,
4637                                send_compression_encodings,
4638                            )
4639                            .apply_max_message_size_config(
4640                                max_decoding_message_size,
4641                                max_encoding_message_size,
4642                            );
4643                        let res = grpc.unary(method, req).await;
4644                        Ok(res)
4645                    };
4646                    Box::pin(fut)
4647                }
4648                "/meta.StreamManagerService/GetFragmentVnodes" => {
4649                    #[allow(non_camel_case_types)]
4650                    struct GetFragmentVnodesSvc<T: StreamManagerService>(pub Arc<T>);
4651                    impl<
4652                        T: StreamManagerService,
4653                    > tonic::server::UnaryService<super::GetFragmentVnodesRequest>
4654                    for GetFragmentVnodesSvc<T> {
4655                        type Response = super::GetFragmentVnodesResponse;
4656                        type Future = BoxFuture<
4657                            tonic::Response<Self::Response>,
4658                            tonic::Status,
4659                        >;
4660                        fn call(
4661                            &mut self,
4662                            request: tonic::Request<super::GetFragmentVnodesRequest>,
4663                        ) -> Self::Future {
4664                            let inner = Arc::clone(&self.0);
4665                            let fut = async move {
4666                                <T as StreamManagerService>::get_fragment_vnodes(
4667                                        &inner,
4668                                        request,
4669                                    )
4670                                    .await
4671                            };
4672                            Box::pin(fut)
4673                        }
4674                    }
4675                    let accept_compression_encodings = self.accept_compression_encodings;
4676                    let send_compression_encodings = self.send_compression_encodings;
4677                    let max_decoding_message_size = self.max_decoding_message_size;
4678                    let max_encoding_message_size = self.max_encoding_message_size;
4679                    let inner = self.inner.clone();
4680                    let fut = async move {
4681                        let method = GetFragmentVnodesSvc(inner);
4682                        let codec = tonic_prost::ProstCodec::default();
4683                        let mut grpc = tonic::server::Grpc::new(codec)
4684                            .apply_compression_config(
4685                                accept_compression_encodings,
4686                                send_compression_encodings,
4687                            )
4688                            .apply_max_message_size_config(
4689                                max_decoding_message_size,
4690                                max_encoding_message_size,
4691                            );
4692                        let res = grpc.unary(method, req).await;
4693                        Ok(res)
4694                    };
4695                    Box::pin(fut)
4696                }
4697                "/meta.StreamManagerService/GetActorVnodes" => {
4698                    #[allow(non_camel_case_types)]
4699                    struct GetActorVnodesSvc<T: StreamManagerService>(pub Arc<T>);
4700                    impl<
4701                        T: StreamManagerService,
4702                    > tonic::server::UnaryService<super::GetActorVnodesRequest>
4703                    for GetActorVnodesSvc<T> {
4704                        type Response = super::GetActorVnodesResponse;
4705                        type Future = BoxFuture<
4706                            tonic::Response<Self::Response>,
4707                            tonic::Status,
4708                        >;
4709                        fn call(
4710                            &mut self,
4711                            request: tonic::Request<super::GetActorVnodesRequest>,
4712                        ) -> Self::Future {
4713                            let inner = Arc::clone(&self.0);
4714                            let fut = async move {
4715                                <T as StreamManagerService>::get_actor_vnodes(
4716                                        &inner,
4717                                        request,
4718                                    )
4719                                    .await
4720                            };
4721                            Box::pin(fut)
4722                        }
4723                    }
4724                    let accept_compression_encodings = self.accept_compression_encodings;
4725                    let send_compression_encodings = self.send_compression_encodings;
4726                    let max_decoding_message_size = self.max_decoding_message_size;
4727                    let max_encoding_message_size = self.max_encoding_message_size;
4728                    let inner = self.inner.clone();
4729                    let fut = async move {
4730                        let method = GetActorVnodesSvc(inner);
4731                        let codec = tonic_prost::ProstCodec::default();
4732                        let mut grpc = tonic::server::Grpc::new(codec)
4733                            .apply_compression_config(
4734                                accept_compression_encodings,
4735                                send_compression_encodings,
4736                            )
4737                            .apply_max_message_size_config(
4738                                max_decoding_message_size,
4739                                max_encoding_message_size,
4740                            );
4741                        let res = grpc.unary(method, req).await;
4742                        Ok(res)
4743                    };
4744                    Box::pin(fut)
4745                }
4746                "/meta.StreamManagerService/SetSyncLogStoreAligned" => {
4747                    #[allow(non_camel_case_types)]
4748                    struct SetSyncLogStoreAlignedSvc<T: StreamManagerService>(
4749                        pub Arc<T>,
4750                    );
4751                    impl<
4752                        T: StreamManagerService,
4753                    > tonic::server::UnaryService<super::SetSyncLogStoreAlignedRequest>
4754                    for SetSyncLogStoreAlignedSvc<T> {
4755                        type Response = super::SetSyncLogStoreAlignedResponse;
4756                        type Future = BoxFuture<
4757                            tonic::Response<Self::Response>,
4758                            tonic::Status,
4759                        >;
4760                        fn call(
4761                            &mut self,
4762                            request: tonic::Request<super::SetSyncLogStoreAlignedRequest>,
4763                        ) -> Self::Future {
4764                            let inner = Arc::clone(&self.0);
4765                            let fut = async move {
4766                                <T as StreamManagerService>::set_sync_log_store_aligned(
4767                                        &inner,
4768                                        request,
4769                                    )
4770                                    .await
4771                            };
4772                            Box::pin(fut)
4773                        }
4774                    }
4775                    let accept_compression_encodings = self.accept_compression_encodings;
4776                    let send_compression_encodings = self.send_compression_encodings;
4777                    let max_decoding_message_size = self.max_decoding_message_size;
4778                    let max_encoding_message_size = self.max_encoding_message_size;
4779                    let inner = self.inner.clone();
4780                    let fut = async move {
4781                        let method = SetSyncLogStoreAlignedSvc(inner);
4782                        let codec = tonic_prost::ProstCodec::default();
4783                        let mut grpc = tonic::server::Grpc::new(codec)
4784                            .apply_compression_config(
4785                                accept_compression_encodings,
4786                                send_compression_encodings,
4787                            )
4788                            .apply_max_message_size_config(
4789                                max_decoding_message_size,
4790                                max_encoding_message_size,
4791                            );
4792                        let res = grpc.unary(method, req).await;
4793                        Ok(res)
4794                    };
4795                    Box::pin(fut)
4796                }
4797                "/meta.StreamManagerService/ListCdcProgress" => {
4798                    #[allow(non_camel_case_types)]
4799                    struct ListCdcProgressSvc<T: StreamManagerService>(pub Arc<T>);
4800                    impl<
4801                        T: StreamManagerService,
4802                    > tonic::server::UnaryService<super::ListCdcProgressRequest>
4803                    for ListCdcProgressSvc<T> {
4804                        type Response = super::ListCdcProgressResponse;
4805                        type Future = BoxFuture<
4806                            tonic::Response<Self::Response>,
4807                            tonic::Status,
4808                        >;
4809                        fn call(
4810                            &mut self,
4811                            request: tonic::Request<super::ListCdcProgressRequest>,
4812                        ) -> Self::Future {
4813                            let inner = Arc::clone(&self.0);
4814                            let fut = async move {
4815                                <T as StreamManagerService>::list_cdc_progress(
4816                                        &inner,
4817                                        request,
4818                                    )
4819                                    .await
4820                            };
4821                            Box::pin(fut)
4822                        }
4823                    }
4824                    let accept_compression_encodings = self.accept_compression_encodings;
4825                    let send_compression_encodings = self.send_compression_encodings;
4826                    let max_decoding_message_size = self.max_decoding_message_size;
4827                    let max_encoding_message_size = self.max_encoding_message_size;
4828                    let inner = self.inner.clone();
4829                    let fut = async move {
4830                        let method = ListCdcProgressSvc(inner);
4831                        let codec = tonic_prost::ProstCodec::default();
4832                        let mut grpc = tonic::server::Grpc::new(codec)
4833                            .apply_compression_config(
4834                                accept_compression_encodings,
4835                                send_compression_encodings,
4836                            )
4837                            .apply_max_message_size_config(
4838                                max_decoding_message_size,
4839                                max_encoding_message_size,
4840                            );
4841                        let res = grpc.unary(method, req).await;
4842                        Ok(res)
4843                    };
4844                    Box::pin(fut)
4845                }
4846                "/meta.StreamManagerService/ListUnmigratedTables" => {
4847                    #[allow(non_camel_case_types)]
4848                    struct ListUnmigratedTablesSvc<T: StreamManagerService>(pub Arc<T>);
4849                    impl<
4850                        T: StreamManagerService,
4851                    > tonic::server::UnaryService<super::ListUnmigratedTablesRequest>
4852                    for ListUnmigratedTablesSvc<T> {
4853                        type Response = super::ListUnmigratedTablesResponse;
4854                        type Future = BoxFuture<
4855                            tonic::Response<Self::Response>,
4856                            tonic::Status,
4857                        >;
4858                        fn call(
4859                            &mut self,
4860                            request: tonic::Request<super::ListUnmigratedTablesRequest>,
4861                        ) -> Self::Future {
4862                            let inner = Arc::clone(&self.0);
4863                            let fut = async move {
4864                                <T as StreamManagerService>::list_unmigrated_tables(
4865                                        &inner,
4866                                        request,
4867                                    )
4868                                    .await
4869                            };
4870                            Box::pin(fut)
4871                        }
4872                    }
4873                    let accept_compression_encodings = self.accept_compression_encodings;
4874                    let send_compression_encodings = self.send_compression_encodings;
4875                    let max_decoding_message_size = self.max_decoding_message_size;
4876                    let max_encoding_message_size = self.max_encoding_message_size;
4877                    let inner = self.inner.clone();
4878                    let fut = async move {
4879                        let method = ListUnmigratedTablesSvc(inner);
4880                        let codec = tonic_prost::ProstCodec::default();
4881                        let mut grpc = tonic::server::Grpc::new(codec)
4882                            .apply_compression_config(
4883                                accept_compression_encodings,
4884                                send_compression_encodings,
4885                            )
4886                            .apply_max_message_size_config(
4887                                max_decoding_message_size,
4888                                max_encoding_message_size,
4889                            );
4890                        let res = grpc.unary(method, req).await;
4891                        Ok(res)
4892                    };
4893                    Box::pin(fut)
4894                }
4895                "/meta.StreamManagerService/ListRefreshTableStates" => {
4896                    #[allow(non_camel_case_types)]
4897                    struct ListRefreshTableStatesSvc<T: StreamManagerService>(
4898                        pub Arc<T>,
4899                    );
4900                    impl<
4901                        T: StreamManagerService,
4902                    > tonic::server::UnaryService<super::ListRefreshTableStatesRequest>
4903                    for ListRefreshTableStatesSvc<T> {
4904                        type Response = super::ListRefreshTableStatesResponse;
4905                        type Future = BoxFuture<
4906                            tonic::Response<Self::Response>,
4907                            tonic::Status,
4908                        >;
4909                        fn call(
4910                            &mut self,
4911                            request: tonic::Request<super::ListRefreshTableStatesRequest>,
4912                        ) -> Self::Future {
4913                            let inner = Arc::clone(&self.0);
4914                            let fut = async move {
4915                                <T as StreamManagerService>::list_refresh_table_states(
4916                                        &inner,
4917                                        request,
4918                                    )
4919                                    .await
4920                            };
4921                            Box::pin(fut)
4922                        }
4923                    }
4924                    let accept_compression_encodings = self.accept_compression_encodings;
4925                    let send_compression_encodings = self.send_compression_encodings;
4926                    let max_decoding_message_size = self.max_decoding_message_size;
4927                    let max_encoding_message_size = self.max_encoding_message_size;
4928                    let inner = self.inner.clone();
4929                    let fut = async move {
4930                        let method = ListRefreshTableStatesSvc(inner);
4931                        let codec = tonic_prost::ProstCodec::default();
4932                        let mut grpc = tonic::server::Grpc::new(codec)
4933                            .apply_compression_config(
4934                                accept_compression_encodings,
4935                                send_compression_encodings,
4936                            )
4937                            .apply_max_message_size_config(
4938                                max_decoding_message_size,
4939                                max_encoding_message_size,
4940                            );
4941                        let res = grpc.unary(method, req).await;
4942                        Ok(res)
4943                    };
4944                    Box::pin(fut)
4945                }
4946                "/meta.StreamManagerService/ListIcebergCompactionStatus" => {
4947                    #[allow(non_camel_case_types)]
4948                    struct ListIcebergCompactionStatusSvc<T: StreamManagerService>(
4949                        pub Arc<T>,
4950                    );
4951                    impl<
4952                        T: StreamManagerService,
4953                    > tonic::server::UnaryService<
4954                        super::ListIcebergCompactionStatusRequest,
4955                    > for ListIcebergCompactionStatusSvc<T> {
4956                        type Response = super::ListIcebergCompactionStatusResponse;
4957                        type Future = BoxFuture<
4958                            tonic::Response<Self::Response>,
4959                            tonic::Status,
4960                        >;
4961                        fn call(
4962                            &mut self,
4963                            request: tonic::Request<
4964                                super::ListIcebergCompactionStatusRequest,
4965                            >,
4966                        ) -> Self::Future {
4967                            let inner = Arc::clone(&self.0);
4968                            let fut = async move {
4969                                <T as StreamManagerService>::list_iceberg_compaction_status(
4970                                        &inner,
4971                                        request,
4972                                    )
4973                                    .await
4974                            };
4975                            Box::pin(fut)
4976                        }
4977                    }
4978                    let accept_compression_encodings = self.accept_compression_encodings;
4979                    let send_compression_encodings = self.send_compression_encodings;
4980                    let max_decoding_message_size = self.max_decoding_message_size;
4981                    let max_encoding_message_size = self.max_encoding_message_size;
4982                    let inner = self.inner.clone();
4983                    let fut = async move {
4984                        let method = ListIcebergCompactionStatusSvc(inner);
4985                        let codec = tonic_prost::ProstCodec::default();
4986                        let mut grpc = tonic::server::Grpc::new(codec)
4987                            .apply_compression_config(
4988                                accept_compression_encodings,
4989                                send_compression_encodings,
4990                            )
4991                            .apply_max_message_size_config(
4992                                max_decoding_message_size,
4993                                max_encoding_message_size,
4994                            );
4995                        let res = grpc.unary(method, req).await;
4996                        Ok(res)
4997                    };
4998                    Box::pin(fut)
4999                }
5000                _ => {
5001                    Box::pin(async move {
5002                        let mut response = http::Response::new(
5003                            tonic::body::Body::default(),
5004                        );
5005                        let headers = response.headers_mut();
5006                        headers
5007                            .insert(
5008                                tonic::Status::GRPC_STATUS,
5009                                (tonic::Code::Unimplemented as i32).into(),
5010                            );
5011                        headers
5012                            .insert(
5013                                http::header::CONTENT_TYPE,
5014                                tonic::metadata::GRPC_CONTENT_TYPE,
5015                            );
5016                        Ok(response)
5017                    })
5018                }
5019            }
5020        }
5021    }
5022    impl<T> Clone for StreamManagerServiceServer<T> {
5023        fn clone(&self) -> Self {
5024            let inner = self.inner.clone();
5025            Self {
5026                inner,
5027                accept_compression_encodings: self.accept_compression_encodings,
5028                send_compression_encodings: self.send_compression_encodings,
5029                max_decoding_message_size: self.max_decoding_message_size,
5030                max_encoding_message_size: self.max_encoding_message_size,
5031            }
5032        }
5033    }
5034    /// Generated gRPC service name
5035    pub const SERVICE_NAME: &str = "meta.StreamManagerService";
5036    impl<T> tonic::server::NamedService for StreamManagerServiceServer<T> {
5037        const NAME: &'static str = SERVICE_NAME;
5038    }
5039}
5040/// Generated client implementations.
5041pub mod cluster_service_client {
5042    #![allow(
5043        unused_variables,
5044        dead_code,
5045        missing_docs,
5046        clippy::wildcard_imports,
5047        clippy::let_unit_value,
5048    )]
5049    use tonic::codegen::*;
5050    use tonic::codegen::http::Uri;
5051    #[derive(Debug, Clone)]
5052    pub struct ClusterServiceClient<T> {
5053        inner: tonic::client::Grpc<T>,
5054    }
5055    impl ClusterServiceClient<tonic::transport::Channel> {
5056        /// Attempt to create a new client by connecting to a given endpoint.
5057        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
5058        where
5059            D: TryInto<tonic::transport::Endpoint>,
5060            D::Error: Into<StdError>,
5061        {
5062            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
5063            Ok(Self::new(conn))
5064        }
5065    }
5066    impl<T> ClusterServiceClient<T>
5067    where
5068        T: tonic::client::GrpcService<tonic::body::Body>,
5069        T::Error: Into<StdError>,
5070        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
5071        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
5072    {
5073        pub fn new(inner: T) -> Self {
5074            let inner = tonic::client::Grpc::new(inner);
5075            Self { inner }
5076        }
5077        pub fn with_origin(inner: T, origin: Uri) -> Self {
5078            let inner = tonic::client::Grpc::with_origin(inner, origin);
5079            Self { inner }
5080        }
5081        pub fn with_interceptor<F>(
5082            inner: T,
5083            interceptor: F,
5084        ) -> ClusterServiceClient<InterceptedService<T, F>>
5085        where
5086            F: tonic::service::Interceptor,
5087            T::ResponseBody: Default,
5088            T: tonic::codegen::Service<
5089                http::Request<tonic::body::Body>,
5090                Response = http::Response<
5091                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
5092                >,
5093            >,
5094            <T as tonic::codegen::Service<
5095                http::Request<tonic::body::Body>,
5096            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
5097        {
5098            ClusterServiceClient::new(InterceptedService::new(inner, interceptor))
5099        }
5100        /// Compress requests with the given encoding.
5101        ///
5102        /// This requires the server to support it otherwise it might respond with an
5103        /// error.
5104        #[must_use]
5105        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
5106            self.inner = self.inner.send_compressed(encoding);
5107            self
5108        }
5109        /// Enable decompressing responses.
5110        #[must_use]
5111        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
5112            self.inner = self.inner.accept_compressed(encoding);
5113            self
5114        }
5115        /// Limits the maximum size of a decoded message.
5116        ///
5117        /// Default: `4MB`
5118        #[must_use]
5119        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
5120            self.inner = self.inner.max_decoding_message_size(limit);
5121            self
5122        }
5123        /// Limits the maximum size of an encoded message.
5124        ///
5125        /// Default: `usize::MAX`
5126        #[must_use]
5127        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
5128            self.inner = self.inner.max_encoding_message_size(limit);
5129            self
5130        }
5131        pub async fn add_worker_node(
5132            &mut self,
5133            request: impl tonic::IntoRequest<super::AddWorkerNodeRequest>,
5134        ) -> std::result::Result<
5135            tonic::Response<super::AddWorkerNodeResponse>,
5136            tonic::Status,
5137        > {
5138            self.inner
5139                .ready()
5140                .await
5141                .map_err(|e| {
5142                    tonic::Status::unknown(
5143                        format!("Service was not ready: {}", e.into()),
5144                    )
5145                })?;
5146            let codec = tonic_prost::ProstCodec::default();
5147            let path = http::uri::PathAndQuery::from_static(
5148                "/meta.ClusterService/AddWorkerNode",
5149            );
5150            let mut req = request.into_request();
5151            req.extensions_mut()
5152                .insert(GrpcMethod::new("meta.ClusterService", "AddWorkerNode"));
5153            self.inner.unary(req, path, codec).await
5154        }
5155        pub async fn activate_worker_node(
5156            &mut self,
5157            request: impl tonic::IntoRequest<super::ActivateWorkerNodeRequest>,
5158        ) -> std::result::Result<
5159            tonic::Response<super::ActivateWorkerNodeResponse>,
5160            tonic::Status,
5161        > {
5162            self.inner
5163                .ready()
5164                .await
5165                .map_err(|e| {
5166                    tonic::Status::unknown(
5167                        format!("Service was not ready: {}", e.into()),
5168                    )
5169                })?;
5170            let codec = tonic_prost::ProstCodec::default();
5171            let path = http::uri::PathAndQuery::from_static(
5172                "/meta.ClusterService/ActivateWorkerNode",
5173            );
5174            let mut req = request.into_request();
5175            req.extensions_mut()
5176                .insert(GrpcMethod::new("meta.ClusterService", "ActivateWorkerNode"));
5177            self.inner.unary(req, path, codec).await
5178        }
5179        pub async fn delete_worker_node(
5180            &mut self,
5181            request: impl tonic::IntoRequest<super::DeleteWorkerNodeRequest>,
5182        ) -> std::result::Result<
5183            tonic::Response<super::DeleteWorkerNodeResponse>,
5184            tonic::Status,
5185        > {
5186            self.inner
5187                .ready()
5188                .await
5189                .map_err(|e| {
5190                    tonic::Status::unknown(
5191                        format!("Service was not ready: {}", e.into()),
5192                    )
5193                })?;
5194            let codec = tonic_prost::ProstCodec::default();
5195            let path = http::uri::PathAndQuery::from_static(
5196                "/meta.ClusterService/DeleteWorkerNode",
5197            );
5198            let mut req = request.into_request();
5199            req.extensions_mut()
5200                .insert(GrpcMethod::new("meta.ClusterService", "DeleteWorkerNode"));
5201            self.inner.unary(req, path, codec).await
5202        }
5203        pub async fn list_all_nodes(
5204            &mut self,
5205            request: impl tonic::IntoRequest<super::ListAllNodesRequest>,
5206        ) -> std::result::Result<
5207            tonic::Response<super::ListAllNodesResponse>,
5208            tonic::Status,
5209        > {
5210            self.inner
5211                .ready()
5212                .await
5213                .map_err(|e| {
5214                    tonic::Status::unknown(
5215                        format!("Service was not ready: {}", e.into()),
5216                    )
5217                })?;
5218            let codec = tonic_prost::ProstCodec::default();
5219            let path = http::uri::PathAndQuery::from_static(
5220                "/meta.ClusterService/ListAllNodes",
5221            );
5222            let mut req = request.into_request();
5223            req.extensions_mut()
5224                .insert(GrpcMethod::new("meta.ClusterService", "ListAllNodes"));
5225            self.inner.unary(req, path, codec).await
5226        }
5227        pub async fn get_cluster_recovery_status(
5228            &mut self,
5229            request: impl tonic::IntoRequest<super::GetClusterRecoveryStatusRequest>,
5230        ) -> std::result::Result<
5231            tonic::Response<super::GetClusterRecoveryStatusResponse>,
5232            tonic::Status,
5233        > {
5234            self.inner
5235                .ready()
5236                .await
5237                .map_err(|e| {
5238                    tonic::Status::unknown(
5239                        format!("Service was not ready: {}", e.into()),
5240                    )
5241                })?;
5242            let codec = tonic_prost::ProstCodec::default();
5243            let path = http::uri::PathAndQuery::from_static(
5244                "/meta.ClusterService/GetClusterRecoveryStatus",
5245            );
5246            let mut req = request.into_request();
5247            req.extensions_mut()
5248                .insert(
5249                    GrpcMethod::new("meta.ClusterService", "GetClusterRecoveryStatus"),
5250                );
5251            self.inner.unary(req, path, codec).await
5252        }
5253        pub async fn get_meta_store_info(
5254            &mut self,
5255            request: impl tonic::IntoRequest<super::GetMetaStoreInfoRequest>,
5256        ) -> std::result::Result<
5257            tonic::Response<super::GetMetaStoreInfoResponse>,
5258            tonic::Status,
5259        > {
5260            self.inner
5261                .ready()
5262                .await
5263                .map_err(|e| {
5264                    tonic::Status::unknown(
5265                        format!("Service was not ready: {}", e.into()),
5266                    )
5267                })?;
5268            let codec = tonic_prost::ProstCodec::default();
5269            let path = http::uri::PathAndQuery::from_static(
5270                "/meta.ClusterService/GetMetaStoreInfo",
5271            );
5272            let mut req = request.into_request();
5273            req.extensions_mut()
5274                .insert(GrpcMethod::new("meta.ClusterService", "GetMetaStoreInfo"));
5275            self.inner.unary(req, path, codec).await
5276        }
5277    }
5278}
5279/// Generated server implementations.
5280pub mod cluster_service_server {
5281    #![allow(
5282        unused_variables,
5283        dead_code,
5284        missing_docs,
5285        clippy::wildcard_imports,
5286        clippy::let_unit_value,
5287    )]
5288    use tonic::codegen::*;
5289    /// Generated trait containing gRPC methods that should be implemented for use with ClusterServiceServer.
5290    #[async_trait]
5291    pub trait ClusterService: std::marker::Send + std::marker::Sync + 'static {
5292        async fn add_worker_node(
5293            &self,
5294            request: tonic::Request<super::AddWorkerNodeRequest>,
5295        ) -> std::result::Result<
5296            tonic::Response<super::AddWorkerNodeResponse>,
5297            tonic::Status,
5298        >;
5299        async fn activate_worker_node(
5300            &self,
5301            request: tonic::Request<super::ActivateWorkerNodeRequest>,
5302        ) -> std::result::Result<
5303            tonic::Response<super::ActivateWorkerNodeResponse>,
5304            tonic::Status,
5305        >;
5306        async fn delete_worker_node(
5307            &self,
5308            request: tonic::Request<super::DeleteWorkerNodeRequest>,
5309        ) -> std::result::Result<
5310            tonic::Response<super::DeleteWorkerNodeResponse>,
5311            tonic::Status,
5312        >;
5313        async fn list_all_nodes(
5314            &self,
5315            request: tonic::Request<super::ListAllNodesRequest>,
5316        ) -> std::result::Result<
5317            tonic::Response<super::ListAllNodesResponse>,
5318            tonic::Status,
5319        >;
5320        async fn get_cluster_recovery_status(
5321            &self,
5322            request: tonic::Request<super::GetClusterRecoveryStatusRequest>,
5323        ) -> std::result::Result<
5324            tonic::Response<super::GetClusterRecoveryStatusResponse>,
5325            tonic::Status,
5326        >;
5327        async fn get_meta_store_info(
5328            &self,
5329            request: tonic::Request<super::GetMetaStoreInfoRequest>,
5330        ) -> std::result::Result<
5331            tonic::Response<super::GetMetaStoreInfoResponse>,
5332            tonic::Status,
5333        >;
5334    }
5335    #[derive(Debug)]
5336    pub struct ClusterServiceServer<T> {
5337        inner: Arc<T>,
5338        accept_compression_encodings: EnabledCompressionEncodings,
5339        send_compression_encodings: EnabledCompressionEncodings,
5340        max_decoding_message_size: Option<usize>,
5341        max_encoding_message_size: Option<usize>,
5342    }
5343    impl<T> ClusterServiceServer<T> {
5344        pub fn new(inner: T) -> Self {
5345            Self::from_arc(Arc::new(inner))
5346        }
5347        pub fn from_arc(inner: Arc<T>) -> Self {
5348            Self {
5349                inner,
5350                accept_compression_encodings: Default::default(),
5351                send_compression_encodings: Default::default(),
5352                max_decoding_message_size: None,
5353                max_encoding_message_size: None,
5354            }
5355        }
5356        pub fn with_interceptor<F>(
5357            inner: T,
5358            interceptor: F,
5359        ) -> InterceptedService<Self, F>
5360        where
5361            F: tonic::service::Interceptor,
5362        {
5363            InterceptedService::new(Self::new(inner), interceptor)
5364        }
5365        /// Enable decompressing requests with the given encoding.
5366        #[must_use]
5367        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
5368            self.accept_compression_encodings.enable(encoding);
5369            self
5370        }
5371        /// Compress responses with the given encoding, if the client supports it.
5372        #[must_use]
5373        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
5374            self.send_compression_encodings.enable(encoding);
5375            self
5376        }
5377        /// Limits the maximum size of a decoded message.
5378        ///
5379        /// Default: `4MB`
5380        #[must_use]
5381        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
5382            self.max_decoding_message_size = Some(limit);
5383            self
5384        }
5385        /// Limits the maximum size of an encoded message.
5386        ///
5387        /// Default: `usize::MAX`
5388        #[must_use]
5389        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
5390            self.max_encoding_message_size = Some(limit);
5391            self
5392        }
5393    }
5394    impl<T, B> tonic::codegen::Service<http::Request<B>> for ClusterServiceServer<T>
5395    where
5396        T: ClusterService,
5397        B: Body + std::marker::Send + 'static,
5398        B::Error: Into<StdError> + std::marker::Send + 'static,
5399    {
5400        type Response = http::Response<tonic::body::Body>;
5401        type Error = std::convert::Infallible;
5402        type Future = BoxFuture<Self::Response, Self::Error>;
5403        fn poll_ready(
5404            &mut self,
5405            _cx: &mut Context<'_>,
5406        ) -> Poll<std::result::Result<(), Self::Error>> {
5407            Poll::Ready(Ok(()))
5408        }
5409        fn call(&mut self, req: http::Request<B>) -> Self::Future {
5410            match req.uri().path() {
5411                "/meta.ClusterService/AddWorkerNode" => {
5412                    #[allow(non_camel_case_types)]
5413                    struct AddWorkerNodeSvc<T: ClusterService>(pub Arc<T>);
5414                    impl<
5415                        T: ClusterService,
5416                    > tonic::server::UnaryService<super::AddWorkerNodeRequest>
5417                    for AddWorkerNodeSvc<T> {
5418                        type Response = super::AddWorkerNodeResponse;
5419                        type Future = BoxFuture<
5420                            tonic::Response<Self::Response>,
5421                            tonic::Status,
5422                        >;
5423                        fn call(
5424                            &mut self,
5425                            request: tonic::Request<super::AddWorkerNodeRequest>,
5426                        ) -> Self::Future {
5427                            let inner = Arc::clone(&self.0);
5428                            let fut = async move {
5429                                <T as ClusterService>::add_worker_node(&inner, request)
5430                                    .await
5431                            };
5432                            Box::pin(fut)
5433                        }
5434                    }
5435                    let accept_compression_encodings = self.accept_compression_encodings;
5436                    let send_compression_encodings = self.send_compression_encodings;
5437                    let max_decoding_message_size = self.max_decoding_message_size;
5438                    let max_encoding_message_size = self.max_encoding_message_size;
5439                    let inner = self.inner.clone();
5440                    let fut = async move {
5441                        let method = AddWorkerNodeSvc(inner);
5442                        let codec = tonic_prost::ProstCodec::default();
5443                        let mut grpc = tonic::server::Grpc::new(codec)
5444                            .apply_compression_config(
5445                                accept_compression_encodings,
5446                                send_compression_encodings,
5447                            )
5448                            .apply_max_message_size_config(
5449                                max_decoding_message_size,
5450                                max_encoding_message_size,
5451                            );
5452                        let res = grpc.unary(method, req).await;
5453                        Ok(res)
5454                    };
5455                    Box::pin(fut)
5456                }
5457                "/meta.ClusterService/ActivateWorkerNode" => {
5458                    #[allow(non_camel_case_types)]
5459                    struct ActivateWorkerNodeSvc<T: ClusterService>(pub Arc<T>);
5460                    impl<
5461                        T: ClusterService,
5462                    > tonic::server::UnaryService<super::ActivateWorkerNodeRequest>
5463                    for ActivateWorkerNodeSvc<T> {
5464                        type Response = super::ActivateWorkerNodeResponse;
5465                        type Future = BoxFuture<
5466                            tonic::Response<Self::Response>,
5467                            tonic::Status,
5468                        >;
5469                        fn call(
5470                            &mut self,
5471                            request: tonic::Request<super::ActivateWorkerNodeRequest>,
5472                        ) -> Self::Future {
5473                            let inner = Arc::clone(&self.0);
5474                            let fut = async move {
5475                                <T as ClusterService>::activate_worker_node(&inner, request)
5476                                    .await
5477                            };
5478                            Box::pin(fut)
5479                        }
5480                    }
5481                    let accept_compression_encodings = self.accept_compression_encodings;
5482                    let send_compression_encodings = self.send_compression_encodings;
5483                    let max_decoding_message_size = self.max_decoding_message_size;
5484                    let max_encoding_message_size = self.max_encoding_message_size;
5485                    let inner = self.inner.clone();
5486                    let fut = async move {
5487                        let method = ActivateWorkerNodeSvc(inner);
5488                        let codec = tonic_prost::ProstCodec::default();
5489                        let mut grpc = tonic::server::Grpc::new(codec)
5490                            .apply_compression_config(
5491                                accept_compression_encodings,
5492                                send_compression_encodings,
5493                            )
5494                            .apply_max_message_size_config(
5495                                max_decoding_message_size,
5496                                max_encoding_message_size,
5497                            );
5498                        let res = grpc.unary(method, req).await;
5499                        Ok(res)
5500                    };
5501                    Box::pin(fut)
5502                }
5503                "/meta.ClusterService/DeleteWorkerNode" => {
5504                    #[allow(non_camel_case_types)]
5505                    struct DeleteWorkerNodeSvc<T: ClusterService>(pub Arc<T>);
5506                    impl<
5507                        T: ClusterService,
5508                    > tonic::server::UnaryService<super::DeleteWorkerNodeRequest>
5509                    for DeleteWorkerNodeSvc<T> {
5510                        type Response = super::DeleteWorkerNodeResponse;
5511                        type Future = BoxFuture<
5512                            tonic::Response<Self::Response>,
5513                            tonic::Status,
5514                        >;
5515                        fn call(
5516                            &mut self,
5517                            request: tonic::Request<super::DeleteWorkerNodeRequest>,
5518                        ) -> Self::Future {
5519                            let inner = Arc::clone(&self.0);
5520                            let fut = async move {
5521                                <T as ClusterService>::delete_worker_node(&inner, request)
5522                                    .await
5523                            };
5524                            Box::pin(fut)
5525                        }
5526                    }
5527                    let accept_compression_encodings = self.accept_compression_encodings;
5528                    let send_compression_encodings = self.send_compression_encodings;
5529                    let max_decoding_message_size = self.max_decoding_message_size;
5530                    let max_encoding_message_size = self.max_encoding_message_size;
5531                    let inner = self.inner.clone();
5532                    let fut = async move {
5533                        let method = DeleteWorkerNodeSvc(inner);
5534                        let codec = tonic_prost::ProstCodec::default();
5535                        let mut grpc = tonic::server::Grpc::new(codec)
5536                            .apply_compression_config(
5537                                accept_compression_encodings,
5538                                send_compression_encodings,
5539                            )
5540                            .apply_max_message_size_config(
5541                                max_decoding_message_size,
5542                                max_encoding_message_size,
5543                            );
5544                        let res = grpc.unary(method, req).await;
5545                        Ok(res)
5546                    };
5547                    Box::pin(fut)
5548                }
5549                "/meta.ClusterService/ListAllNodes" => {
5550                    #[allow(non_camel_case_types)]
5551                    struct ListAllNodesSvc<T: ClusterService>(pub Arc<T>);
5552                    impl<
5553                        T: ClusterService,
5554                    > tonic::server::UnaryService<super::ListAllNodesRequest>
5555                    for ListAllNodesSvc<T> {
5556                        type Response = super::ListAllNodesResponse;
5557                        type Future = BoxFuture<
5558                            tonic::Response<Self::Response>,
5559                            tonic::Status,
5560                        >;
5561                        fn call(
5562                            &mut self,
5563                            request: tonic::Request<super::ListAllNodesRequest>,
5564                        ) -> Self::Future {
5565                            let inner = Arc::clone(&self.0);
5566                            let fut = async move {
5567                                <T as ClusterService>::list_all_nodes(&inner, request).await
5568                            };
5569                            Box::pin(fut)
5570                        }
5571                    }
5572                    let accept_compression_encodings = self.accept_compression_encodings;
5573                    let send_compression_encodings = self.send_compression_encodings;
5574                    let max_decoding_message_size = self.max_decoding_message_size;
5575                    let max_encoding_message_size = self.max_encoding_message_size;
5576                    let inner = self.inner.clone();
5577                    let fut = async move {
5578                        let method = ListAllNodesSvc(inner);
5579                        let codec = tonic_prost::ProstCodec::default();
5580                        let mut grpc = tonic::server::Grpc::new(codec)
5581                            .apply_compression_config(
5582                                accept_compression_encodings,
5583                                send_compression_encodings,
5584                            )
5585                            .apply_max_message_size_config(
5586                                max_decoding_message_size,
5587                                max_encoding_message_size,
5588                            );
5589                        let res = grpc.unary(method, req).await;
5590                        Ok(res)
5591                    };
5592                    Box::pin(fut)
5593                }
5594                "/meta.ClusterService/GetClusterRecoveryStatus" => {
5595                    #[allow(non_camel_case_types)]
5596                    struct GetClusterRecoveryStatusSvc<T: ClusterService>(pub Arc<T>);
5597                    impl<
5598                        T: ClusterService,
5599                    > tonic::server::UnaryService<super::GetClusterRecoveryStatusRequest>
5600                    for GetClusterRecoveryStatusSvc<T> {
5601                        type Response = super::GetClusterRecoveryStatusResponse;
5602                        type Future = BoxFuture<
5603                            tonic::Response<Self::Response>,
5604                            tonic::Status,
5605                        >;
5606                        fn call(
5607                            &mut self,
5608                            request: tonic::Request<
5609                                super::GetClusterRecoveryStatusRequest,
5610                            >,
5611                        ) -> Self::Future {
5612                            let inner = Arc::clone(&self.0);
5613                            let fut = async move {
5614                                <T as ClusterService>::get_cluster_recovery_status(
5615                                        &inner,
5616                                        request,
5617                                    )
5618                                    .await
5619                            };
5620                            Box::pin(fut)
5621                        }
5622                    }
5623                    let accept_compression_encodings = self.accept_compression_encodings;
5624                    let send_compression_encodings = self.send_compression_encodings;
5625                    let max_decoding_message_size = self.max_decoding_message_size;
5626                    let max_encoding_message_size = self.max_encoding_message_size;
5627                    let inner = self.inner.clone();
5628                    let fut = async move {
5629                        let method = GetClusterRecoveryStatusSvc(inner);
5630                        let codec = tonic_prost::ProstCodec::default();
5631                        let mut grpc = tonic::server::Grpc::new(codec)
5632                            .apply_compression_config(
5633                                accept_compression_encodings,
5634                                send_compression_encodings,
5635                            )
5636                            .apply_max_message_size_config(
5637                                max_decoding_message_size,
5638                                max_encoding_message_size,
5639                            );
5640                        let res = grpc.unary(method, req).await;
5641                        Ok(res)
5642                    };
5643                    Box::pin(fut)
5644                }
5645                "/meta.ClusterService/GetMetaStoreInfo" => {
5646                    #[allow(non_camel_case_types)]
5647                    struct GetMetaStoreInfoSvc<T: ClusterService>(pub Arc<T>);
5648                    impl<
5649                        T: ClusterService,
5650                    > tonic::server::UnaryService<super::GetMetaStoreInfoRequest>
5651                    for GetMetaStoreInfoSvc<T> {
5652                        type Response = super::GetMetaStoreInfoResponse;
5653                        type Future = BoxFuture<
5654                            tonic::Response<Self::Response>,
5655                            tonic::Status,
5656                        >;
5657                        fn call(
5658                            &mut self,
5659                            request: tonic::Request<super::GetMetaStoreInfoRequest>,
5660                        ) -> Self::Future {
5661                            let inner = Arc::clone(&self.0);
5662                            let fut = async move {
5663                                <T as ClusterService>::get_meta_store_info(&inner, request)
5664                                    .await
5665                            };
5666                            Box::pin(fut)
5667                        }
5668                    }
5669                    let accept_compression_encodings = self.accept_compression_encodings;
5670                    let send_compression_encodings = self.send_compression_encodings;
5671                    let max_decoding_message_size = self.max_decoding_message_size;
5672                    let max_encoding_message_size = self.max_encoding_message_size;
5673                    let inner = self.inner.clone();
5674                    let fut = async move {
5675                        let method = GetMetaStoreInfoSvc(inner);
5676                        let codec = tonic_prost::ProstCodec::default();
5677                        let mut grpc = tonic::server::Grpc::new(codec)
5678                            .apply_compression_config(
5679                                accept_compression_encodings,
5680                                send_compression_encodings,
5681                            )
5682                            .apply_max_message_size_config(
5683                                max_decoding_message_size,
5684                                max_encoding_message_size,
5685                            );
5686                        let res = grpc.unary(method, req).await;
5687                        Ok(res)
5688                    };
5689                    Box::pin(fut)
5690                }
5691                _ => {
5692                    Box::pin(async move {
5693                        let mut response = http::Response::new(
5694                            tonic::body::Body::default(),
5695                        );
5696                        let headers = response.headers_mut();
5697                        headers
5698                            .insert(
5699                                tonic::Status::GRPC_STATUS,
5700                                (tonic::Code::Unimplemented as i32).into(),
5701                            );
5702                        headers
5703                            .insert(
5704                                http::header::CONTENT_TYPE,
5705                                tonic::metadata::GRPC_CONTENT_TYPE,
5706                            );
5707                        Ok(response)
5708                    })
5709                }
5710            }
5711        }
5712    }
5713    impl<T> Clone for ClusterServiceServer<T> {
5714        fn clone(&self) -> Self {
5715            let inner = self.inner.clone();
5716            Self {
5717                inner,
5718                accept_compression_encodings: self.accept_compression_encodings,
5719                send_compression_encodings: self.send_compression_encodings,
5720                max_decoding_message_size: self.max_decoding_message_size,
5721                max_encoding_message_size: self.max_encoding_message_size,
5722            }
5723        }
5724    }
5725    /// Generated gRPC service name
5726    pub const SERVICE_NAME: &str = "meta.ClusterService";
5727    impl<T> tonic::server::NamedService for ClusterServiceServer<T> {
5728        const NAME: &'static str = SERVICE_NAME;
5729    }
5730}
5731/// Generated client implementations.
5732pub mod notification_service_client {
5733    #![allow(
5734        unused_variables,
5735        dead_code,
5736        missing_docs,
5737        clippy::wildcard_imports,
5738        clippy::let_unit_value,
5739    )]
5740    use tonic::codegen::*;
5741    use tonic::codegen::http::Uri;
5742    #[derive(Debug, Clone)]
5743    pub struct NotificationServiceClient<T> {
5744        inner: tonic::client::Grpc<T>,
5745    }
5746    impl NotificationServiceClient<tonic::transport::Channel> {
5747        /// Attempt to create a new client by connecting to a given endpoint.
5748        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
5749        where
5750            D: TryInto<tonic::transport::Endpoint>,
5751            D::Error: Into<StdError>,
5752        {
5753            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
5754            Ok(Self::new(conn))
5755        }
5756    }
5757    impl<T> NotificationServiceClient<T>
5758    where
5759        T: tonic::client::GrpcService<tonic::body::Body>,
5760        T::Error: Into<StdError>,
5761        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
5762        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
5763    {
5764        pub fn new(inner: T) -> Self {
5765            let inner = tonic::client::Grpc::new(inner);
5766            Self { inner }
5767        }
5768        pub fn with_origin(inner: T, origin: Uri) -> Self {
5769            let inner = tonic::client::Grpc::with_origin(inner, origin);
5770            Self { inner }
5771        }
5772        pub fn with_interceptor<F>(
5773            inner: T,
5774            interceptor: F,
5775        ) -> NotificationServiceClient<InterceptedService<T, F>>
5776        where
5777            F: tonic::service::Interceptor,
5778            T::ResponseBody: Default,
5779            T: tonic::codegen::Service<
5780                http::Request<tonic::body::Body>,
5781                Response = http::Response<
5782                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
5783                >,
5784            >,
5785            <T as tonic::codegen::Service<
5786                http::Request<tonic::body::Body>,
5787            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
5788        {
5789            NotificationServiceClient::new(InterceptedService::new(inner, interceptor))
5790        }
5791        /// Compress requests with the given encoding.
5792        ///
5793        /// This requires the server to support it otherwise it might respond with an
5794        /// error.
5795        #[must_use]
5796        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
5797            self.inner = self.inner.send_compressed(encoding);
5798            self
5799        }
5800        /// Enable decompressing responses.
5801        #[must_use]
5802        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
5803            self.inner = self.inner.accept_compressed(encoding);
5804            self
5805        }
5806        /// Limits the maximum size of a decoded message.
5807        ///
5808        /// Default: `4MB`
5809        #[must_use]
5810        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
5811            self.inner = self.inner.max_decoding_message_size(limit);
5812            self
5813        }
5814        /// Limits the maximum size of an encoded message.
5815        ///
5816        /// Default: `usize::MAX`
5817        #[must_use]
5818        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
5819            self.inner = self.inner.max_encoding_message_size(limit);
5820            self
5821        }
5822        pub async fn subscribe(
5823            &mut self,
5824            request: impl tonic::IntoRequest<super::SubscribeRequest>,
5825        ) -> std::result::Result<
5826            tonic::Response<tonic::codec::Streaming<super::SubscribeResponse>>,
5827            tonic::Status,
5828        > {
5829            self.inner
5830                .ready()
5831                .await
5832                .map_err(|e| {
5833                    tonic::Status::unknown(
5834                        format!("Service was not ready: {}", e.into()),
5835                    )
5836                })?;
5837            let codec = tonic_prost::ProstCodec::default();
5838            let path = http::uri::PathAndQuery::from_static(
5839                "/meta.NotificationService/Subscribe",
5840            );
5841            let mut req = request.into_request();
5842            req.extensions_mut()
5843                .insert(GrpcMethod::new("meta.NotificationService", "Subscribe"));
5844            self.inner.server_streaming(req, path, codec).await
5845        }
5846    }
5847}
5848/// Generated server implementations.
5849pub mod notification_service_server {
5850    #![allow(
5851        unused_variables,
5852        dead_code,
5853        missing_docs,
5854        clippy::wildcard_imports,
5855        clippy::let_unit_value,
5856    )]
5857    use tonic::codegen::*;
5858    /// Generated trait containing gRPC methods that should be implemented for use with NotificationServiceServer.
5859    #[async_trait]
5860    pub trait NotificationService: std::marker::Send + std::marker::Sync + 'static {
5861        /// Server streaming response type for the Subscribe method.
5862        type SubscribeStream: tonic::codegen::tokio_stream::Stream<
5863                Item = std::result::Result<super::SubscribeResponse, tonic::Status>,
5864            >
5865            + std::marker::Send
5866            + 'static;
5867        async fn subscribe(
5868            &self,
5869            request: tonic::Request<super::SubscribeRequest>,
5870        ) -> std::result::Result<tonic::Response<Self::SubscribeStream>, tonic::Status>;
5871    }
5872    #[derive(Debug)]
5873    pub struct NotificationServiceServer<T> {
5874        inner: Arc<T>,
5875        accept_compression_encodings: EnabledCompressionEncodings,
5876        send_compression_encodings: EnabledCompressionEncodings,
5877        max_decoding_message_size: Option<usize>,
5878        max_encoding_message_size: Option<usize>,
5879    }
5880    impl<T> NotificationServiceServer<T> {
5881        pub fn new(inner: T) -> Self {
5882            Self::from_arc(Arc::new(inner))
5883        }
5884        pub fn from_arc(inner: Arc<T>) -> Self {
5885            Self {
5886                inner,
5887                accept_compression_encodings: Default::default(),
5888                send_compression_encodings: Default::default(),
5889                max_decoding_message_size: None,
5890                max_encoding_message_size: None,
5891            }
5892        }
5893        pub fn with_interceptor<F>(
5894            inner: T,
5895            interceptor: F,
5896        ) -> InterceptedService<Self, F>
5897        where
5898            F: tonic::service::Interceptor,
5899        {
5900            InterceptedService::new(Self::new(inner), interceptor)
5901        }
5902        /// Enable decompressing requests with the given encoding.
5903        #[must_use]
5904        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
5905            self.accept_compression_encodings.enable(encoding);
5906            self
5907        }
5908        /// Compress responses with the given encoding, if the client supports it.
5909        #[must_use]
5910        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
5911            self.send_compression_encodings.enable(encoding);
5912            self
5913        }
5914        /// Limits the maximum size of a decoded message.
5915        ///
5916        /// Default: `4MB`
5917        #[must_use]
5918        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
5919            self.max_decoding_message_size = Some(limit);
5920            self
5921        }
5922        /// Limits the maximum size of an encoded message.
5923        ///
5924        /// Default: `usize::MAX`
5925        #[must_use]
5926        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
5927            self.max_encoding_message_size = Some(limit);
5928            self
5929        }
5930    }
5931    impl<T, B> tonic::codegen::Service<http::Request<B>> for NotificationServiceServer<T>
5932    where
5933        T: NotificationService,
5934        B: Body + std::marker::Send + 'static,
5935        B::Error: Into<StdError> + std::marker::Send + 'static,
5936    {
5937        type Response = http::Response<tonic::body::Body>;
5938        type Error = std::convert::Infallible;
5939        type Future = BoxFuture<Self::Response, Self::Error>;
5940        fn poll_ready(
5941            &mut self,
5942            _cx: &mut Context<'_>,
5943        ) -> Poll<std::result::Result<(), Self::Error>> {
5944            Poll::Ready(Ok(()))
5945        }
5946        fn call(&mut self, req: http::Request<B>) -> Self::Future {
5947            match req.uri().path() {
5948                "/meta.NotificationService/Subscribe" => {
5949                    #[allow(non_camel_case_types)]
5950                    struct SubscribeSvc<T: NotificationService>(pub Arc<T>);
5951                    impl<
5952                        T: NotificationService,
5953                    > tonic::server::ServerStreamingService<super::SubscribeRequest>
5954                    for SubscribeSvc<T> {
5955                        type Response = super::SubscribeResponse;
5956                        type ResponseStream = T::SubscribeStream;
5957                        type Future = BoxFuture<
5958                            tonic::Response<Self::ResponseStream>,
5959                            tonic::Status,
5960                        >;
5961                        fn call(
5962                            &mut self,
5963                            request: tonic::Request<super::SubscribeRequest>,
5964                        ) -> Self::Future {
5965                            let inner = Arc::clone(&self.0);
5966                            let fut = async move {
5967                                <T as NotificationService>::subscribe(&inner, request).await
5968                            };
5969                            Box::pin(fut)
5970                        }
5971                    }
5972                    let accept_compression_encodings = self.accept_compression_encodings;
5973                    let send_compression_encodings = self.send_compression_encodings;
5974                    let max_decoding_message_size = self.max_decoding_message_size;
5975                    let max_encoding_message_size = self.max_encoding_message_size;
5976                    let inner = self.inner.clone();
5977                    let fut = async move {
5978                        let method = SubscribeSvc(inner);
5979                        let codec = tonic_prost::ProstCodec::default();
5980                        let mut grpc = tonic::server::Grpc::new(codec)
5981                            .apply_compression_config(
5982                                accept_compression_encodings,
5983                                send_compression_encodings,
5984                            )
5985                            .apply_max_message_size_config(
5986                                max_decoding_message_size,
5987                                max_encoding_message_size,
5988                            );
5989                        let res = grpc.server_streaming(method, req).await;
5990                        Ok(res)
5991                    };
5992                    Box::pin(fut)
5993                }
5994                _ => {
5995                    Box::pin(async move {
5996                        let mut response = http::Response::new(
5997                            tonic::body::Body::default(),
5998                        );
5999                        let headers = response.headers_mut();
6000                        headers
6001                            .insert(
6002                                tonic::Status::GRPC_STATUS,
6003                                (tonic::Code::Unimplemented as i32).into(),
6004                            );
6005                        headers
6006                            .insert(
6007                                http::header::CONTENT_TYPE,
6008                                tonic::metadata::GRPC_CONTENT_TYPE,
6009                            );
6010                        Ok(response)
6011                    })
6012                }
6013            }
6014        }
6015    }
6016    impl<T> Clone for NotificationServiceServer<T> {
6017        fn clone(&self) -> Self {
6018            let inner = self.inner.clone();
6019            Self {
6020                inner,
6021                accept_compression_encodings: self.accept_compression_encodings,
6022                send_compression_encodings: self.send_compression_encodings,
6023                max_decoding_message_size: self.max_decoding_message_size,
6024                max_encoding_message_size: self.max_encoding_message_size,
6025            }
6026        }
6027    }
6028    /// Generated gRPC service name
6029    pub const SERVICE_NAME: &str = "meta.NotificationService";
6030    impl<T> tonic::server::NamedService for NotificationServiceServer<T> {
6031        const NAME: &'static str = SERVICE_NAME;
6032    }
6033}
6034/// Generated client implementations.
6035pub mod scale_service_client {
6036    #![allow(
6037        unused_variables,
6038        dead_code,
6039        missing_docs,
6040        clippy::wildcard_imports,
6041        clippy::let_unit_value,
6042    )]
6043    use tonic::codegen::*;
6044    use tonic::codegen::http::Uri;
6045    /// This is used by `risectl`
6046    #[derive(Debug, Clone)]
6047    pub struct ScaleServiceClient<T> {
6048        inner: tonic::client::Grpc<T>,
6049    }
6050    impl ScaleServiceClient<tonic::transport::Channel> {
6051        /// Attempt to create a new client by connecting to a given endpoint.
6052        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
6053        where
6054            D: TryInto<tonic::transport::Endpoint>,
6055            D::Error: Into<StdError>,
6056        {
6057            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
6058            Ok(Self::new(conn))
6059        }
6060    }
6061    impl<T> ScaleServiceClient<T>
6062    where
6063        T: tonic::client::GrpcService<tonic::body::Body>,
6064        T::Error: Into<StdError>,
6065        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
6066        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
6067    {
6068        pub fn new(inner: T) -> Self {
6069            let inner = tonic::client::Grpc::new(inner);
6070            Self { inner }
6071        }
6072        pub fn with_origin(inner: T, origin: Uri) -> Self {
6073            let inner = tonic::client::Grpc::with_origin(inner, origin);
6074            Self { inner }
6075        }
6076        pub fn with_interceptor<F>(
6077            inner: T,
6078            interceptor: F,
6079        ) -> ScaleServiceClient<InterceptedService<T, F>>
6080        where
6081            F: tonic::service::Interceptor,
6082            T::ResponseBody: Default,
6083            T: tonic::codegen::Service<
6084                http::Request<tonic::body::Body>,
6085                Response = http::Response<
6086                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
6087                >,
6088            >,
6089            <T as tonic::codegen::Service<
6090                http::Request<tonic::body::Body>,
6091            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
6092        {
6093            ScaleServiceClient::new(InterceptedService::new(inner, interceptor))
6094        }
6095        /// Compress requests with the given encoding.
6096        ///
6097        /// This requires the server to support it otherwise it might respond with an
6098        /// error.
6099        #[must_use]
6100        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
6101            self.inner = self.inner.send_compressed(encoding);
6102            self
6103        }
6104        /// Enable decompressing responses.
6105        #[must_use]
6106        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
6107            self.inner = self.inner.accept_compressed(encoding);
6108            self
6109        }
6110        /// Limits the maximum size of a decoded message.
6111        ///
6112        /// Default: `4MB`
6113        #[must_use]
6114        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
6115            self.inner = self.inner.max_decoding_message_size(limit);
6116            self
6117        }
6118        /// Limits the maximum size of an encoded message.
6119        ///
6120        /// Default: `usize::MAX`
6121        #[must_use]
6122        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
6123            self.inner = self.inner.max_encoding_message_size(limit);
6124            self
6125        }
6126        pub async fn get_cluster_info(
6127            &mut self,
6128            request: impl tonic::IntoRequest<super::GetClusterInfoRequest>,
6129        ) -> std::result::Result<
6130            tonic::Response<super::GetClusterInfoResponse>,
6131            tonic::Status,
6132        > {
6133            self.inner
6134                .ready()
6135                .await
6136                .map_err(|e| {
6137                    tonic::Status::unknown(
6138                        format!("Service was not ready: {}", e.into()),
6139                    )
6140                })?;
6141            let codec = tonic_prost::ProstCodec::default();
6142            let path = http::uri::PathAndQuery::from_static(
6143                "/meta.ScaleService/GetClusterInfo",
6144            );
6145            let mut req = request.into_request();
6146            req.extensions_mut()
6147                .insert(GrpcMethod::new("meta.ScaleService", "GetClusterInfo"));
6148            self.inner.unary(req, path, codec).await
6149        }
6150        pub async fn reschedule(
6151            &mut self,
6152            request: impl tonic::IntoRequest<super::RescheduleRequest>,
6153        ) -> std::result::Result<
6154            tonic::Response<super::RescheduleResponse>,
6155            tonic::Status,
6156        > {
6157            self.inner
6158                .ready()
6159                .await
6160                .map_err(|e| {
6161                    tonic::Status::unknown(
6162                        format!("Service was not ready: {}", e.into()),
6163                    )
6164                })?;
6165            let codec = tonic_prost::ProstCodec::default();
6166            let path = http::uri::PathAndQuery::from_static(
6167                "/meta.ScaleService/Reschedule",
6168            );
6169            let mut req = request.into_request();
6170            req.extensions_mut()
6171                .insert(GrpcMethod::new("meta.ScaleService", "Reschedule"));
6172            self.inner.unary(req, path, codec).await
6173        }
6174        pub async fn update_streaming_job_node_labels(
6175            &mut self,
6176            request: impl tonic::IntoRequest<super::UpdateStreamingJobNodeLabelsRequest>,
6177        ) -> std::result::Result<
6178            tonic::Response<super::UpdateStreamingJobNodeLabelsResponse>,
6179            tonic::Status,
6180        > {
6181            self.inner
6182                .ready()
6183                .await
6184                .map_err(|e| {
6185                    tonic::Status::unknown(
6186                        format!("Service was not ready: {}", e.into()),
6187                    )
6188                })?;
6189            let codec = tonic_prost::ProstCodec::default();
6190            let path = http::uri::PathAndQuery::from_static(
6191                "/meta.ScaleService/UpdateStreamingJobNodeLabels",
6192            );
6193            let mut req = request.into_request();
6194            req.extensions_mut()
6195                .insert(
6196                    GrpcMethod::new("meta.ScaleService", "UpdateStreamingJobNodeLabels"),
6197                );
6198            self.inner.unary(req, path, codec).await
6199        }
6200        pub async fn get_serverless_streaming_jobs_status(
6201            &mut self,
6202            request: impl tonic::IntoRequest<
6203                super::GetServerlessStreamingJobsStatusRequest,
6204            >,
6205        ) -> std::result::Result<
6206            tonic::Response<super::GetServerlessStreamingJobsStatusResponse>,
6207            tonic::Status,
6208        > {
6209            self.inner
6210                .ready()
6211                .await
6212                .map_err(|e| {
6213                    tonic::Status::unknown(
6214                        format!("Service was not ready: {}", e.into()),
6215                    )
6216                })?;
6217            let codec = tonic_prost::ProstCodec::default();
6218            let path = http::uri::PathAndQuery::from_static(
6219                "/meta.ScaleService/GetServerlessStreamingJobsStatus",
6220            );
6221            let mut req = request.into_request();
6222            req.extensions_mut()
6223                .insert(
6224                    GrpcMethod::new(
6225                        "meta.ScaleService",
6226                        "GetServerlessStreamingJobsStatus",
6227                    ),
6228                );
6229            self.inner.unary(req, path, codec).await
6230        }
6231    }
6232}
6233/// Generated server implementations.
6234pub mod scale_service_server {
6235    #![allow(
6236        unused_variables,
6237        dead_code,
6238        missing_docs,
6239        clippy::wildcard_imports,
6240        clippy::let_unit_value,
6241    )]
6242    use tonic::codegen::*;
6243    /// Generated trait containing gRPC methods that should be implemented for use with ScaleServiceServer.
6244    #[async_trait]
6245    pub trait ScaleService: std::marker::Send + std::marker::Sync + 'static {
6246        async fn get_cluster_info(
6247            &self,
6248            request: tonic::Request<super::GetClusterInfoRequest>,
6249        ) -> std::result::Result<
6250            tonic::Response<super::GetClusterInfoResponse>,
6251            tonic::Status,
6252        >;
6253        async fn reschedule(
6254            &self,
6255            request: tonic::Request<super::RescheduleRequest>,
6256        ) -> std::result::Result<
6257            tonic::Response<super::RescheduleResponse>,
6258            tonic::Status,
6259        >;
6260        async fn update_streaming_job_node_labels(
6261            &self,
6262            request: tonic::Request<super::UpdateStreamingJobNodeLabelsRequest>,
6263        ) -> std::result::Result<
6264            tonic::Response<super::UpdateStreamingJobNodeLabelsResponse>,
6265            tonic::Status,
6266        >;
6267        async fn get_serverless_streaming_jobs_status(
6268            &self,
6269            request: tonic::Request<super::GetServerlessStreamingJobsStatusRequest>,
6270        ) -> std::result::Result<
6271            tonic::Response<super::GetServerlessStreamingJobsStatusResponse>,
6272            tonic::Status,
6273        >;
6274    }
6275    /// This is used by `risectl`
6276    #[derive(Debug)]
6277    pub struct ScaleServiceServer<T> {
6278        inner: Arc<T>,
6279        accept_compression_encodings: EnabledCompressionEncodings,
6280        send_compression_encodings: EnabledCompressionEncodings,
6281        max_decoding_message_size: Option<usize>,
6282        max_encoding_message_size: Option<usize>,
6283    }
6284    impl<T> ScaleServiceServer<T> {
6285        pub fn new(inner: T) -> Self {
6286            Self::from_arc(Arc::new(inner))
6287        }
6288        pub fn from_arc(inner: Arc<T>) -> Self {
6289            Self {
6290                inner,
6291                accept_compression_encodings: Default::default(),
6292                send_compression_encodings: Default::default(),
6293                max_decoding_message_size: None,
6294                max_encoding_message_size: None,
6295            }
6296        }
6297        pub fn with_interceptor<F>(
6298            inner: T,
6299            interceptor: F,
6300        ) -> InterceptedService<Self, F>
6301        where
6302            F: tonic::service::Interceptor,
6303        {
6304            InterceptedService::new(Self::new(inner), interceptor)
6305        }
6306        /// Enable decompressing requests with the given encoding.
6307        #[must_use]
6308        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
6309            self.accept_compression_encodings.enable(encoding);
6310            self
6311        }
6312        /// Compress responses with the given encoding, if the client supports it.
6313        #[must_use]
6314        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
6315            self.send_compression_encodings.enable(encoding);
6316            self
6317        }
6318        /// Limits the maximum size of a decoded message.
6319        ///
6320        /// Default: `4MB`
6321        #[must_use]
6322        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
6323            self.max_decoding_message_size = Some(limit);
6324            self
6325        }
6326        /// Limits the maximum size of an encoded message.
6327        ///
6328        /// Default: `usize::MAX`
6329        #[must_use]
6330        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
6331            self.max_encoding_message_size = Some(limit);
6332            self
6333        }
6334    }
6335    impl<T, B> tonic::codegen::Service<http::Request<B>> for ScaleServiceServer<T>
6336    where
6337        T: ScaleService,
6338        B: Body + std::marker::Send + 'static,
6339        B::Error: Into<StdError> + std::marker::Send + 'static,
6340    {
6341        type Response = http::Response<tonic::body::Body>;
6342        type Error = std::convert::Infallible;
6343        type Future = BoxFuture<Self::Response, Self::Error>;
6344        fn poll_ready(
6345            &mut self,
6346            _cx: &mut Context<'_>,
6347        ) -> Poll<std::result::Result<(), Self::Error>> {
6348            Poll::Ready(Ok(()))
6349        }
6350        fn call(&mut self, req: http::Request<B>) -> Self::Future {
6351            match req.uri().path() {
6352                "/meta.ScaleService/GetClusterInfo" => {
6353                    #[allow(non_camel_case_types)]
6354                    struct GetClusterInfoSvc<T: ScaleService>(pub Arc<T>);
6355                    impl<
6356                        T: ScaleService,
6357                    > tonic::server::UnaryService<super::GetClusterInfoRequest>
6358                    for GetClusterInfoSvc<T> {
6359                        type Response = super::GetClusterInfoResponse;
6360                        type Future = BoxFuture<
6361                            tonic::Response<Self::Response>,
6362                            tonic::Status,
6363                        >;
6364                        fn call(
6365                            &mut self,
6366                            request: tonic::Request<super::GetClusterInfoRequest>,
6367                        ) -> Self::Future {
6368                            let inner = Arc::clone(&self.0);
6369                            let fut = async move {
6370                                <T as ScaleService>::get_cluster_info(&inner, request).await
6371                            };
6372                            Box::pin(fut)
6373                        }
6374                    }
6375                    let accept_compression_encodings = self.accept_compression_encodings;
6376                    let send_compression_encodings = self.send_compression_encodings;
6377                    let max_decoding_message_size = self.max_decoding_message_size;
6378                    let max_encoding_message_size = self.max_encoding_message_size;
6379                    let inner = self.inner.clone();
6380                    let fut = async move {
6381                        let method = GetClusterInfoSvc(inner);
6382                        let codec = tonic_prost::ProstCodec::default();
6383                        let mut grpc = tonic::server::Grpc::new(codec)
6384                            .apply_compression_config(
6385                                accept_compression_encodings,
6386                                send_compression_encodings,
6387                            )
6388                            .apply_max_message_size_config(
6389                                max_decoding_message_size,
6390                                max_encoding_message_size,
6391                            );
6392                        let res = grpc.unary(method, req).await;
6393                        Ok(res)
6394                    };
6395                    Box::pin(fut)
6396                }
6397                "/meta.ScaleService/Reschedule" => {
6398                    #[allow(non_camel_case_types)]
6399                    struct RescheduleSvc<T: ScaleService>(pub Arc<T>);
6400                    impl<
6401                        T: ScaleService,
6402                    > tonic::server::UnaryService<super::RescheduleRequest>
6403                    for RescheduleSvc<T> {
6404                        type Response = super::RescheduleResponse;
6405                        type Future = BoxFuture<
6406                            tonic::Response<Self::Response>,
6407                            tonic::Status,
6408                        >;
6409                        fn call(
6410                            &mut self,
6411                            request: tonic::Request<super::RescheduleRequest>,
6412                        ) -> Self::Future {
6413                            let inner = Arc::clone(&self.0);
6414                            let fut = async move {
6415                                <T as ScaleService>::reschedule(&inner, request).await
6416                            };
6417                            Box::pin(fut)
6418                        }
6419                    }
6420                    let accept_compression_encodings = self.accept_compression_encodings;
6421                    let send_compression_encodings = self.send_compression_encodings;
6422                    let max_decoding_message_size = self.max_decoding_message_size;
6423                    let max_encoding_message_size = self.max_encoding_message_size;
6424                    let inner = self.inner.clone();
6425                    let fut = async move {
6426                        let method = RescheduleSvc(inner);
6427                        let codec = tonic_prost::ProstCodec::default();
6428                        let mut grpc = tonic::server::Grpc::new(codec)
6429                            .apply_compression_config(
6430                                accept_compression_encodings,
6431                                send_compression_encodings,
6432                            )
6433                            .apply_max_message_size_config(
6434                                max_decoding_message_size,
6435                                max_encoding_message_size,
6436                            );
6437                        let res = grpc.unary(method, req).await;
6438                        Ok(res)
6439                    };
6440                    Box::pin(fut)
6441                }
6442                "/meta.ScaleService/UpdateStreamingJobNodeLabels" => {
6443                    #[allow(non_camel_case_types)]
6444                    struct UpdateStreamingJobNodeLabelsSvc<T: ScaleService>(pub Arc<T>);
6445                    impl<
6446                        T: ScaleService,
6447                    > tonic::server::UnaryService<
6448                        super::UpdateStreamingJobNodeLabelsRequest,
6449                    > for UpdateStreamingJobNodeLabelsSvc<T> {
6450                        type Response = super::UpdateStreamingJobNodeLabelsResponse;
6451                        type Future = BoxFuture<
6452                            tonic::Response<Self::Response>,
6453                            tonic::Status,
6454                        >;
6455                        fn call(
6456                            &mut self,
6457                            request: tonic::Request<
6458                                super::UpdateStreamingJobNodeLabelsRequest,
6459                            >,
6460                        ) -> Self::Future {
6461                            let inner = Arc::clone(&self.0);
6462                            let fut = async move {
6463                                <T as ScaleService>::update_streaming_job_node_labels(
6464                                        &inner,
6465                                        request,
6466                                    )
6467                                    .await
6468                            };
6469                            Box::pin(fut)
6470                        }
6471                    }
6472                    let accept_compression_encodings = self.accept_compression_encodings;
6473                    let send_compression_encodings = self.send_compression_encodings;
6474                    let max_decoding_message_size = self.max_decoding_message_size;
6475                    let max_encoding_message_size = self.max_encoding_message_size;
6476                    let inner = self.inner.clone();
6477                    let fut = async move {
6478                        let method = UpdateStreamingJobNodeLabelsSvc(inner);
6479                        let codec = tonic_prost::ProstCodec::default();
6480                        let mut grpc = tonic::server::Grpc::new(codec)
6481                            .apply_compression_config(
6482                                accept_compression_encodings,
6483                                send_compression_encodings,
6484                            )
6485                            .apply_max_message_size_config(
6486                                max_decoding_message_size,
6487                                max_encoding_message_size,
6488                            );
6489                        let res = grpc.unary(method, req).await;
6490                        Ok(res)
6491                    };
6492                    Box::pin(fut)
6493                }
6494                "/meta.ScaleService/GetServerlessStreamingJobsStatus" => {
6495                    #[allow(non_camel_case_types)]
6496                    struct GetServerlessStreamingJobsStatusSvc<T: ScaleService>(
6497                        pub Arc<T>,
6498                    );
6499                    impl<
6500                        T: ScaleService,
6501                    > tonic::server::UnaryService<
6502                        super::GetServerlessStreamingJobsStatusRequest,
6503                    > for GetServerlessStreamingJobsStatusSvc<T> {
6504                        type Response = super::GetServerlessStreamingJobsStatusResponse;
6505                        type Future = BoxFuture<
6506                            tonic::Response<Self::Response>,
6507                            tonic::Status,
6508                        >;
6509                        fn call(
6510                            &mut self,
6511                            request: tonic::Request<
6512                                super::GetServerlessStreamingJobsStatusRequest,
6513                            >,
6514                        ) -> Self::Future {
6515                            let inner = Arc::clone(&self.0);
6516                            let fut = async move {
6517                                <T as ScaleService>::get_serverless_streaming_jobs_status(
6518                                        &inner,
6519                                        request,
6520                                    )
6521                                    .await
6522                            };
6523                            Box::pin(fut)
6524                        }
6525                    }
6526                    let accept_compression_encodings = self.accept_compression_encodings;
6527                    let send_compression_encodings = self.send_compression_encodings;
6528                    let max_decoding_message_size = self.max_decoding_message_size;
6529                    let max_encoding_message_size = self.max_encoding_message_size;
6530                    let inner = self.inner.clone();
6531                    let fut = async move {
6532                        let method = GetServerlessStreamingJobsStatusSvc(inner);
6533                        let codec = tonic_prost::ProstCodec::default();
6534                        let mut grpc = tonic::server::Grpc::new(codec)
6535                            .apply_compression_config(
6536                                accept_compression_encodings,
6537                                send_compression_encodings,
6538                            )
6539                            .apply_max_message_size_config(
6540                                max_decoding_message_size,
6541                                max_encoding_message_size,
6542                            );
6543                        let res = grpc.unary(method, req).await;
6544                        Ok(res)
6545                    };
6546                    Box::pin(fut)
6547                }
6548                _ => {
6549                    Box::pin(async move {
6550                        let mut response = http::Response::new(
6551                            tonic::body::Body::default(),
6552                        );
6553                        let headers = response.headers_mut();
6554                        headers
6555                            .insert(
6556                                tonic::Status::GRPC_STATUS,
6557                                (tonic::Code::Unimplemented as i32).into(),
6558                            );
6559                        headers
6560                            .insert(
6561                                http::header::CONTENT_TYPE,
6562                                tonic::metadata::GRPC_CONTENT_TYPE,
6563                            );
6564                        Ok(response)
6565                    })
6566                }
6567            }
6568        }
6569    }
6570    impl<T> Clone for ScaleServiceServer<T> {
6571        fn clone(&self) -> Self {
6572            let inner = self.inner.clone();
6573            Self {
6574                inner,
6575                accept_compression_encodings: self.accept_compression_encodings,
6576                send_compression_encodings: self.send_compression_encodings,
6577                max_decoding_message_size: self.max_decoding_message_size,
6578                max_encoding_message_size: self.max_encoding_message_size,
6579            }
6580        }
6581    }
6582    /// Generated gRPC service name
6583    pub const SERVICE_NAME: &str = "meta.ScaleService";
6584    impl<T> tonic::server::NamedService for ScaleServiceServer<T> {
6585        const NAME: &'static str = SERVICE_NAME;
6586    }
6587}
6588/// Generated client implementations.
6589pub mod meta_member_service_client {
6590    #![allow(
6591        unused_variables,
6592        dead_code,
6593        missing_docs,
6594        clippy::wildcard_imports,
6595        clippy::let_unit_value,
6596    )]
6597    use tonic::codegen::*;
6598    use tonic::codegen::http::Uri;
6599    #[derive(Debug, Clone)]
6600    pub struct MetaMemberServiceClient<T> {
6601        inner: tonic::client::Grpc<T>,
6602    }
6603    impl MetaMemberServiceClient<tonic::transport::Channel> {
6604        /// Attempt to create a new client by connecting to a given endpoint.
6605        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
6606        where
6607            D: TryInto<tonic::transport::Endpoint>,
6608            D::Error: Into<StdError>,
6609        {
6610            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
6611            Ok(Self::new(conn))
6612        }
6613    }
6614    impl<T> MetaMemberServiceClient<T>
6615    where
6616        T: tonic::client::GrpcService<tonic::body::Body>,
6617        T::Error: Into<StdError>,
6618        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
6619        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
6620    {
6621        pub fn new(inner: T) -> Self {
6622            let inner = tonic::client::Grpc::new(inner);
6623            Self { inner }
6624        }
6625        pub fn with_origin(inner: T, origin: Uri) -> Self {
6626            let inner = tonic::client::Grpc::with_origin(inner, origin);
6627            Self { inner }
6628        }
6629        pub fn with_interceptor<F>(
6630            inner: T,
6631            interceptor: F,
6632        ) -> MetaMemberServiceClient<InterceptedService<T, F>>
6633        where
6634            F: tonic::service::Interceptor,
6635            T::ResponseBody: Default,
6636            T: tonic::codegen::Service<
6637                http::Request<tonic::body::Body>,
6638                Response = http::Response<
6639                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
6640                >,
6641            >,
6642            <T as tonic::codegen::Service<
6643                http::Request<tonic::body::Body>,
6644            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
6645        {
6646            MetaMemberServiceClient::new(InterceptedService::new(inner, interceptor))
6647        }
6648        /// Compress requests with the given encoding.
6649        ///
6650        /// This requires the server to support it otherwise it might respond with an
6651        /// error.
6652        #[must_use]
6653        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
6654            self.inner = self.inner.send_compressed(encoding);
6655            self
6656        }
6657        /// Enable decompressing responses.
6658        #[must_use]
6659        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
6660            self.inner = self.inner.accept_compressed(encoding);
6661            self
6662        }
6663        /// Limits the maximum size of a decoded message.
6664        ///
6665        /// Default: `4MB`
6666        #[must_use]
6667        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
6668            self.inner = self.inner.max_decoding_message_size(limit);
6669            self
6670        }
6671        /// Limits the maximum size of an encoded message.
6672        ///
6673        /// Default: `usize::MAX`
6674        #[must_use]
6675        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
6676            self.inner = self.inner.max_encoding_message_size(limit);
6677            self
6678        }
6679        pub async fn members(
6680            &mut self,
6681            request: impl tonic::IntoRequest<super::MembersRequest>,
6682        ) -> std::result::Result<
6683            tonic::Response<super::MembersResponse>,
6684            tonic::Status,
6685        > {
6686            self.inner
6687                .ready()
6688                .await
6689                .map_err(|e| {
6690                    tonic::Status::unknown(
6691                        format!("Service was not ready: {}", e.into()),
6692                    )
6693                })?;
6694            let codec = tonic_prost::ProstCodec::default();
6695            let path = http::uri::PathAndQuery::from_static(
6696                "/meta.MetaMemberService/Members",
6697            );
6698            let mut req = request.into_request();
6699            req.extensions_mut()
6700                .insert(GrpcMethod::new("meta.MetaMemberService", "Members"));
6701            self.inner.unary(req, path, codec).await
6702        }
6703    }
6704}
6705/// Generated server implementations.
6706pub mod meta_member_service_server {
6707    #![allow(
6708        unused_variables,
6709        dead_code,
6710        missing_docs,
6711        clippy::wildcard_imports,
6712        clippy::let_unit_value,
6713    )]
6714    use tonic::codegen::*;
6715    /// Generated trait containing gRPC methods that should be implemented for use with MetaMemberServiceServer.
6716    #[async_trait]
6717    pub trait MetaMemberService: std::marker::Send + std::marker::Sync + 'static {
6718        async fn members(
6719            &self,
6720            request: tonic::Request<super::MembersRequest>,
6721        ) -> std::result::Result<tonic::Response<super::MembersResponse>, tonic::Status>;
6722    }
6723    #[derive(Debug)]
6724    pub struct MetaMemberServiceServer<T> {
6725        inner: Arc<T>,
6726        accept_compression_encodings: EnabledCompressionEncodings,
6727        send_compression_encodings: EnabledCompressionEncodings,
6728        max_decoding_message_size: Option<usize>,
6729        max_encoding_message_size: Option<usize>,
6730    }
6731    impl<T> MetaMemberServiceServer<T> {
6732        pub fn new(inner: T) -> Self {
6733            Self::from_arc(Arc::new(inner))
6734        }
6735        pub fn from_arc(inner: Arc<T>) -> Self {
6736            Self {
6737                inner,
6738                accept_compression_encodings: Default::default(),
6739                send_compression_encodings: Default::default(),
6740                max_decoding_message_size: None,
6741                max_encoding_message_size: None,
6742            }
6743        }
6744        pub fn with_interceptor<F>(
6745            inner: T,
6746            interceptor: F,
6747        ) -> InterceptedService<Self, F>
6748        where
6749            F: tonic::service::Interceptor,
6750        {
6751            InterceptedService::new(Self::new(inner), interceptor)
6752        }
6753        /// Enable decompressing requests with the given encoding.
6754        #[must_use]
6755        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
6756            self.accept_compression_encodings.enable(encoding);
6757            self
6758        }
6759        /// Compress responses with the given encoding, if the client supports it.
6760        #[must_use]
6761        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
6762            self.send_compression_encodings.enable(encoding);
6763            self
6764        }
6765        /// Limits the maximum size of a decoded message.
6766        ///
6767        /// Default: `4MB`
6768        #[must_use]
6769        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
6770            self.max_decoding_message_size = Some(limit);
6771            self
6772        }
6773        /// Limits the maximum size of an encoded message.
6774        ///
6775        /// Default: `usize::MAX`
6776        #[must_use]
6777        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
6778            self.max_encoding_message_size = Some(limit);
6779            self
6780        }
6781    }
6782    impl<T, B> tonic::codegen::Service<http::Request<B>> for MetaMemberServiceServer<T>
6783    where
6784        T: MetaMemberService,
6785        B: Body + std::marker::Send + 'static,
6786        B::Error: Into<StdError> + std::marker::Send + 'static,
6787    {
6788        type Response = http::Response<tonic::body::Body>;
6789        type Error = std::convert::Infallible;
6790        type Future = BoxFuture<Self::Response, Self::Error>;
6791        fn poll_ready(
6792            &mut self,
6793            _cx: &mut Context<'_>,
6794        ) -> Poll<std::result::Result<(), Self::Error>> {
6795            Poll::Ready(Ok(()))
6796        }
6797        fn call(&mut self, req: http::Request<B>) -> Self::Future {
6798            match req.uri().path() {
6799                "/meta.MetaMemberService/Members" => {
6800                    #[allow(non_camel_case_types)]
6801                    struct MembersSvc<T: MetaMemberService>(pub Arc<T>);
6802                    impl<
6803                        T: MetaMemberService,
6804                    > tonic::server::UnaryService<super::MembersRequest>
6805                    for MembersSvc<T> {
6806                        type Response = super::MembersResponse;
6807                        type Future = BoxFuture<
6808                            tonic::Response<Self::Response>,
6809                            tonic::Status,
6810                        >;
6811                        fn call(
6812                            &mut self,
6813                            request: tonic::Request<super::MembersRequest>,
6814                        ) -> Self::Future {
6815                            let inner = Arc::clone(&self.0);
6816                            let fut = async move {
6817                                <T as MetaMemberService>::members(&inner, request).await
6818                            };
6819                            Box::pin(fut)
6820                        }
6821                    }
6822                    let accept_compression_encodings = self.accept_compression_encodings;
6823                    let send_compression_encodings = self.send_compression_encodings;
6824                    let max_decoding_message_size = self.max_decoding_message_size;
6825                    let max_encoding_message_size = self.max_encoding_message_size;
6826                    let inner = self.inner.clone();
6827                    let fut = async move {
6828                        let method = MembersSvc(inner);
6829                        let codec = tonic_prost::ProstCodec::default();
6830                        let mut grpc = tonic::server::Grpc::new(codec)
6831                            .apply_compression_config(
6832                                accept_compression_encodings,
6833                                send_compression_encodings,
6834                            )
6835                            .apply_max_message_size_config(
6836                                max_decoding_message_size,
6837                                max_encoding_message_size,
6838                            );
6839                        let res = grpc.unary(method, req).await;
6840                        Ok(res)
6841                    };
6842                    Box::pin(fut)
6843                }
6844                _ => {
6845                    Box::pin(async move {
6846                        let mut response = http::Response::new(
6847                            tonic::body::Body::default(),
6848                        );
6849                        let headers = response.headers_mut();
6850                        headers
6851                            .insert(
6852                                tonic::Status::GRPC_STATUS,
6853                                (tonic::Code::Unimplemented as i32).into(),
6854                            );
6855                        headers
6856                            .insert(
6857                                http::header::CONTENT_TYPE,
6858                                tonic::metadata::GRPC_CONTENT_TYPE,
6859                            );
6860                        Ok(response)
6861                    })
6862                }
6863            }
6864        }
6865    }
6866    impl<T> Clone for MetaMemberServiceServer<T> {
6867        fn clone(&self) -> Self {
6868            let inner = self.inner.clone();
6869            Self {
6870                inner,
6871                accept_compression_encodings: self.accept_compression_encodings,
6872                send_compression_encodings: self.send_compression_encodings,
6873                max_decoding_message_size: self.max_decoding_message_size,
6874                max_encoding_message_size: self.max_encoding_message_size,
6875            }
6876        }
6877    }
6878    /// Generated gRPC service name
6879    pub const SERVICE_NAME: &str = "meta.MetaMemberService";
6880    impl<T> tonic::server::NamedService for MetaMemberServiceServer<T> {
6881        const NAME: &'static str = SERVICE_NAME;
6882    }
6883}
6884/// Generated client implementations.
6885pub mod system_params_service_client {
6886    #![allow(
6887        unused_variables,
6888        dead_code,
6889        missing_docs,
6890        clippy::wildcard_imports,
6891        clippy::let_unit_value,
6892    )]
6893    use tonic::codegen::*;
6894    use tonic::codegen::http::Uri;
6895    #[derive(Debug, Clone)]
6896    pub struct SystemParamsServiceClient<T> {
6897        inner: tonic::client::Grpc<T>,
6898    }
6899    impl SystemParamsServiceClient<tonic::transport::Channel> {
6900        /// Attempt to create a new client by connecting to a given endpoint.
6901        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
6902        where
6903            D: TryInto<tonic::transport::Endpoint>,
6904            D::Error: Into<StdError>,
6905        {
6906            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
6907            Ok(Self::new(conn))
6908        }
6909    }
6910    impl<T> SystemParamsServiceClient<T>
6911    where
6912        T: tonic::client::GrpcService<tonic::body::Body>,
6913        T::Error: Into<StdError>,
6914        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
6915        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
6916    {
6917        pub fn new(inner: T) -> Self {
6918            let inner = tonic::client::Grpc::new(inner);
6919            Self { inner }
6920        }
6921        pub fn with_origin(inner: T, origin: Uri) -> Self {
6922            let inner = tonic::client::Grpc::with_origin(inner, origin);
6923            Self { inner }
6924        }
6925        pub fn with_interceptor<F>(
6926            inner: T,
6927            interceptor: F,
6928        ) -> SystemParamsServiceClient<InterceptedService<T, F>>
6929        where
6930            F: tonic::service::Interceptor,
6931            T::ResponseBody: Default,
6932            T: tonic::codegen::Service<
6933                http::Request<tonic::body::Body>,
6934                Response = http::Response<
6935                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
6936                >,
6937            >,
6938            <T as tonic::codegen::Service<
6939                http::Request<tonic::body::Body>,
6940            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
6941        {
6942            SystemParamsServiceClient::new(InterceptedService::new(inner, interceptor))
6943        }
6944        /// Compress requests with the given encoding.
6945        ///
6946        /// This requires the server to support it otherwise it might respond with an
6947        /// error.
6948        #[must_use]
6949        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
6950            self.inner = self.inner.send_compressed(encoding);
6951            self
6952        }
6953        /// Enable decompressing responses.
6954        #[must_use]
6955        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
6956            self.inner = self.inner.accept_compressed(encoding);
6957            self
6958        }
6959        /// Limits the maximum size of a decoded message.
6960        ///
6961        /// Default: `4MB`
6962        #[must_use]
6963        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
6964            self.inner = self.inner.max_decoding_message_size(limit);
6965            self
6966        }
6967        /// Limits the maximum size of an encoded message.
6968        ///
6969        /// Default: `usize::MAX`
6970        #[must_use]
6971        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
6972            self.inner = self.inner.max_encoding_message_size(limit);
6973            self
6974        }
6975        pub async fn get_system_params(
6976            &mut self,
6977            request: impl tonic::IntoRequest<super::GetSystemParamsRequest>,
6978        ) -> std::result::Result<
6979            tonic::Response<super::GetSystemParamsResponse>,
6980            tonic::Status,
6981        > {
6982            self.inner
6983                .ready()
6984                .await
6985                .map_err(|e| {
6986                    tonic::Status::unknown(
6987                        format!("Service was not ready: {}", e.into()),
6988                    )
6989                })?;
6990            let codec = tonic_prost::ProstCodec::default();
6991            let path = http::uri::PathAndQuery::from_static(
6992                "/meta.SystemParamsService/GetSystemParams",
6993            );
6994            let mut req = request.into_request();
6995            req.extensions_mut()
6996                .insert(GrpcMethod::new("meta.SystemParamsService", "GetSystemParams"));
6997            self.inner.unary(req, path, codec).await
6998        }
6999        pub async fn set_system_param(
7000            &mut self,
7001            request: impl tonic::IntoRequest<super::SetSystemParamRequest>,
7002        ) -> std::result::Result<
7003            tonic::Response<super::SetSystemParamResponse>,
7004            tonic::Status,
7005        > {
7006            self.inner
7007                .ready()
7008                .await
7009                .map_err(|e| {
7010                    tonic::Status::unknown(
7011                        format!("Service was not ready: {}", e.into()),
7012                    )
7013                })?;
7014            let codec = tonic_prost::ProstCodec::default();
7015            let path = http::uri::PathAndQuery::from_static(
7016                "/meta.SystemParamsService/SetSystemParam",
7017            );
7018            let mut req = request.into_request();
7019            req.extensions_mut()
7020                .insert(GrpcMethod::new("meta.SystemParamsService", "SetSystemParam"));
7021            self.inner.unary(req, path, codec).await
7022        }
7023    }
7024}
7025/// Generated server implementations.
7026pub mod system_params_service_server {
7027    #![allow(
7028        unused_variables,
7029        dead_code,
7030        missing_docs,
7031        clippy::wildcard_imports,
7032        clippy::let_unit_value,
7033    )]
7034    use tonic::codegen::*;
7035    /// Generated trait containing gRPC methods that should be implemented for use with SystemParamsServiceServer.
7036    #[async_trait]
7037    pub trait SystemParamsService: std::marker::Send + std::marker::Sync + 'static {
7038        async fn get_system_params(
7039            &self,
7040            request: tonic::Request<super::GetSystemParamsRequest>,
7041        ) -> std::result::Result<
7042            tonic::Response<super::GetSystemParamsResponse>,
7043            tonic::Status,
7044        >;
7045        async fn set_system_param(
7046            &self,
7047            request: tonic::Request<super::SetSystemParamRequest>,
7048        ) -> std::result::Result<
7049            tonic::Response<super::SetSystemParamResponse>,
7050            tonic::Status,
7051        >;
7052    }
7053    #[derive(Debug)]
7054    pub struct SystemParamsServiceServer<T> {
7055        inner: Arc<T>,
7056        accept_compression_encodings: EnabledCompressionEncodings,
7057        send_compression_encodings: EnabledCompressionEncodings,
7058        max_decoding_message_size: Option<usize>,
7059        max_encoding_message_size: Option<usize>,
7060    }
7061    impl<T> SystemParamsServiceServer<T> {
7062        pub fn new(inner: T) -> Self {
7063            Self::from_arc(Arc::new(inner))
7064        }
7065        pub fn from_arc(inner: Arc<T>) -> Self {
7066            Self {
7067                inner,
7068                accept_compression_encodings: Default::default(),
7069                send_compression_encodings: Default::default(),
7070                max_decoding_message_size: None,
7071                max_encoding_message_size: None,
7072            }
7073        }
7074        pub fn with_interceptor<F>(
7075            inner: T,
7076            interceptor: F,
7077        ) -> InterceptedService<Self, F>
7078        where
7079            F: tonic::service::Interceptor,
7080        {
7081            InterceptedService::new(Self::new(inner), interceptor)
7082        }
7083        /// Enable decompressing requests with the given encoding.
7084        #[must_use]
7085        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
7086            self.accept_compression_encodings.enable(encoding);
7087            self
7088        }
7089        /// Compress responses with the given encoding, if the client supports it.
7090        #[must_use]
7091        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
7092            self.send_compression_encodings.enable(encoding);
7093            self
7094        }
7095        /// Limits the maximum size of a decoded message.
7096        ///
7097        /// Default: `4MB`
7098        #[must_use]
7099        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
7100            self.max_decoding_message_size = Some(limit);
7101            self
7102        }
7103        /// Limits the maximum size of an encoded message.
7104        ///
7105        /// Default: `usize::MAX`
7106        #[must_use]
7107        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
7108            self.max_encoding_message_size = Some(limit);
7109            self
7110        }
7111    }
7112    impl<T, B> tonic::codegen::Service<http::Request<B>> for SystemParamsServiceServer<T>
7113    where
7114        T: SystemParamsService,
7115        B: Body + std::marker::Send + 'static,
7116        B::Error: Into<StdError> + std::marker::Send + 'static,
7117    {
7118        type Response = http::Response<tonic::body::Body>;
7119        type Error = std::convert::Infallible;
7120        type Future = BoxFuture<Self::Response, Self::Error>;
7121        fn poll_ready(
7122            &mut self,
7123            _cx: &mut Context<'_>,
7124        ) -> Poll<std::result::Result<(), Self::Error>> {
7125            Poll::Ready(Ok(()))
7126        }
7127        fn call(&mut self, req: http::Request<B>) -> Self::Future {
7128            match req.uri().path() {
7129                "/meta.SystemParamsService/GetSystemParams" => {
7130                    #[allow(non_camel_case_types)]
7131                    struct GetSystemParamsSvc<T: SystemParamsService>(pub Arc<T>);
7132                    impl<
7133                        T: SystemParamsService,
7134                    > tonic::server::UnaryService<super::GetSystemParamsRequest>
7135                    for GetSystemParamsSvc<T> {
7136                        type Response = super::GetSystemParamsResponse;
7137                        type Future = BoxFuture<
7138                            tonic::Response<Self::Response>,
7139                            tonic::Status,
7140                        >;
7141                        fn call(
7142                            &mut self,
7143                            request: tonic::Request<super::GetSystemParamsRequest>,
7144                        ) -> Self::Future {
7145                            let inner = Arc::clone(&self.0);
7146                            let fut = async move {
7147                                <T as SystemParamsService>::get_system_params(
7148                                        &inner,
7149                                        request,
7150                                    )
7151                                    .await
7152                            };
7153                            Box::pin(fut)
7154                        }
7155                    }
7156                    let accept_compression_encodings = self.accept_compression_encodings;
7157                    let send_compression_encodings = self.send_compression_encodings;
7158                    let max_decoding_message_size = self.max_decoding_message_size;
7159                    let max_encoding_message_size = self.max_encoding_message_size;
7160                    let inner = self.inner.clone();
7161                    let fut = async move {
7162                        let method = GetSystemParamsSvc(inner);
7163                        let codec = tonic_prost::ProstCodec::default();
7164                        let mut grpc = tonic::server::Grpc::new(codec)
7165                            .apply_compression_config(
7166                                accept_compression_encodings,
7167                                send_compression_encodings,
7168                            )
7169                            .apply_max_message_size_config(
7170                                max_decoding_message_size,
7171                                max_encoding_message_size,
7172                            );
7173                        let res = grpc.unary(method, req).await;
7174                        Ok(res)
7175                    };
7176                    Box::pin(fut)
7177                }
7178                "/meta.SystemParamsService/SetSystemParam" => {
7179                    #[allow(non_camel_case_types)]
7180                    struct SetSystemParamSvc<T: SystemParamsService>(pub Arc<T>);
7181                    impl<
7182                        T: SystemParamsService,
7183                    > tonic::server::UnaryService<super::SetSystemParamRequest>
7184                    for SetSystemParamSvc<T> {
7185                        type Response = super::SetSystemParamResponse;
7186                        type Future = BoxFuture<
7187                            tonic::Response<Self::Response>,
7188                            tonic::Status,
7189                        >;
7190                        fn call(
7191                            &mut self,
7192                            request: tonic::Request<super::SetSystemParamRequest>,
7193                        ) -> Self::Future {
7194                            let inner = Arc::clone(&self.0);
7195                            let fut = async move {
7196                                <T as SystemParamsService>::set_system_param(
7197                                        &inner,
7198                                        request,
7199                                    )
7200                                    .await
7201                            };
7202                            Box::pin(fut)
7203                        }
7204                    }
7205                    let accept_compression_encodings = self.accept_compression_encodings;
7206                    let send_compression_encodings = self.send_compression_encodings;
7207                    let max_decoding_message_size = self.max_decoding_message_size;
7208                    let max_encoding_message_size = self.max_encoding_message_size;
7209                    let inner = self.inner.clone();
7210                    let fut = async move {
7211                        let method = SetSystemParamSvc(inner);
7212                        let codec = tonic_prost::ProstCodec::default();
7213                        let mut grpc = tonic::server::Grpc::new(codec)
7214                            .apply_compression_config(
7215                                accept_compression_encodings,
7216                                send_compression_encodings,
7217                            )
7218                            .apply_max_message_size_config(
7219                                max_decoding_message_size,
7220                                max_encoding_message_size,
7221                            );
7222                        let res = grpc.unary(method, req).await;
7223                        Ok(res)
7224                    };
7225                    Box::pin(fut)
7226                }
7227                _ => {
7228                    Box::pin(async move {
7229                        let mut response = http::Response::new(
7230                            tonic::body::Body::default(),
7231                        );
7232                        let headers = response.headers_mut();
7233                        headers
7234                            .insert(
7235                                tonic::Status::GRPC_STATUS,
7236                                (tonic::Code::Unimplemented as i32).into(),
7237                            );
7238                        headers
7239                            .insert(
7240                                http::header::CONTENT_TYPE,
7241                                tonic::metadata::GRPC_CONTENT_TYPE,
7242                            );
7243                        Ok(response)
7244                    })
7245                }
7246            }
7247        }
7248    }
7249    impl<T> Clone for SystemParamsServiceServer<T> {
7250        fn clone(&self) -> Self {
7251            let inner = self.inner.clone();
7252            Self {
7253                inner,
7254                accept_compression_encodings: self.accept_compression_encodings,
7255                send_compression_encodings: self.send_compression_encodings,
7256                max_decoding_message_size: self.max_decoding_message_size,
7257                max_encoding_message_size: self.max_encoding_message_size,
7258            }
7259        }
7260    }
7261    /// Generated gRPC service name
7262    pub const SERVICE_NAME: &str = "meta.SystemParamsService";
7263    impl<T> tonic::server::NamedService for SystemParamsServiceServer<T> {
7264        const NAME: &'static str = SERVICE_NAME;
7265    }
7266}
7267/// Generated client implementations.
7268pub mod session_param_service_client {
7269    #![allow(
7270        unused_variables,
7271        dead_code,
7272        missing_docs,
7273        clippy::wildcard_imports,
7274        clippy::let_unit_value,
7275    )]
7276    use tonic::codegen::*;
7277    use tonic::codegen::http::Uri;
7278    /// Used for alter system wide default parameters
7279    #[derive(Debug, Clone)]
7280    pub struct SessionParamServiceClient<T> {
7281        inner: tonic::client::Grpc<T>,
7282    }
7283    impl SessionParamServiceClient<tonic::transport::Channel> {
7284        /// Attempt to create a new client by connecting to a given endpoint.
7285        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
7286        where
7287            D: TryInto<tonic::transport::Endpoint>,
7288            D::Error: Into<StdError>,
7289        {
7290            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
7291            Ok(Self::new(conn))
7292        }
7293    }
7294    impl<T> SessionParamServiceClient<T>
7295    where
7296        T: tonic::client::GrpcService<tonic::body::Body>,
7297        T::Error: Into<StdError>,
7298        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
7299        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
7300    {
7301        pub fn new(inner: T) -> Self {
7302            let inner = tonic::client::Grpc::new(inner);
7303            Self { inner }
7304        }
7305        pub fn with_origin(inner: T, origin: Uri) -> Self {
7306            let inner = tonic::client::Grpc::with_origin(inner, origin);
7307            Self { inner }
7308        }
7309        pub fn with_interceptor<F>(
7310            inner: T,
7311            interceptor: F,
7312        ) -> SessionParamServiceClient<InterceptedService<T, F>>
7313        where
7314            F: tonic::service::Interceptor,
7315            T::ResponseBody: Default,
7316            T: tonic::codegen::Service<
7317                http::Request<tonic::body::Body>,
7318                Response = http::Response<
7319                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
7320                >,
7321            >,
7322            <T as tonic::codegen::Service<
7323                http::Request<tonic::body::Body>,
7324            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
7325        {
7326            SessionParamServiceClient::new(InterceptedService::new(inner, interceptor))
7327        }
7328        /// Compress requests with the given encoding.
7329        ///
7330        /// This requires the server to support it otherwise it might respond with an
7331        /// error.
7332        #[must_use]
7333        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
7334            self.inner = self.inner.send_compressed(encoding);
7335            self
7336        }
7337        /// Enable decompressing responses.
7338        #[must_use]
7339        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
7340            self.inner = self.inner.accept_compressed(encoding);
7341            self
7342        }
7343        /// Limits the maximum size of a decoded message.
7344        ///
7345        /// Default: `4MB`
7346        #[must_use]
7347        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
7348            self.inner = self.inner.max_decoding_message_size(limit);
7349            self
7350        }
7351        /// Limits the maximum size of an encoded message.
7352        ///
7353        /// Default: `usize::MAX`
7354        #[must_use]
7355        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
7356            self.inner = self.inner.max_encoding_message_size(limit);
7357            self
7358        }
7359        pub async fn get_session_params(
7360            &mut self,
7361            request: impl tonic::IntoRequest<super::GetSessionParamsRequest>,
7362        ) -> std::result::Result<
7363            tonic::Response<super::GetSessionParamsResponse>,
7364            tonic::Status,
7365        > {
7366            self.inner
7367                .ready()
7368                .await
7369                .map_err(|e| {
7370                    tonic::Status::unknown(
7371                        format!("Service was not ready: {}", e.into()),
7372                    )
7373                })?;
7374            let codec = tonic_prost::ProstCodec::default();
7375            let path = http::uri::PathAndQuery::from_static(
7376                "/meta.SessionParamService/GetSessionParams",
7377            );
7378            let mut req = request.into_request();
7379            req.extensions_mut()
7380                .insert(GrpcMethod::new("meta.SessionParamService", "GetSessionParams"));
7381            self.inner.unary(req, path, codec).await
7382        }
7383        pub async fn set_session_param(
7384            &mut self,
7385            request: impl tonic::IntoRequest<super::SetSessionParamRequest>,
7386        ) -> std::result::Result<
7387            tonic::Response<super::SetSessionParamResponse>,
7388            tonic::Status,
7389        > {
7390            self.inner
7391                .ready()
7392                .await
7393                .map_err(|e| {
7394                    tonic::Status::unknown(
7395                        format!("Service was not ready: {}", e.into()),
7396                    )
7397                })?;
7398            let codec = tonic_prost::ProstCodec::default();
7399            let path = http::uri::PathAndQuery::from_static(
7400                "/meta.SessionParamService/SetSessionParam",
7401            );
7402            let mut req = request.into_request();
7403            req.extensions_mut()
7404                .insert(GrpcMethod::new("meta.SessionParamService", "SetSessionParam"));
7405            self.inner.unary(req, path, codec).await
7406        }
7407    }
7408}
7409/// Generated server implementations.
7410pub mod session_param_service_server {
7411    #![allow(
7412        unused_variables,
7413        dead_code,
7414        missing_docs,
7415        clippy::wildcard_imports,
7416        clippy::let_unit_value,
7417    )]
7418    use tonic::codegen::*;
7419    /// Generated trait containing gRPC methods that should be implemented for use with SessionParamServiceServer.
7420    #[async_trait]
7421    pub trait SessionParamService: std::marker::Send + std::marker::Sync + 'static {
7422        async fn get_session_params(
7423            &self,
7424            request: tonic::Request<super::GetSessionParamsRequest>,
7425        ) -> std::result::Result<
7426            tonic::Response<super::GetSessionParamsResponse>,
7427            tonic::Status,
7428        >;
7429        async fn set_session_param(
7430            &self,
7431            request: tonic::Request<super::SetSessionParamRequest>,
7432        ) -> std::result::Result<
7433            tonic::Response<super::SetSessionParamResponse>,
7434            tonic::Status,
7435        >;
7436    }
7437    /// Used for alter system wide default parameters
7438    #[derive(Debug)]
7439    pub struct SessionParamServiceServer<T> {
7440        inner: Arc<T>,
7441        accept_compression_encodings: EnabledCompressionEncodings,
7442        send_compression_encodings: EnabledCompressionEncodings,
7443        max_decoding_message_size: Option<usize>,
7444        max_encoding_message_size: Option<usize>,
7445    }
7446    impl<T> SessionParamServiceServer<T> {
7447        pub fn new(inner: T) -> Self {
7448            Self::from_arc(Arc::new(inner))
7449        }
7450        pub fn from_arc(inner: Arc<T>) -> Self {
7451            Self {
7452                inner,
7453                accept_compression_encodings: Default::default(),
7454                send_compression_encodings: Default::default(),
7455                max_decoding_message_size: None,
7456                max_encoding_message_size: None,
7457            }
7458        }
7459        pub fn with_interceptor<F>(
7460            inner: T,
7461            interceptor: F,
7462        ) -> InterceptedService<Self, F>
7463        where
7464            F: tonic::service::Interceptor,
7465        {
7466            InterceptedService::new(Self::new(inner), interceptor)
7467        }
7468        /// Enable decompressing requests with the given encoding.
7469        #[must_use]
7470        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
7471            self.accept_compression_encodings.enable(encoding);
7472            self
7473        }
7474        /// Compress responses with the given encoding, if the client supports it.
7475        #[must_use]
7476        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
7477            self.send_compression_encodings.enable(encoding);
7478            self
7479        }
7480        /// Limits the maximum size of a decoded message.
7481        ///
7482        /// Default: `4MB`
7483        #[must_use]
7484        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
7485            self.max_decoding_message_size = Some(limit);
7486            self
7487        }
7488        /// Limits the maximum size of an encoded message.
7489        ///
7490        /// Default: `usize::MAX`
7491        #[must_use]
7492        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
7493            self.max_encoding_message_size = Some(limit);
7494            self
7495        }
7496    }
7497    impl<T, B> tonic::codegen::Service<http::Request<B>> for SessionParamServiceServer<T>
7498    where
7499        T: SessionParamService,
7500        B: Body + std::marker::Send + 'static,
7501        B::Error: Into<StdError> + std::marker::Send + 'static,
7502    {
7503        type Response = http::Response<tonic::body::Body>;
7504        type Error = std::convert::Infallible;
7505        type Future = BoxFuture<Self::Response, Self::Error>;
7506        fn poll_ready(
7507            &mut self,
7508            _cx: &mut Context<'_>,
7509        ) -> Poll<std::result::Result<(), Self::Error>> {
7510            Poll::Ready(Ok(()))
7511        }
7512        fn call(&mut self, req: http::Request<B>) -> Self::Future {
7513            match req.uri().path() {
7514                "/meta.SessionParamService/GetSessionParams" => {
7515                    #[allow(non_camel_case_types)]
7516                    struct GetSessionParamsSvc<T: SessionParamService>(pub Arc<T>);
7517                    impl<
7518                        T: SessionParamService,
7519                    > tonic::server::UnaryService<super::GetSessionParamsRequest>
7520                    for GetSessionParamsSvc<T> {
7521                        type Response = super::GetSessionParamsResponse;
7522                        type Future = BoxFuture<
7523                            tonic::Response<Self::Response>,
7524                            tonic::Status,
7525                        >;
7526                        fn call(
7527                            &mut self,
7528                            request: tonic::Request<super::GetSessionParamsRequest>,
7529                        ) -> Self::Future {
7530                            let inner = Arc::clone(&self.0);
7531                            let fut = async move {
7532                                <T as SessionParamService>::get_session_params(
7533                                        &inner,
7534                                        request,
7535                                    )
7536                                    .await
7537                            };
7538                            Box::pin(fut)
7539                        }
7540                    }
7541                    let accept_compression_encodings = self.accept_compression_encodings;
7542                    let send_compression_encodings = self.send_compression_encodings;
7543                    let max_decoding_message_size = self.max_decoding_message_size;
7544                    let max_encoding_message_size = self.max_encoding_message_size;
7545                    let inner = self.inner.clone();
7546                    let fut = async move {
7547                        let method = GetSessionParamsSvc(inner);
7548                        let codec = tonic_prost::ProstCodec::default();
7549                        let mut grpc = tonic::server::Grpc::new(codec)
7550                            .apply_compression_config(
7551                                accept_compression_encodings,
7552                                send_compression_encodings,
7553                            )
7554                            .apply_max_message_size_config(
7555                                max_decoding_message_size,
7556                                max_encoding_message_size,
7557                            );
7558                        let res = grpc.unary(method, req).await;
7559                        Ok(res)
7560                    };
7561                    Box::pin(fut)
7562                }
7563                "/meta.SessionParamService/SetSessionParam" => {
7564                    #[allow(non_camel_case_types)]
7565                    struct SetSessionParamSvc<T: SessionParamService>(pub Arc<T>);
7566                    impl<
7567                        T: SessionParamService,
7568                    > tonic::server::UnaryService<super::SetSessionParamRequest>
7569                    for SetSessionParamSvc<T> {
7570                        type Response = super::SetSessionParamResponse;
7571                        type Future = BoxFuture<
7572                            tonic::Response<Self::Response>,
7573                            tonic::Status,
7574                        >;
7575                        fn call(
7576                            &mut self,
7577                            request: tonic::Request<super::SetSessionParamRequest>,
7578                        ) -> Self::Future {
7579                            let inner = Arc::clone(&self.0);
7580                            let fut = async move {
7581                                <T as SessionParamService>::set_session_param(
7582                                        &inner,
7583                                        request,
7584                                    )
7585                                    .await
7586                            };
7587                            Box::pin(fut)
7588                        }
7589                    }
7590                    let accept_compression_encodings = self.accept_compression_encodings;
7591                    let send_compression_encodings = self.send_compression_encodings;
7592                    let max_decoding_message_size = self.max_decoding_message_size;
7593                    let max_encoding_message_size = self.max_encoding_message_size;
7594                    let inner = self.inner.clone();
7595                    let fut = async move {
7596                        let method = SetSessionParamSvc(inner);
7597                        let codec = tonic_prost::ProstCodec::default();
7598                        let mut grpc = tonic::server::Grpc::new(codec)
7599                            .apply_compression_config(
7600                                accept_compression_encodings,
7601                                send_compression_encodings,
7602                            )
7603                            .apply_max_message_size_config(
7604                                max_decoding_message_size,
7605                                max_encoding_message_size,
7606                            );
7607                        let res = grpc.unary(method, req).await;
7608                        Ok(res)
7609                    };
7610                    Box::pin(fut)
7611                }
7612                _ => {
7613                    Box::pin(async move {
7614                        let mut response = http::Response::new(
7615                            tonic::body::Body::default(),
7616                        );
7617                        let headers = response.headers_mut();
7618                        headers
7619                            .insert(
7620                                tonic::Status::GRPC_STATUS,
7621                                (tonic::Code::Unimplemented as i32).into(),
7622                            );
7623                        headers
7624                            .insert(
7625                                http::header::CONTENT_TYPE,
7626                                tonic::metadata::GRPC_CONTENT_TYPE,
7627                            );
7628                        Ok(response)
7629                    })
7630                }
7631            }
7632        }
7633    }
7634    impl<T> Clone for SessionParamServiceServer<T> {
7635        fn clone(&self) -> Self {
7636            let inner = self.inner.clone();
7637            Self {
7638                inner,
7639                accept_compression_encodings: self.accept_compression_encodings,
7640                send_compression_encodings: self.send_compression_encodings,
7641                max_decoding_message_size: self.max_decoding_message_size,
7642                max_encoding_message_size: self.max_encoding_message_size,
7643            }
7644        }
7645    }
7646    /// Generated gRPC service name
7647    pub const SERVICE_NAME: &str = "meta.SessionParamService";
7648    impl<T> tonic::server::NamedService for SessionParamServiceServer<T> {
7649        const NAME: &'static str = SERVICE_NAME;
7650    }
7651}
7652/// Generated client implementations.
7653pub mod serving_service_client {
7654    #![allow(
7655        unused_variables,
7656        dead_code,
7657        missing_docs,
7658        clippy::wildcard_imports,
7659        clippy::let_unit_value,
7660    )]
7661    use tonic::codegen::*;
7662    use tonic::codegen::http::Uri;
7663    #[derive(Debug, Clone)]
7664    pub struct ServingServiceClient<T> {
7665        inner: tonic::client::Grpc<T>,
7666    }
7667    impl ServingServiceClient<tonic::transport::Channel> {
7668        /// Attempt to create a new client by connecting to a given endpoint.
7669        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
7670        where
7671            D: TryInto<tonic::transport::Endpoint>,
7672            D::Error: Into<StdError>,
7673        {
7674            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
7675            Ok(Self::new(conn))
7676        }
7677    }
7678    impl<T> ServingServiceClient<T>
7679    where
7680        T: tonic::client::GrpcService<tonic::body::Body>,
7681        T::Error: Into<StdError>,
7682        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
7683        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
7684    {
7685        pub fn new(inner: T) -> Self {
7686            let inner = tonic::client::Grpc::new(inner);
7687            Self { inner }
7688        }
7689        pub fn with_origin(inner: T, origin: Uri) -> Self {
7690            let inner = tonic::client::Grpc::with_origin(inner, origin);
7691            Self { inner }
7692        }
7693        pub fn with_interceptor<F>(
7694            inner: T,
7695            interceptor: F,
7696        ) -> ServingServiceClient<InterceptedService<T, F>>
7697        where
7698            F: tonic::service::Interceptor,
7699            T::ResponseBody: Default,
7700            T: tonic::codegen::Service<
7701                http::Request<tonic::body::Body>,
7702                Response = http::Response<
7703                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
7704                >,
7705            >,
7706            <T as tonic::codegen::Service<
7707                http::Request<tonic::body::Body>,
7708            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
7709        {
7710            ServingServiceClient::new(InterceptedService::new(inner, interceptor))
7711        }
7712        /// Compress requests with the given encoding.
7713        ///
7714        /// This requires the server to support it otherwise it might respond with an
7715        /// error.
7716        #[must_use]
7717        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
7718            self.inner = self.inner.send_compressed(encoding);
7719            self
7720        }
7721        /// Enable decompressing responses.
7722        #[must_use]
7723        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
7724            self.inner = self.inner.accept_compressed(encoding);
7725            self
7726        }
7727        /// Limits the maximum size of a decoded message.
7728        ///
7729        /// Default: `4MB`
7730        #[must_use]
7731        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
7732            self.inner = self.inner.max_decoding_message_size(limit);
7733            self
7734        }
7735        /// Limits the maximum size of an encoded message.
7736        ///
7737        /// Default: `usize::MAX`
7738        #[must_use]
7739        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
7740            self.inner = self.inner.max_encoding_message_size(limit);
7741            self
7742        }
7743        pub async fn get_serving_vnode_mappings(
7744            &mut self,
7745            request: impl tonic::IntoRequest<super::GetServingVnodeMappingsRequest>,
7746        ) -> std::result::Result<
7747            tonic::Response<super::GetServingVnodeMappingsResponse>,
7748            tonic::Status,
7749        > {
7750            self.inner
7751                .ready()
7752                .await
7753                .map_err(|e| {
7754                    tonic::Status::unknown(
7755                        format!("Service was not ready: {}", e.into()),
7756                    )
7757                })?;
7758            let codec = tonic_prost::ProstCodec::default();
7759            let path = http::uri::PathAndQuery::from_static(
7760                "/meta.ServingService/GetServingVnodeMappings",
7761            );
7762            let mut req = request.into_request();
7763            req.extensions_mut()
7764                .insert(
7765                    GrpcMethod::new("meta.ServingService", "GetServingVnodeMappings"),
7766                );
7767            self.inner.unary(req, path, codec).await
7768        }
7769    }
7770}
7771/// Generated server implementations.
7772pub mod serving_service_server {
7773    #![allow(
7774        unused_variables,
7775        dead_code,
7776        missing_docs,
7777        clippy::wildcard_imports,
7778        clippy::let_unit_value,
7779    )]
7780    use tonic::codegen::*;
7781    /// Generated trait containing gRPC methods that should be implemented for use with ServingServiceServer.
7782    #[async_trait]
7783    pub trait ServingService: std::marker::Send + std::marker::Sync + 'static {
7784        async fn get_serving_vnode_mappings(
7785            &self,
7786            request: tonic::Request<super::GetServingVnodeMappingsRequest>,
7787        ) -> std::result::Result<
7788            tonic::Response<super::GetServingVnodeMappingsResponse>,
7789            tonic::Status,
7790        >;
7791    }
7792    #[derive(Debug)]
7793    pub struct ServingServiceServer<T> {
7794        inner: Arc<T>,
7795        accept_compression_encodings: EnabledCompressionEncodings,
7796        send_compression_encodings: EnabledCompressionEncodings,
7797        max_decoding_message_size: Option<usize>,
7798        max_encoding_message_size: Option<usize>,
7799    }
7800    impl<T> ServingServiceServer<T> {
7801        pub fn new(inner: T) -> Self {
7802            Self::from_arc(Arc::new(inner))
7803        }
7804        pub fn from_arc(inner: Arc<T>) -> Self {
7805            Self {
7806                inner,
7807                accept_compression_encodings: Default::default(),
7808                send_compression_encodings: Default::default(),
7809                max_decoding_message_size: None,
7810                max_encoding_message_size: None,
7811            }
7812        }
7813        pub fn with_interceptor<F>(
7814            inner: T,
7815            interceptor: F,
7816        ) -> InterceptedService<Self, F>
7817        where
7818            F: tonic::service::Interceptor,
7819        {
7820            InterceptedService::new(Self::new(inner), interceptor)
7821        }
7822        /// Enable decompressing requests with the given encoding.
7823        #[must_use]
7824        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
7825            self.accept_compression_encodings.enable(encoding);
7826            self
7827        }
7828        /// Compress responses with the given encoding, if the client supports it.
7829        #[must_use]
7830        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
7831            self.send_compression_encodings.enable(encoding);
7832            self
7833        }
7834        /// Limits the maximum size of a decoded message.
7835        ///
7836        /// Default: `4MB`
7837        #[must_use]
7838        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
7839            self.max_decoding_message_size = Some(limit);
7840            self
7841        }
7842        /// Limits the maximum size of an encoded message.
7843        ///
7844        /// Default: `usize::MAX`
7845        #[must_use]
7846        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
7847            self.max_encoding_message_size = Some(limit);
7848            self
7849        }
7850    }
7851    impl<T, B> tonic::codegen::Service<http::Request<B>> for ServingServiceServer<T>
7852    where
7853        T: ServingService,
7854        B: Body + std::marker::Send + 'static,
7855        B::Error: Into<StdError> + std::marker::Send + 'static,
7856    {
7857        type Response = http::Response<tonic::body::Body>;
7858        type Error = std::convert::Infallible;
7859        type Future = BoxFuture<Self::Response, Self::Error>;
7860        fn poll_ready(
7861            &mut self,
7862            _cx: &mut Context<'_>,
7863        ) -> Poll<std::result::Result<(), Self::Error>> {
7864            Poll::Ready(Ok(()))
7865        }
7866        fn call(&mut self, req: http::Request<B>) -> Self::Future {
7867            match req.uri().path() {
7868                "/meta.ServingService/GetServingVnodeMappings" => {
7869                    #[allow(non_camel_case_types)]
7870                    struct GetServingVnodeMappingsSvc<T: ServingService>(pub Arc<T>);
7871                    impl<
7872                        T: ServingService,
7873                    > tonic::server::UnaryService<super::GetServingVnodeMappingsRequest>
7874                    for GetServingVnodeMappingsSvc<T> {
7875                        type Response = super::GetServingVnodeMappingsResponse;
7876                        type Future = BoxFuture<
7877                            tonic::Response<Self::Response>,
7878                            tonic::Status,
7879                        >;
7880                        fn call(
7881                            &mut self,
7882                            request: tonic::Request<
7883                                super::GetServingVnodeMappingsRequest,
7884                            >,
7885                        ) -> Self::Future {
7886                            let inner = Arc::clone(&self.0);
7887                            let fut = async move {
7888                                <T as ServingService>::get_serving_vnode_mappings(
7889                                        &inner,
7890                                        request,
7891                                    )
7892                                    .await
7893                            };
7894                            Box::pin(fut)
7895                        }
7896                    }
7897                    let accept_compression_encodings = self.accept_compression_encodings;
7898                    let send_compression_encodings = self.send_compression_encodings;
7899                    let max_decoding_message_size = self.max_decoding_message_size;
7900                    let max_encoding_message_size = self.max_encoding_message_size;
7901                    let inner = self.inner.clone();
7902                    let fut = async move {
7903                        let method = GetServingVnodeMappingsSvc(inner);
7904                        let codec = tonic_prost::ProstCodec::default();
7905                        let mut grpc = tonic::server::Grpc::new(codec)
7906                            .apply_compression_config(
7907                                accept_compression_encodings,
7908                                send_compression_encodings,
7909                            )
7910                            .apply_max_message_size_config(
7911                                max_decoding_message_size,
7912                                max_encoding_message_size,
7913                            );
7914                        let res = grpc.unary(method, req).await;
7915                        Ok(res)
7916                    };
7917                    Box::pin(fut)
7918                }
7919                _ => {
7920                    Box::pin(async move {
7921                        let mut response = http::Response::new(
7922                            tonic::body::Body::default(),
7923                        );
7924                        let headers = response.headers_mut();
7925                        headers
7926                            .insert(
7927                                tonic::Status::GRPC_STATUS,
7928                                (tonic::Code::Unimplemented as i32).into(),
7929                            );
7930                        headers
7931                            .insert(
7932                                http::header::CONTENT_TYPE,
7933                                tonic::metadata::GRPC_CONTENT_TYPE,
7934                            );
7935                        Ok(response)
7936                    })
7937                }
7938            }
7939        }
7940    }
7941    impl<T> Clone for ServingServiceServer<T> {
7942        fn clone(&self) -> Self {
7943            let inner = self.inner.clone();
7944            Self {
7945                inner,
7946                accept_compression_encodings: self.accept_compression_encodings,
7947                send_compression_encodings: self.send_compression_encodings,
7948                max_decoding_message_size: self.max_decoding_message_size,
7949                max_encoding_message_size: self.max_encoding_message_size,
7950            }
7951        }
7952    }
7953    /// Generated gRPC service name
7954    pub const SERVICE_NAME: &str = "meta.ServingService";
7955    impl<T> tonic::server::NamedService for ServingServiceServer<T> {
7956        const NAME: &'static str = SERVICE_NAME;
7957    }
7958}
7959/// Generated client implementations.
7960pub mod event_log_service_client {
7961    #![allow(
7962        unused_variables,
7963        dead_code,
7964        missing_docs,
7965        clippy::wildcard_imports,
7966        clippy::let_unit_value,
7967    )]
7968    use tonic::codegen::*;
7969    use tonic::codegen::http::Uri;
7970    #[derive(Debug, Clone)]
7971    pub struct EventLogServiceClient<T> {
7972        inner: tonic::client::Grpc<T>,
7973    }
7974    impl EventLogServiceClient<tonic::transport::Channel> {
7975        /// Attempt to create a new client by connecting to a given endpoint.
7976        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
7977        where
7978            D: TryInto<tonic::transport::Endpoint>,
7979            D::Error: Into<StdError>,
7980        {
7981            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
7982            Ok(Self::new(conn))
7983        }
7984    }
7985    impl<T> EventLogServiceClient<T>
7986    where
7987        T: tonic::client::GrpcService<tonic::body::Body>,
7988        T::Error: Into<StdError>,
7989        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
7990        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
7991    {
7992        pub fn new(inner: T) -> Self {
7993            let inner = tonic::client::Grpc::new(inner);
7994            Self { inner }
7995        }
7996        pub fn with_origin(inner: T, origin: Uri) -> Self {
7997            let inner = tonic::client::Grpc::with_origin(inner, origin);
7998            Self { inner }
7999        }
8000        pub fn with_interceptor<F>(
8001            inner: T,
8002            interceptor: F,
8003        ) -> EventLogServiceClient<InterceptedService<T, F>>
8004        where
8005            F: tonic::service::Interceptor,
8006            T::ResponseBody: Default,
8007            T: tonic::codegen::Service<
8008                http::Request<tonic::body::Body>,
8009                Response = http::Response<
8010                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
8011                >,
8012            >,
8013            <T as tonic::codegen::Service<
8014                http::Request<tonic::body::Body>,
8015            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
8016        {
8017            EventLogServiceClient::new(InterceptedService::new(inner, interceptor))
8018        }
8019        /// Compress requests with the given encoding.
8020        ///
8021        /// This requires the server to support it otherwise it might respond with an
8022        /// error.
8023        #[must_use]
8024        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
8025            self.inner = self.inner.send_compressed(encoding);
8026            self
8027        }
8028        /// Enable decompressing responses.
8029        #[must_use]
8030        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
8031            self.inner = self.inner.accept_compressed(encoding);
8032            self
8033        }
8034        /// Limits the maximum size of a decoded message.
8035        ///
8036        /// Default: `4MB`
8037        #[must_use]
8038        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
8039            self.inner = self.inner.max_decoding_message_size(limit);
8040            self
8041        }
8042        /// Limits the maximum size of an encoded message.
8043        ///
8044        /// Default: `usize::MAX`
8045        #[must_use]
8046        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
8047            self.inner = self.inner.max_encoding_message_size(limit);
8048            self
8049        }
8050        pub async fn list_event_log(
8051            &mut self,
8052            request: impl tonic::IntoRequest<super::ListEventLogRequest>,
8053        ) -> std::result::Result<
8054            tonic::Response<super::ListEventLogResponse>,
8055            tonic::Status,
8056        > {
8057            self.inner
8058                .ready()
8059                .await
8060                .map_err(|e| {
8061                    tonic::Status::unknown(
8062                        format!("Service was not ready: {}", e.into()),
8063                    )
8064                })?;
8065            let codec = tonic_prost::ProstCodec::default();
8066            let path = http::uri::PathAndQuery::from_static(
8067                "/meta.EventLogService/ListEventLog",
8068            );
8069            let mut req = request.into_request();
8070            req.extensions_mut()
8071                .insert(GrpcMethod::new("meta.EventLogService", "ListEventLog"));
8072            self.inner.unary(req, path, codec).await
8073        }
8074        pub async fn add_event_log(
8075            &mut self,
8076            request: impl tonic::IntoRequest<super::AddEventLogRequest>,
8077        ) -> std::result::Result<
8078            tonic::Response<super::AddEventLogResponse>,
8079            tonic::Status,
8080        > {
8081            self.inner
8082                .ready()
8083                .await
8084                .map_err(|e| {
8085                    tonic::Status::unknown(
8086                        format!("Service was not ready: {}", e.into()),
8087                    )
8088                })?;
8089            let codec = tonic_prost::ProstCodec::default();
8090            let path = http::uri::PathAndQuery::from_static(
8091                "/meta.EventLogService/AddEventLog",
8092            );
8093            let mut req = request.into_request();
8094            req.extensions_mut()
8095                .insert(GrpcMethod::new("meta.EventLogService", "AddEventLog"));
8096            self.inner.unary(req, path, codec).await
8097        }
8098    }
8099}
8100/// Generated server implementations.
8101pub mod event_log_service_server {
8102    #![allow(
8103        unused_variables,
8104        dead_code,
8105        missing_docs,
8106        clippy::wildcard_imports,
8107        clippy::let_unit_value,
8108    )]
8109    use tonic::codegen::*;
8110    /// Generated trait containing gRPC methods that should be implemented for use with EventLogServiceServer.
8111    #[async_trait]
8112    pub trait EventLogService: std::marker::Send + std::marker::Sync + 'static {
8113        async fn list_event_log(
8114            &self,
8115            request: tonic::Request<super::ListEventLogRequest>,
8116        ) -> std::result::Result<
8117            tonic::Response<super::ListEventLogResponse>,
8118            tonic::Status,
8119        >;
8120        async fn add_event_log(
8121            &self,
8122            request: tonic::Request<super::AddEventLogRequest>,
8123        ) -> std::result::Result<
8124            tonic::Response<super::AddEventLogResponse>,
8125            tonic::Status,
8126        >;
8127    }
8128    #[derive(Debug)]
8129    pub struct EventLogServiceServer<T> {
8130        inner: Arc<T>,
8131        accept_compression_encodings: EnabledCompressionEncodings,
8132        send_compression_encodings: EnabledCompressionEncodings,
8133        max_decoding_message_size: Option<usize>,
8134        max_encoding_message_size: Option<usize>,
8135    }
8136    impl<T> EventLogServiceServer<T> {
8137        pub fn new(inner: T) -> Self {
8138            Self::from_arc(Arc::new(inner))
8139        }
8140        pub fn from_arc(inner: Arc<T>) -> Self {
8141            Self {
8142                inner,
8143                accept_compression_encodings: Default::default(),
8144                send_compression_encodings: Default::default(),
8145                max_decoding_message_size: None,
8146                max_encoding_message_size: None,
8147            }
8148        }
8149        pub fn with_interceptor<F>(
8150            inner: T,
8151            interceptor: F,
8152        ) -> InterceptedService<Self, F>
8153        where
8154            F: tonic::service::Interceptor,
8155        {
8156            InterceptedService::new(Self::new(inner), interceptor)
8157        }
8158        /// Enable decompressing requests with the given encoding.
8159        #[must_use]
8160        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
8161            self.accept_compression_encodings.enable(encoding);
8162            self
8163        }
8164        /// Compress responses with the given encoding, if the client supports it.
8165        #[must_use]
8166        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
8167            self.send_compression_encodings.enable(encoding);
8168            self
8169        }
8170        /// Limits the maximum size of a decoded message.
8171        ///
8172        /// Default: `4MB`
8173        #[must_use]
8174        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
8175            self.max_decoding_message_size = Some(limit);
8176            self
8177        }
8178        /// Limits the maximum size of an encoded message.
8179        ///
8180        /// Default: `usize::MAX`
8181        #[must_use]
8182        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
8183            self.max_encoding_message_size = Some(limit);
8184            self
8185        }
8186    }
8187    impl<T, B> tonic::codegen::Service<http::Request<B>> for EventLogServiceServer<T>
8188    where
8189        T: EventLogService,
8190        B: Body + std::marker::Send + 'static,
8191        B::Error: Into<StdError> + std::marker::Send + 'static,
8192    {
8193        type Response = http::Response<tonic::body::Body>;
8194        type Error = std::convert::Infallible;
8195        type Future = BoxFuture<Self::Response, Self::Error>;
8196        fn poll_ready(
8197            &mut self,
8198            _cx: &mut Context<'_>,
8199        ) -> Poll<std::result::Result<(), Self::Error>> {
8200            Poll::Ready(Ok(()))
8201        }
8202        fn call(&mut self, req: http::Request<B>) -> Self::Future {
8203            match req.uri().path() {
8204                "/meta.EventLogService/ListEventLog" => {
8205                    #[allow(non_camel_case_types)]
8206                    struct ListEventLogSvc<T: EventLogService>(pub Arc<T>);
8207                    impl<
8208                        T: EventLogService,
8209                    > tonic::server::UnaryService<super::ListEventLogRequest>
8210                    for ListEventLogSvc<T> {
8211                        type Response = super::ListEventLogResponse;
8212                        type Future = BoxFuture<
8213                            tonic::Response<Self::Response>,
8214                            tonic::Status,
8215                        >;
8216                        fn call(
8217                            &mut self,
8218                            request: tonic::Request<super::ListEventLogRequest>,
8219                        ) -> Self::Future {
8220                            let inner = Arc::clone(&self.0);
8221                            let fut = async move {
8222                                <T as EventLogService>::list_event_log(&inner, request)
8223                                    .await
8224                            };
8225                            Box::pin(fut)
8226                        }
8227                    }
8228                    let accept_compression_encodings = self.accept_compression_encodings;
8229                    let send_compression_encodings = self.send_compression_encodings;
8230                    let max_decoding_message_size = self.max_decoding_message_size;
8231                    let max_encoding_message_size = self.max_encoding_message_size;
8232                    let inner = self.inner.clone();
8233                    let fut = async move {
8234                        let method = ListEventLogSvc(inner);
8235                        let codec = tonic_prost::ProstCodec::default();
8236                        let mut grpc = tonic::server::Grpc::new(codec)
8237                            .apply_compression_config(
8238                                accept_compression_encodings,
8239                                send_compression_encodings,
8240                            )
8241                            .apply_max_message_size_config(
8242                                max_decoding_message_size,
8243                                max_encoding_message_size,
8244                            );
8245                        let res = grpc.unary(method, req).await;
8246                        Ok(res)
8247                    };
8248                    Box::pin(fut)
8249                }
8250                "/meta.EventLogService/AddEventLog" => {
8251                    #[allow(non_camel_case_types)]
8252                    struct AddEventLogSvc<T: EventLogService>(pub Arc<T>);
8253                    impl<
8254                        T: EventLogService,
8255                    > tonic::server::UnaryService<super::AddEventLogRequest>
8256                    for AddEventLogSvc<T> {
8257                        type Response = super::AddEventLogResponse;
8258                        type Future = BoxFuture<
8259                            tonic::Response<Self::Response>,
8260                            tonic::Status,
8261                        >;
8262                        fn call(
8263                            &mut self,
8264                            request: tonic::Request<super::AddEventLogRequest>,
8265                        ) -> Self::Future {
8266                            let inner = Arc::clone(&self.0);
8267                            let fut = async move {
8268                                <T as EventLogService>::add_event_log(&inner, request).await
8269                            };
8270                            Box::pin(fut)
8271                        }
8272                    }
8273                    let accept_compression_encodings = self.accept_compression_encodings;
8274                    let send_compression_encodings = self.send_compression_encodings;
8275                    let max_decoding_message_size = self.max_decoding_message_size;
8276                    let max_encoding_message_size = self.max_encoding_message_size;
8277                    let inner = self.inner.clone();
8278                    let fut = async move {
8279                        let method = AddEventLogSvc(inner);
8280                        let codec = tonic_prost::ProstCodec::default();
8281                        let mut grpc = tonic::server::Grpc::new(codec)
8282                            .apply_compression_config(
8283                                accept_compression_encodings,
8284                                send_compression_encodings,
8285                            )
8286                            .apply_max_message_size_config(
8287                                max_decoding_message_size,
8288                                max_encoding_message_size,
8289                            );
8290                        let res = grpc.unary(method, req).await;
8291                        Ok(res)
8292                    };
8293                    Box::pin(fut)
8294                }
8295                _ => {
8296                    Box::pin(async move {
8297                        let mut response = http::Response::new(
8298                            tonic::body::Body::default(),
8299                        );
8300                        let headers = response.headers_mut();
8301                        headers
8302                            .insert(
8303                                tonic::Status::GRPC_STATUS,
8304                                (tonic::Code::Unimplemented as i32).into(),
8305                            );
8306                        headers
8307                            .insert(
8308                                http::header::CONTENT_TYPE,
8309                                tonic::metadata::GRPC_CONTENT_TYPE,
8310                            );
8311                        Ok(response)
8312                    })
8313                }
8314            }
8315        }
8316    }
8317    impl<T> Clone for EventLogServiceServer<T> {
8318        fn clone(&self) -> Self {
8319            let inner = self.inner.clone();
8320            Self {
8321                inner,
8322                accept_compression_encodings: self.accept_compression_encodings,
8323                send_compression_encodings: self.send_compression_encodings,
8324                max_decoding_message_size: self.max_decoding_message_size,
8325                max_encoding_message_size: self.max_encoding_message_size,
8326            }
8327        }
8328    }
8329    /// Generated gRPC service name
8330    pub const SERVICE_NAME: &str = "meta.EventLogService";
8331    impl<T> tonic::server::NamedService for EventLogServiceServer<T> {
8332        const NAME: &'static str = SERVICE_NAME;
8333    }
8334}
8335/// Generated client implementations.
8336pub mod cluster_limit_service_client {
8337    #![allow(
8338        unused_variables,
8339        dead_code,
8340        missing_docs,
8341        clippy::wildcard_imports,
8342        clippy::let_unit_value,
8343    )]
8344    use tonic::codegen::*;
8345    use tonic::codegen::http::Uri;
8346    #[derive(Debug, Clone)]
8347    pub struct ClusterLimitServiceClient<T> {
8348        inner: tonic::client::Grpc<T>,
8349    }
8350    impl ClusterLimitServiceClient<tonic::transport::Channel> {
8351        /// Attempt to create a new client by connecting to a given endpoint.
8352        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
8353        where
8354            D: TryInto<tonic::transport::Endpoint>,
8355            D::Error: Into<StdError>,
8356        {
8357            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
8358            Ok(Self::new(conn))
8359        }
8360    }
8361    impl<T> ClusterLimitServiceClient<T>
8362    where
8363        T: tonic::client::GrpcService<tonic::body::Body>,
8364        T::Error: Into<StdError>,
8365        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
8366        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
8367    {
8368        pub fn new(inner: T) -> Self {
8369            let inner = tonic::client::Grpc::new(inner);
8370            Self { inner }
8371        }
8372        pub fn with_origin(inner: T, origin: Uri) -> Self {
8373            let inner = tonic::client::Grpc::with_origin(inner, origin);
8374            Self { inner }
8375        }
8376        pub fn with_interceptor<F>(
8377            inner: T,
8378            interceptor: F,
8379        ) -> ClusterLimitServiceClient<InterceptedService<T, F>>
8380        where
8381            F: tonic::service::Interceptor,
8382            T::ResponseBody: Default,
8383            T: tonic::codegen::Service<
8384                http::Request<tonic::body::Body>,
8385                Response = http::Response<
8386                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
8387                >,
8388            >,
8389            <T as tonic::codegen::Service<
8390                http::Request<tonic::body::Body>,
8391            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
8392        {
8393            ClusterLimitServiceClient::new(InterceptedService::new(inner, interceptor))
8394        }
8395        /// Compress requests with the given encoding.
8396        ///
8397        /// This requires the server to support it otherwise it might respond with an
8398        /// error.
8399        #[must_use]
8400        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
8401            self.inner = self.inner.send_compressed(encoding);
8402            self
8403        }
8404        /// Enable decompressing responses.
8405        #[must_use]
8406        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
8407            self.inner = self.inner.accept_compressed(encoding);
8408            self
8409        }
8410        /// Limits the maximum size of a decoded message.
8411        ///
8412        /// Default: `4MB`
8413        #[must_use]
8414        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
8415            self.inner = self.inner.max_decoding_message_size(limit);
8416            self
8417        }
8418        /// Limits the maximum size of an encoded message.
8419        ///
8420        /// Default: `usize::MAX`
8421        #[must_use]
8422        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
8423            self.inner = self.inner.max_encoding_message_size(limit);
8424            self
8425        }
8426        pub async fn get_cluster_limits(
8427            &mut self,
8428            request: impl tonic::IntoRequest<super::GetClusterLimitsRequest>,
8429        ) -> std::result::Result<
8430            tonic::Response<super::GetClusterLimitsResponse>,
8431            tonic::Status,
8432        > {
8433            self.inner
8434                .ready()
8435                .await
8436                .map_err(|e| {
8437                    tonic::Status::unknown(
8438                        format!("Service was not ready: {}", e.into()),
8439                    )
8440                })?;
8441            let codec = tonic_prost::ProstCodec::default();
8442            let path = http::uri::PathAndQuery::from_static(
8443                "/meta.ClusterLimitService/GetClusterLimits",
8444            );
8445            let mut req = request.into_request();
8446            req.extensions_mut()
8447                .insert(GrpcMethod::new("meta.ClusterLimitService", "GetClusterLimits"));
8448            self.inner.unary(req, path, codec).await
8449        }
8450    }
8451}
8452/// Generated server implementations.
8453pub mod cluster_limit_service_server {
8454    #![allow(
8455        unused_variables,
8456        dead_code,
8457        missing_docs,
8458        clippy::wildcard_imports,
8459        clippy::let_unit_value,
8460    )]
8461    use tonic::codegen::*;
8462    /// Generated trait containing gRPC methods that should be implemented for use with ClusterLimitServiceServer.
8463    #[async_trait]
8464    pub trait ClusterLimitService: std::marker::Send + std::marker::Sync + 'static {
8465        async fn get_cluster_limits(
8466            &self,
8467            request: tonic::Request<super::GetClusterLimitsRequest>,
8468        ) -> std::result::Result<
8469            tonic::Response<super::GetClusterLimitsResponse>,
8470            tonic::Status,
8471        >;
8472    }
8473    #[derive(Debug)]
8474    pub struct ClusterLimitServiceServer<T> {
8475        inner: Arc<T>,
8476        accept_compression_encodings: EnabledCompressionEncodings,
8477        send_compression_encodings: EnabledCompressionEncodings,
8478        max_decoding_message_size: Option<usize>,
8479        max_encoding_message_size: Option<usize>,
8480    }
8481    impl<T> ClusterLimitServiceServer<T> {
8482        pub fn new(inner: T) -> Self {
8483            Self::from_arc(Arc::new(inner))
8484        }
8485        pub fn from_arc(inner: Arc<T>) -> Self {
8486            Self {
8487                inner,
8488                accept_compression_encodings: Default::default(),
8489                send_compression_encodings: Default::default(),
8490                max_decoding_message_size: None,
8491                max_encoding_message_size: None,
8492            }
8493        }
8494        pub fn with_interceptor<F>(
8495            inner: T,
8496            interceptor: F,
8497        ) -> InterceptedService<Self, F>
8498        where
8499            F: tonic::service::Interceptor,
8500        {
8501            InterceptedService::new(Self::new(inner), interceptor)
8502        }
8503        /// Enable decompressing requests with the given encoding.
8504        #[must_use]
8505        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
8506            self.accept_compression_encodings.enable(encoding);
8507            self
8508        }
8509        /// Compress responses with the given encoding, if the client supports it.
8510        #[must_use]
8511        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
8512            self.send_compression_encodings.enable(encoding);
8513            self
8514        }
8515        /// Limits the maximum size of a decoded message.
8516        ///
8517        /// Default: `4MB`
8518        #[must_use]
8519        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
8520            self.max_decoding_message_size = Some(limit);
8521            self
8522        }
8523        /// Limits the maximum size of an encoded message.
8524        ///
8525        /// Default: `usize::MAX`
8526        #[must_use]
8527        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
8528            self.max_encoding_message_size = Some(limit);
8529            self
8530        }
8531    }
8532    impl<T, B> tonic::codegen::Service<http::Request<B>> for ClusterLimitServiceServer<T>
8533    where
8534        T: ClusterLimitService,
8535        B: Body + std::marker::Send + 'static,
8536        B::Error: Into<StdError> + std::marker::Send + 'static,
8537    {
8538        type Response = http::Response<tonic::body::Body>;
8539        type Error = std::convert::Infallible;
8540        type Future = BoxFuture<Self::Response, Self::Error>;
8541        fn poll_ready(
8542            &mut self,
8543            _cx: &mut Context<'_>,
8544        ) -> Poll<std::result::Result<(), Self::Error>> {
8545            Poll::Ready(Ok(()))
8546        }
8547        fn call(&mut self, req: http::Request<B>) -> Self::Future {
8548            match req.uri().path() {
8549                "/meta.ClusterLimitService/GetClusterLimits" => {
8550                    #[allow(non_camel_case_types)]
8551                    struct GetClusterLimitsSvc<T: ClusterLimitService>(pub Arc<T>);
8552                    impl<
8553                        T: ClusterLimitService,
8554                    > tonic::server::UnaryService<super::GetClusterLimitsRequest>
8555                    for GetClusterLimitsSvc<T> {
8556                        type Response = super::GetClusterLimitsResponse;
8557                        type Future = BoxFuture<
8558                            tonic::Response<Self::Response>,
8559                            tonic::Status,
8560                        >;
8561                        fn call(
8562                            &mut self,
8563                            request: tonic::Request<super::GetClusterLimitsRequest>,
8564                        ) -> Self::Future {
8565                            let inner = Arc::clone(&self.0);
8566                            let fut = async move {
8567                                <T as ClusterLimitService>::get_cluster_limits(
8568                                        &inner,
8569                                        request,
8570                                    )
8571                                    .await
8572                            };
8573                            Box::pin(fut)
8574                        }
8575                    }
8576                    let accept_compression_encodings = self.accept_compression_encodings;
8577                    let send_compression_encodings = self.send_compression_encodings;
8578                    let max_decoding_message_size = self.max_decoding_message_size;
8579                    let max_encoding_message_size = self.max_encoding_message_size;
8580                    let inner = self.inner.clone();
8581                    let fut = async move {
8582                        let method = GetClusterLimitsSvc(inner);
8583                        let codec = tonic_prost::ProstCodec::default();
8584                        let mut grpc = tonic::server::Grpc::new(codec)
8585                            .apply_compression_config(
8586                                accept_compression_encodings,
8587                                send_compression_encodings,
8588                            )
8589                            .apply_max_message_size_config(
8590                                max_decoding_message_size,
8591                                max_encoding_message_size,
8592                            );
8593                        let res = grpc.unary(method, req).await;
8594                        Ok(res)
8595                    };
8596                    Box::pin(fut)
8597                }
8598                _ => {
8599                    Box::pin(async move {
8600                        let mut response = http::Response::new(
8601                            tonic::body::Body::default(),
8602                        );
8603                        let headers = response.headers_mut();
8604                        headers
8605                            .insert(
8606                                tonic::Status::GRPC_STATUS,
8607                                (tonic::Code::Unimplemented as i32).into(),
8608                            );
8609                        headers
8610                            .insert(
8611                                http::header::CONTENT_TYPE,
8612                                tonic::metadata::GRPC_CONTENT_TYPE,
8613                            );
8614                        Ok(response)
8615                    })
8616                }
8617            }
8618        }
8619    }
8620    impl<T> Clone for ClusterLimitServiceServer<T> {
8621        fn clone(&self) -> Self {
8622            let inner = self.inner.clone();
8623            Self {
8624                inner,
8625                accept_compression_encodings: self.accept_compression_encodings,
8626                send_compression_encodings: self.send_compression_encodings,
8627                max_decoding_message_size: self.max_decoding_message_size,
8628                max_encoding_message_size: self.max_encoding_message_size,
8629            }
8630        }
8631    }
8632    /// Generated gRPC service name
8633    pub const SERVICE_NAME: &str = "meta.ClusterLimitService";
8634    impl<T> tonic::server::NamedService for ClusterLimitServiceServer<T> {
8635        const NAME: &'static str = SERVICE_NAME;
8636    }
8637}
8638/// Generated client implementations.
8639pub mod hosted_iceberg_catalog_service_client {
8640    #![allow(
8641        unused_variables,
8642        dead_code,
8643        missing_docs,
8644        clippy::wildcard_imports,
8645        clippy::let_unit_value,
8646    )]
8647    use tonic::codegen::*;
8648    use tonic::codegen::http::Uri;
8649    #[derive(Debug, Clone)]
8650    pub struct HostedIcebergCatalogServiceClient<T> {
8651        inner: tonic::client::Grpc<T>,
8652    }
8653    impl HostedIcebergCatalogServiceClient<tonic::transport::Channel> {
8654        /// Attempt to create a new client by connecting to a given endpoint.
8655        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
8656        where
8657            D: TryInto<tonic::transport::Endpoint>,
8658            D::Error: Into<StdError>,
8659        {
8660            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
8661            Ok(Self::new(conn))
8662        }
8663    }
8664    impl<T> HostedIcebergCatalogServiceClient<T>
8665    where
8666        T: tonic::client::GrpcService<tonic::body::Body>,
8667        T::Error: Into<StdError>,
8668        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
8669        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
8670    {
8671        pub fn new(inner: T) -> Self {
8672            let inner = tonic::client::Grpc::new(inner);
8673            Self { inner }
8674        }
8675        pub fn with_origin(inner: T, origin: Uri) -> Self {
8676            let inner = tonic::client::Grpc::with_origin(inner, origin);
8677            Self { inner }
8678        }
8679        pub fn with_interceptor<F>(
8680            inner: T,
8681            interceptor: F,
8682        ) -> HostedIcebergCatalogServiceClient<InterceptedService<T, F>>
8683        where
8684            F: tonic::service::Interceptor,
8685            T::ResponseBody: Default,
8686            T: tonic::codegen::Service<
8687                http::Request<tonic::body::Body>,
8688                Response = http::Response<
8689                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
8690                >,
8691            >,
8692            <T as tonic::codegen::Service<
8693                http::Request<tonic::body::Body>,
8694            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
8695        {
8696            HostedIcebergCatalogServiceClient::new(
8697                InterceptedService::new(inner, interceptor),
8698            )
8699        }
8700        /// Compress requests with the given encoding.
8701        ///
8702        /// This requires the server to support it otherwise it might respond with an
8703        /// error.
8704        #[must_use]
8705        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
8706            self.inner = self.inner.send_compressed(encoding);
8707            self
8708        }
8709        /// Enable decompressing responses.
8710        #[must_use]
8711        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
8712            self.inner = self.inner.accept_compressed(encoding);
8713            self
8714        }
8715        /// Limits the maximum size of a decoded message.
8716        ///
8717        /// Default: `4MB`
8718        #[must_use]
8719        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
8720            self.inner = self.inner.max_decoding_message_size(limit);
8721            self
8722        }
8723        /// Limits the maximum size of an encoded message.
8724        ///
8725        /// Default: `usize::MAX`
8726        #[must_use]
8727        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
8728            self.inner = self.inner.max_encoding_message_size(limit);
8729            self
8730        }
8731        pub async fn list_iceberg_tables(
8732            &mut self,
8733            request: impl tonic::IntoRequest<super::ListIcebergTablesRequest>,
8734        ) -> std::result::Result<
8735            tonic::Response<super::ListIcebergTablesResponse>,
8736            tonic::Status,
8737        > {
8738            self.inner
8739                .ready()
8740                .await
8741                .map_err(|e| {
8742                    tonic::Status::unknown(
8743                        format!("Service was not ready: {}", e.into()),
8744                    )
8745                })?;
8746            let codec = tonic_prost::ProstCodec::default();
8747            let path = http::uri::PathAndQuery::from_static(
8748                "/meta.HostedIcebergCatalogService/ListIcebergTables",
8749            );
8750            let mut req = request.into_request();
8751            req.extensions_mut()
8752                .insert(
8753                    GrpcMethod::new(
8754                        "meta.HostedIcebergCatalogService",
8755                        "ListIcebergTables",
8756                    ),
8757                );
8758            self.inner.unary(req, path, codec).await
8759        }
8760    }
8761}
8762/// Generated server implementations.
8763pub mod hosted_iceberg_catalog_service_server {
8764    #![allow(
8765        unused_variables,
8766        dead_code,
8767        missing_docs,
8768        clippy::wildcard_imports,
8769        clippy::let_unit_value,
8770    )]
8771    use tonic::codegen::*;
8772    /// Generated trait containing gRPC methods that should be implemented for use with HostedIcebergCatalogServiceServer.
8773    #[async_trait]
8774    pub trait HostedIcebergCatalogService: std::marker::Send + std::marker::Sync + 'static {
8775        async fn list_iceberg_tables(
8776            &self,
8777            request: tonic::Request<super::ListIcebergTablesRequest>,
8778        ) -> std::result::Result<
8779            tonic::Response<super::ListIcebergTablesResponse>,
8780            tonic::Status,
8781        >;
8782    }
8783    #[derive(Debug)]
8784    pub struct HostedIcebergCatalogServiceServer<T> {
8785        inner: Arc<T>,
8786        accept_compression_encodings: EnabledCompressionEncodings,
8787        send_compression_encodings: EnabledCompressionEncodings,
8788        max_decoding_message_size: Option<usize>,
8789        max_encoding_message_size: Option<usize>,
8790    }
8791    impl<T> HostedIcebergCatalogServiceServer<T> {
8792        pub fn new(inner: T) -> Self {
8793            Self::from_arc(Arc::new(inner))
8794        }
8795        pub fn from_arc(inner: Arc<T>) -> Self {
8796            Self {
8797                inner,
8798                accept_compression_encodings: Default::default(),
8799                send_compression_encodings: Default::default(),
8800                max_decoding_message_size: None,
8801                max_encoding_message_size: None,
8802            }
8803        }
8804        pub fn with_interceptor<F>(
8805            inner: T,
8806            interceptor: F,
8807        ) -> InterceptedService<Self, F>
8808        where
8809            F: tonic::service::Interceptor,
8810        {
8811            InterceptedService::new(Self::new(inner), interceptor)
8812        }
8813        /// Enable decompressing requests with the given encoding.
8814        #[must_use]
8815        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
8816            self.accept_compression_encodings.enable(encoding);
8817            self
8818        }
8819        /// Compress responses with the given encoding, if the client supports it.
8820        #[must_use]
8821        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
8822            self.send_compression_encodings.enable(encoding);
8823            self
8824        }
8825        /// Limits the maximum size of a decoded message.
8826        ///
8827        /// Default: `4MB`
8828        #[must_use]
8829        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
8830            self.max_decoding_message_size = Some(limit);
8831            self
8832        }
8833        /// Limits the maximum size of an encoded message.
8834        ///
8835        /// Default: `usize::MAX`
8836        #[must_use]
8837        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
8838            self.max_encoding_message_size = Some(limit);
8839            self
8840        }
8841    }
8842    impl<T, B> tonic::codegen::Service<http::Request<B>>
8843    for HostedIcebergCatalogServiceServer<T>
8844    where
8845        T: HostedIcebergCatalogService,
8846        B: Body + std::marker::Send + 'static,
8847        B::Error: Into<StdError> + std::marker::Send + 'static,
8848    {
8849        type Response = http::Response<tonic::body::Body>;
8850        type Error = std::convert::Infallible;
8851        type Future = BoxFuture<Self::Response, Self::Error>;
8852        fn poll_ready(
8853            &mut self,
8854            _cx: &mut Context<'_>,
8855        ) -> Poll<std::result::Result<(), Self::Error>> {
8856            Poll::Ready(Ok(()))
8857        }
8858        fn call(&mut self, req: http::Request<B>) -> Self::Future {
8859            match req.uri().path() {
8860                "/meta.HostedIcebergCatalogService/ListIcebergTables" => {
8861                    #[allow(non_camel_case_types)]
8862                    struct ListIcebergTablesSvc<T: HostedIcebergCatalogService>(
8863                        pub Arc<T>,
8864                    );
8865                    impl<
8866                        T: HostedIcebergCatalogService,
8867                    > tonic::server::UnaryService<super::ListIcebergTablesRequest>
8868                    for ListIcebergTablesSvc<T> {
8869                        type Response = super::ListIcebergTablesResponse;
8870                        type Future = BoxFuture<
8871                            tonic::Response<Self::Response>,
8872                            tonic::Status,
8873                        >;
8874                        fn call(
8875                            &mut self,
8876                            request: tonic::Request<super::ListIcebergTablesRequest>,
8877                        ) -> Self::Future {
8878                            let inner = Arc::clone(&self.0);
8879                            let fut = async move {
8880                                <T as HostedIcebergCatalogService>::list_iceberg_tables(
8881                                        &inner,
8882                                        request,
8883                                    )
8884                                    .await
8885                            };
8886                            Box::pin(fut)
8887                        }
8888                    }
8889                    let accept_compression_encodings = self.accept_compression_encodings;
8890                    let send_compression_encodings = self.send_compression_encodings;
8891                    let max_decoding_message_size = self.max_decoding_message_size;
8892                    let max_encoding_message_size = self.max_encoding_message_size;
8893                    let inner = self.inner.clone();
8894                    let fut = async move {
8895                        let method = ListIcebergTablesSvc(inner);
8896                        let codec = tonic_prost::ProstCodec::default();
8897                        let mut grpc = tonic::server::Grpc::new(codec)
8898                            .apply_compression_config(
8899                                accept_compression_encodings,
8900                                send_compression_encodings,
8901                            )
8902                            .apply_max_message_size_config(
8903                                max_decoding_message_size,
8904                                max_encoding_message_size,
8905                            );
8906                        let res = grpc.unary(method, req).await;
8907                        Ok(res)
8908                    };
8909                    Box::pin(fut)
8910                }
8911                _ => {
8912                    Box::pin(async move {
8913                        let mut response = http::Response::new(
8914                            tonic::body::Body::default(),
8915                        );
8916                        let headers = response.headers_mut();
8917                        headers
8918                            .insert(
8919                                tonic::Status::GRPC_STATUS,
8920                                (tonic::Code::Unimplemented as i32).into(),
8921                            );
8922                        headers
8923                            .insert(
8924                                http::header::CONTENT_TYPE,
8925                                tonic::metadata::GRPC_CONTENT_TYPE,
8926                            );
8927                        Ok(response)
8928                    })
8929                }
8930            }
8931        }
8932    }
8933    impl<T> Clone for HostedIcebergCatalogServiceServer<T> {
8934        fn clone(&self) -> Self {
8935            let inner = self.inner.clone();
8936            Self {
8937                inner,
8938                accept_compression_encodings: self.accept_compression_encodings,
8939                send_compression_encodings: self.send_compression_encodings,
8940                max_decoding_message_size: self.max_decoding_message_size,
8941                max_encoding_message_size: self.max_encoding_message_size,
8942            }
8943        }
8944    }
8945    /// Generated gRPC service name
8946    pub const SERVICE_NAME: &str = "meta.HostedIcebergCatalogService";
8947    impl<T> tonic::server::NamedService for HostedIcebergCatalogServiceServer<T> {
8948        const NAME: &'static str = SERVICE_NAME;
8949    }
8950}
risingwave_pb/meta.rs

risingwave_pb/
meta.rs
