risingwave_pb/
meta.rs

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

risingwave_pb/
meta.rs
