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

risingwave_pb/
meta.rs
