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

risingwave_pb/
meta.rs
