risingwave_pb/
meta.rs

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