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

risingwave_pb/
meta.rs
