risingwave_pb/
meta.rs

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

risingwave_pb/
meta.rs
