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