risingwave_pb/
meta.rs

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

risingwave_pb/
meta.rs
