risingwave_pb/
meta.rs

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

risingwave_pb/
meta.rs
