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

risingwave_pb/
meta.rs
