1#[derive(prost_helpers::AnyPB)]
3#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4pub struct StackTraceRequest {
5 #[prost(enumeration = "stack_trace_request::ActorTracesFormat", tag = "1")]
6 pub actor_traces_format: i32,
7}
8pub mod stack_trace_request {
10 #[derive(prost_helpers::AnyPB)]
11 #[derive(
12 Clone,
13 Copy,
14 Debug,
15 PartialEq,
16 Eq,
17 Hash,
18 PartialOrd,
19 Ord,
20 ::prost::Enumeration
21 )]
22 #[repr(i32)]
23 pub enum ActorTracesFormat {
24 Unspecified = 0,
25 Json = 1,
26 Text = 2,
27 }
28 impl ActorTracesFormat {
29 pub fn as_str_name(&self) -> &'static str {
34 match self {
35 Self::Unspecified => "UNSPECIFIED",
36 Self::Json => "JSON",
37 Self::Text => "TEXT",
38 }
39 }
40 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
42 match value {
43 "UNSPECIFIED" => Some(Self::Unspecified),
44 "JSON" => Some(Self::Json),
45 "TEXT" => Some(Self::Text),
46 _ => None,
47 }
48 }
49 }
50}
51#[derive(prost_helpers::AnyPB)]
52#[derive(Clone, PartialEq, ::prost::Message)]
53pub struct StackTraceResponse {
54 #[prost(btree_map = "uint32, string", tag = "1")]
55 pub actor_traces: ::prost::alloc::collections::BTreeMap<
56 u32,
57 ::prost::alloc::string::String,
58 >,
59 #[prost(btree_map = "string, string", tag = "2")]
60 pub rpc_traces: ::prost::alloc::collections::BTreeMap<
61 ::prost::alloc::string::String,
62 ::prost::alloc::string::String,
63 >,
64 #[prost(btree_map = "string, string", tag = "3")]
65 pub compaction_task_traces: ::prost::alloc::collections::BTreeMap<
66 ::prost::alloc::string::String,
67 ::prost::alloc::string::String,
68 >,
69 #[prost(btree_map = "uint64, string", tag = "4")]
70 pub inflight_barrier_traces: ::prost::alloc::collections::BTreeMap<
71 u64,
72 ::prost::alloc::string::String,
73 >,
74 #[prost(btree_map = "uint32, string", tag = "5")]
76 pub barrier_worker_state: ::prost::alloc::collections::BTreeMap<
77 u32,
78 ::prost::alloc::string::String,
79 >,
80 #[prost(btree_map = "uint32, string", tag = "6")]
82 pub jvm_stack_traces: ::prost::alloc::collections::BTreeMap<
83 u32,
84 ::prost::alloc::string::String,
85 >,
86 #[prost(btree_map = "string, string", tag = "7")]
87 pub meta_traces: ::prost::alloc::collections::BTreeMap<
88 ::prost::alloc::string::String,
89 ::prost::alloc::string::String,
90 >,
91}
92#[derive(prost_helpers::AnyPB)]
94#[derive(Clone, Copy, PartialEq, ::prost::Message)]
95pub struct ProfilingRequest {
96 #[prost(uint64, tag = "1")]
98 pub sleep_s: u64,
99}
100#[derive(prost_helpers::AnyPB)]
101#[derive(Clone, PartialEq, ::prost::Message)]
102pub struct ProfilingResponse {
103 #[prost(bytes = "vec", tag = "1")]
104 pub result: ::prost::alloc::vec::Vec<u8>,
105}
106#[derive(prost_helpers::AnyPB)]
108#[derive(Clone, PartialEq, ::prost::Message)]
109pub struct HeapProfilingRequest {
110 #[prost(string, tag = "1")]
112 pub dir: ::prost::alloc::string::String,
113}
114#[derive(prost_helpers::AnyPB)]
115#[derive(Clone, Copy, PartialEq, ::prost::Message)]
116pub struct HeapProfilingResponse {}
117#[derive(prost_helpers::AnyPB)]
118#[derive(Clone, Copy, PartialEq, ::prost::Message)]
119pub struct ListHeapProfilingRequest {}
120#[derive(prost_helpers::AnyPB)]
121#[derive(Clone, PartialEq, ::prost::Message)]
122pub struct ListHeapProfilingResponse {
123 #[prost(string, tag = "1")]
124 pub dir: ::prost::alloc::string::String,
125 #[prost(string, repeated, tag = "2")]
126 pub name_manually: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
127 #[prost(string, repeated, tag = "3")]
128 pub name_auto: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
129}
130#[derive(prost_helpers::AnyPB)]
132#[derive(Clone, PartialEq, ::prost::Message)]
133pub struct AnalyzeHeapRequest {
134 #[prost(string, tag = "1")]
136 pub path: ::prost::alloc::string::String,
137}
138#[derive(prost_helpers::AnyPB)]
139#[derive(Clone, PartialEq, ::prost::Message)]
140pub struct AnalyzeHeapResponse {
141 #[prost(bytes = "vec", tag = "1")]
142 pub result: ::prost::alloc::vec::Vec<u8>,
143}
144#[derive(prost_helpers::AnyPB)]
146#[derive(Clone, Copy, PartialEq, ::prost::Message)]
147pub struct GetStreamingStatsRequest {}
148#[derive(prost_helpers::AnyPB)]
149#[derive(Clone, Copy, PartialEq, ::prost::Message)]
150pub struct ChannelStats {
151 #[prost(uint32, tag = "1")]
155 pub actor_count: u32,
156 #[prost(double, tag = "2")]
158 pub output_blocking_duration: f64,
159 #[prost(uint64, tag = "3")]
161 pub recv_row_count: u64,
162 #[prost(uint64, tag = "4")]
164 pub send_row_count: u64,
165}
166#[derive(prost_helpers::AnyPB)]
167#[derive(Clone, Copy, PartialEq, ::prost::Message)]
168pub struct FragmentStats {
169 #[prost(uint32, tag = "2")]
170 pub actor_count: u32,
171 #[prost(uint64, tag = "3")]
172 pub current_epoch: u64,
173}
174#[derive(prost_helpers::AnyPB)]
175#[derive(Clone, Copy, PartialEq, ::prost::Message)]
176pub struct RelationStats {
177 #[prost(uint32, tag = "2")]
178 pub actor_count: u32,
179 #[prost(uint64, tag = "3")]
180 pub current_epoch: u64,
181}
182#[derive(prost_helpers::AnyPB)]
183#[derive(Clone, PartialEq, ::prost::Message)]
184pub struct GetStreamingStatsResponse {
185 #[prost(map = "string, message", tag = "1")]
187 pub channel_stats: ::std::collections::HashMap<
188 ::prost::alloc::string::String,
189 ChannelStats,
190 >,
191 #[prost(map = "uint32, message", tag = "2")]
192 pub fragment_stats: ::std::collections::HashMap<u32, FragmentStats>,
193 #[prost(map = "uint32, message", tag = "3")]
194 pub relation_stats: ::std::collections::HashMap<u32, RelationStats>,
195}
196#[derive(prost_helpers::AnyPB)]
197#[derive(Clone, Copy, PartialEq, ::prost::Message)]
198pub struct TieredCacheTracingRequest {
199 #[prost(bool, tag = "1")]
200 pub enable: bool,
201 #[prost(uint32, optional, tag = "2")]
202 pub record_hybrid_insert_threshold_ms: ::core::option::Option<u32>,
203 #[prost(uint32, optional, tag = "3")]
204 pub record_hybrid_get_threshold_ms: ::core::option::Option<u32>,
205 #[prost(uint32, optional, tag = "4")]
206 pub record_hybrid_obtain_threshold_ms: ::core::option::Option<u32>,
207 #[prost(uint32, optional, tag = "5")]
208 pub record_hybrid_remove_threshold_ms: ::core::option::Option<u32>,
209 #[prost(uint32, optional, tag = "6")]
210 pub record_hybrid_fetch_threshold_ms: ::core::option::Option<u32>,
211}
212#[derive(prost_helpers::AnyPB)]
213#[derive(Clone, Copy, PartialEq, ::prost::Message)]
214pub struct TieredCacheTracingResponse {}
215#[derive(prost_helpers::AnyPB)]
216#[derive(Clone, PartialEq, ::prost::Message)]
217pub struct GetProfileStatsRequest {
218 #[prost(uint64, repeated, tag = "1")]
220 pub executor_ids: ::prost::alloc::vec::Vec<u64>,
221 #[prost(uint32, repeated, tag = "2")]
224 pub dispatcher_fragment_ids: ::prost::alloc::vec::Vec<u32>,
225}
226#[derive(prost_helpers::AnyPB)]
227#[derive(Clone, PartialEq, ::prost::Message)]
228pub struct GetProfileStatsResponse {
229 #[prost(map = "uint64, uint64", tag = "1")]
230 pub stream_node_output_row_count: ::std::collections::HashMap<u64, u64>,
231 #[prost(map = "uint64, uint64", tag = "2")]
232 pub stream_node_output_blocking_duration_ns: ::std::collections::HashMap<u64, u64>,
233 #[prost(map = "uint32, uint64", tag = "3")]
234 pub dispatch_fragment_output_row_count: ::std::collections::HashMap<u32, u64>,
235 #[prost(map = "uint32, uint64", tag = "4")]
236 pub dispatch_fragment_output_blocking_duration_ns: ::std::collections::HashMap<
237 u32,
238 u64,
239 >,
240}
241pub mod monitor_service_client {
243 #![allow(
244 unused_variables,
245 dead_code,
246 missing_docs,
247 clippy::wildcard_imports,
248 clippy::let_unit_value,
249 )]
250 use tonic::codegen::*;
251 use tonic::codegen::http::Uri;
252 #[derive(Debug, Clone)]
253 pub struct MonitorServiceClient<T> {
254 inner: tonic::client::Grpc<T>,
255 }
256 impl MonitorServiceClient<tonic::transport::Channel> {
257 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
259 where
260 D: TryInto<tonic::transport::Endpoint>,
261 D::Error: Into<StdError>,
262 {
263 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
264 Ok(Self::new(conn))
265 }
266 }
267 impl<T> MonitorServiceClient<T>
268 where
269 T: tonic::client::GrpcService<tonic::body::BoxBody>,
270 T::Error: Into<StdError>,
271 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
272 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
273 {
274 pub fn new(inner: T) -> Self {
275 let inner = tonic::client::Grpc::new(inner);
276 Self { inner }
277 }
278 pub fn with_origin(inner: T, origin: Uri) -> Self {
279 let inner = tonic::client::Grpc::with_origin(inner, origin);
280 Self { inner }
281 }
282 pub fn with_interceptor<F>(
283 inner: T,
284 interceptor: F,
285 ) -> MonitorServiceClient<InterceptedService<T, F>>
286 where
287 F: tonic::service::Interceptor,
288 T::ResponseBody: Default,
289 T: tonic::codegen::Service<
290 http::Request<tonic::body::BoxBody>,
291 Response = http::Response<
292 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
293 >,
294 >,
295 <T as tonic::codegen::Service<
296 http::Request<tonic::body::BoxBody>,
297 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
298 {
299 MonitorServiceClient::new(InterceptedService::new(inner, interceptor))
300 }
301 #[must_use]
306 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
307 self.inner = self.inner.send_compressed(encoding);
308 self
309 }
310 #[must_use]
312 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
313 self.inner = self.inner.accept_compressed(encoding);
314 self
315 }
316 #[must_use]
320 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
321 self.inner = self.inner.max_decoding_message_size(limit);
322 self
323 }
324 #[must_use]
328 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
329 self.inner = self.inner.max_encoding_message_size(limit);
330 self
331 }
332 pub async fn stack_trace(
333 &mut self,
334 request: impl tonic::IntoRequest<super::StackTraceRequest>,
335 ) -> std::result::Result<
336 tonic::Response<super::StackTraceResponse>,
337 tonic::Status,
338 > {
339 self.inner
340 .ready()
341 .await
342 .map_err(|e| {
343 tonic::Status::unknown(
344 format!("Service was not ready: {}", e.into()),
345 )
346 })?;
347 let codec = tonic::codec::ProstCodec::default();
348 let path = http::uri::PathAndQuery::from_static(
349 "/monitor_service.MonitorService/StackTrace",
350 );
351 let mut req = request.into_request();
352 req.extensions_mut()
353 .insert(GrpcMethod::new("monitor_service.MonitorService", "StackTrace"));
354 self.inner.unary(req, path, codec).await
355 }
356 pub async fn profiling(
357 &mut self,
358 request: impl tonic::IntoRequest<super::ProfilingRequest>,
359 ) -> std::result::Result<
360 tonic::Response<super::ProfilingResponse>,
361 tonic::Status,
362 > {
363 self.inner
364 .ready()
365 .await
366 .map_err(|e| {
367 tonic::Status::unknown(
368 format!("Service was not ready: {}", e.into()),
369 )
370 })?;
371 let codec = tonic::codec::ProstCodec::default();
372 let path = http::uri::PathAndQuery::from_static(
373 "/monitor_service.MonitorService/Profiling",
374 );
375 let mut req = request.into_request();
376 req.extensions_mut()
377 .insert(GrpcMethod::new("monitor_service.MonitorService", "Profiling"));
378 self.inner.unary(req, path, codec).await
379 }
380 pub async fn heap_profiling(
381 &mut self,
382 request: impl tonic::IntoRequest<super::HeapProfilingRequest>,
383 ) -> std::result::Result<
384 tonic::Response<super::HeapProfilingResponse>,
385 tonic::Status,
386 > {
387 self.inner
388 .ready()
389 .await
390 .map_err(|e| {
391 tonic::Status::unknown(
392 format!("Service was not ready: {}", e.into()),
393 )
394 })?;
395 let codec = tonic::codec::ProstCodec::default();
396 let path = http::uri::PathAndQuery::from_static(
397 "/monitor_service.MonitorService/HeapProfiling",
398 );
399 let mut req = request.into_request();
400 req.extensions_mut()
401 .insert(
402 GrpcMethod::new("monitor_service.MonitorService", "HeapProfiling"),
403 );
404 self.inner.unary(req, path, codec).await
405 }
406 pub async fn list_heap_profiling(
407 &mut self,
408 request: impl tonic::IntoRequest<super::ListHeapProfilingRequest>,
409 ) -> std::result::Result<
410 tonic::Response<super::ListHeapProfilingResponse>,
411 tonic::Status,
412 > {
413 self.inner
414 .ready()
415 .await
416 .map_err(|e| {
417 tonic::Status::unknown(
418 format!("Service was not ready: {}", e.into()),
419 )
420 })?;
421 let codec = tonic::codec::ProstCodec::default();
422 let path = http::uri::PathAndQuery::from_static(
423 "/monitor_service.MonitorService/ListHeapProfiling",
424 );
425 let mut req = request.into_request();
426 req.extensions_mut()
427 .insert(
428 GrpcMethod::new(
429 "monitor_service.MonitorService",
430 "ListHeapProfiling",
431 ),
432 );
433 self.inner.unary(req, path, codec).await
434 }
435 pub async fn analyze_heap(
436 &mut self,
437 request: impl tonic::IntoRequest<super::AnalyzeHeapRequest>,
438 ) -> std::result::Result<
439 tonic::Response<super::AnalyzeHeapResponse>,
440 tonic::Status,
441 > {
442 self.inner
443 .ready()
444 .await
445 .map_err(|e| {
446 tonic::Status::unknown(
447 format!("Service was not ready: {}", e.into()),
448 )
449 })?;
450 let codec = tonic::codec::ProstCodec::default();
451 let path = http::uri::PathAndQuery::from_static(
452 "/monitor_service.MonitorService/AnalyzeHeap",
453 );
454 let mut req = request.into_request();
455 req.extensions_mut()
456 .insert(
457 GrpcMethod::new("monitor_service.MonitorService", "AnalyzeHeap"),
458 );
459 self.inner.unary(req, path, codec).await
460 }
461 pub async fn get_streaming_stats(
462 &mut self,
463 request: impl tonic::IntoRequest<super::GetStreamingStatsRequest>,
464 ) -> std::result::Result<
465 tonic::Response<super::GetStreamingStatsResponse>,
466 tonic::Status,
467 > {
468 self.inner
469 .ready()
470 .await
471 .map_err(|e| {
472 tonic::Status::unknown(
473 format!("Service was not ready: {}", e.into()),
474 )
475 })?;
476 let codec = tonic::codec::ProstCodec::default();
477 let path = http::uri::PathAndQuery::from_static(
478 "/monitor_service.MonitorService/GetStreamingStats",
479 );
480 let mut req = request.into_request();
481 req.extensions_mut()
482 .insert(
483 GrpcMethod::new(
484 "monitor_service.MonitorService",
485 "GetStreamingStats",
486 ),
487 );
488 self.inner.unary(req, path, codec).await
489 }
490 pub async fn tiered_cache_tracing(
491 &mut self,
492 request: impl tonic::IntoRequest<super::TieredCacheTracingRequest>,
493 ) -> std::result::Result<
494 tonic::Response<super::TieredCacheTracingResponse>,
495 tonic::Status,
496 > {
497 self.inner
498 .ready()
499 .await
500 .map_err(|e| {
501 tonic::Status::unknown(
502 format!("Service was not ready: {}", e.into()),
503 )
504 })?;
505 let codec = tonic::codec::ProstCodec::default();
506 let path = http::uri::PathAndQuery::from_static(
507 "/monitor_service.MonitorService/TieredCacheTracing",
508 );
509 let mut req = request.into_request();
510 req.extensions_mut()
511 .insert(
512 GrpcMethod::new(
513 "monitor_service.MonitorService",
514 "TieredCacheTracing",
515 ),
516 );
517 self.inner.unary(req, path, codec).await
518 }
519 pub async fn get_profile_stats(
520 &mut self,
521 request: impl tonic::IntoRequest<super::GetProfileStatsRequest>,
522 ) -> std::result::Result<
523 tonic::Response<super::GetProfileStatsResponse>,
524 tonic::Status,
525 > {
526 self.inner
527 .ready()
528 .await
529 .map_err(|e| {
530 tonic::Status::unknown(
531 format!("Service was not ready: {}", e.into()),
532 )
533 })?;
534 let codec = tonic::codec::ProstCodec::default();
535 let path = http::uri::PathAndQuery::from_static(
536 "/monitor_service.MonitorService/GetProfileStats",
537 );
538 let mut req = request.into_request();
539 req.extensions_mut()
540 .insert(
541 GrpcMethod::new("monitor_service.MonitorService", "GetProfileStats"),
542 );
543 self.inner.unary(req, path, codec).await
544 }
545 }
546}
547pub mod monitor_service_server {
549 #![allow(
550 unused_variables,
551 dead_code,
552 missing_docs,
553 clippy::wildcard_imports,
554 clippy::let_unit_value,
555 )]
556 use tonic::codegen::*;
557 #[async_trait]
559 pub trait MonitorService: std::marker::Send + std::marker::Sync + 'static {
560 async fn stack_trace(
561 &self,
562 request: tonic::Request<super::StackTraceRequest>,
563 ) -> std::result::Result<
564 tonic::Response<super::StackTraceResponse>,
565 tonic::Status,
566 >;
567 async fn profiling(
568 &self,
569 request: tonic::Request<super::ProfilingRequest>,
570 ) -> std::result::Result<
571 tonic::Response<super::ProfilingResponse>,
572 tonic::Status,
573 >;
574 async fn heap_profiling(
575 &self,
576 request: tonic::Request<super::HeapProfilingRequest>,
577 ) -> std::result::Result<
578 tonic::Response<super::HeapProfilingResponse>,
579 tonic::Status,
580 >;
581 async fn list_heap_profiling(
582 &self,
583 request: tonic::Request<super::ListHeapProfilingRequest>,
584 ) -> std::result::Result<
585 tonic::Response<super::ListHeapProfilingResponse>,
586 tonic::Status,
587 >;
588 async fn analyze_heap(
589 &self,
590 request: tonic::Request<super::AnalyzeHeapRequest>,
591 ) -> std::result::Result<
592 tonic::Response<super::AnalyzeHeapResponse>,
593 tonic::Status,
594 >;
595 async fn get_streaming_stats(
596 &self,
597 request: tonic::Request<super::GetStreamingStatsRequest>,
598 ) -> std::result::Result<
599 tonic::Response<super::GetStreamingStatsResponse>,
600 tonic::Status,
601 >;
602 async fn tiered_cache_tracing(
603 &self,
604 request: tonic::Request<super::TieredCacheTracingRequest>,
605 ) -> std::result::Result<
606 tonic::Response<super::TieredCacheTracingResponse>,
607 tonic::Status,
608 >;
609 async fn get_profile_stats(
610 &self,
611 request: tonic::Request<super::GetProfileStatsRequest>,
612 ) -> std::result::Result<
613 tonic::Response<super::GetProfileStatsResponse>,
614 tonic::Status,
615 >;
616 }
617 #[derive(Debug)]
618 pub struct MonitorServiceServer<T> {
619 inner: Arc<T>,
620 accept_compression_encodings: EnabledCompressionEncodings,
621 send_compression_encodings: EnabledCompressionEncodings,
622 max_decoding_message_size: Option<usize>,
623 max_encoding_message_size: Option<usize>,
624 }
625 impl<T> MonitorServiceServer<T> {
626 pub fn new(inner: T) -> Self {
627 Self::from_arc(Arc::new(inner))
628 }
629 pub fn from_arc(inner: Arc<T>) -> Self {
630 Self {
631 inner,
632 accept_compression_encodings: Default::default(),
633 send_compression_encodings: Default::default(),
634 max_decoding_message_size: None,
635 max_encoding_message_size: None,
636 }
637 }
638 pub fn with_interceptor<F>(
639 inner: T,
640 interceptor: F,
641 ) -> InterceptedService<Self, F>
642 where
643 F: tonic::service::Interceptor,
644 {
645 InterceptedService::new(Self::new(inner), interceptor)
646 }
647 #[must_use]
649 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
650 self.accept_compression_encodings.enable(encoding);
651 self
652 }
653 #[must_use]
655 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
656 self.send_compression_encodings.enable(encoding);
657 self
658 }
659 #[must_use]
663 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
664 self.max_decoding_message_size = Some(limit);
665 self
666 }
667 #[must_use]
671 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
672 self.max_encoding_message_size = Some(limit);
673 self
674 }
675 }
676 impl<T, B> tonic::codegen::Service<http::Request<B>> for MonitorServiceServer<T>
677 where
678 T: MonitorService,
679 B: Body + std::marker::Send + 'static,
680 B::Error: Into<StdError> + std::marker::Send + 'static,
681 {
682 type Response = http::Response<tonic::body::BoxBody>;
683 type Error = std::convert::Infallible;
684 type Future = BoxFuture<Self::Response, Self::Error>;
685 fn poll_ready(
686 &mut self,
687 _cx: &mut Context<'_>,
688 ) -> Poll<std::result::Result<(), Self::Error>> {
689 Poll::Ready(Ok(()))
690 }
691 fn call(&mut self, req: http::Request<B>) -> Self::Future {
692 match req.uri().path() {
693 "/monitor_service.MonitorService/StackTrace" => {
694 #[allow(non_camel_case_types)]
695 struct StackTraceSvc<T: MonitorService>(pub Arc<T>);
696 impl<
697 T: MonitorService,
698 > tonic::server::UnaryService<super::StackTraceRequest>
699 for StackTraceSvc<T> {
700 type Response = super::StackTraceResponse;
701 type Future = BoxFuture<
702 tonic::Response<Self::Response>,
703 tonic::Status,
704 >;
705 fn call(
706 &mut self,
707 request: tonic::Request<super::StackTraceRequest>,
708 ) -> Self::Future {
709 let inner = Arc::clone(&self.0);
710 let fut = async move {
711 <T as MonitorService>::stack_trace(&inner, request).await
712 };
713 Box::pin(fut)
714 }
715 }
716 let accept_compression_encodings = self.accept_compression_encodings;
717 let send_compression_encodings = self.send_compression_encodings;
718 let max_decoding_message_size = self.max_decoding_message_size;
719 let max_encoding_message_size = self.max_encoding_message_size;
720 let inner = self.inner.clone();
721 let fut = async move {
722 let method = StackTraceSvc(inner);
723 let codec = tonic::codec::ProstCodec::default();
724 let mut grpc = tonic::server::Grpc::new(codec)
725 .apply_compression_config(
726 accept_compression_encodings,
727 send_compression_encodings,
728 )
729 .apply_max_message_size_config(
730 max_decoding_message_size,
731 max_encoding_message_size,
732 );
733 let res = grpc.unary(method, req).await;
734 Ok(res)
735 };
736 Box::pin(fut)
737 }
738 "/monitor_service.MonitorService/Profiling" => {
739 #[allow(non_camel_case_types)]
740 struct ProfilingSvc<T: MonitorService>(pub Arc<T>);
741 impl<
742 T: MonitorService,
743 > tonic::server::UnaryService<super::ProfilingRequest>
744 for ProfilingSvc<T> {
745 type Response = super::ProfilingResponse;
746 type Future = BoxFuture<
747 tonic::Response<Self::Response>,
748 tonic::Status,
749 >;
750 fn call(
751 &mut self,
752 request: tonic::Request<super::ProfilingRequest>,
753 ) -> Self::Future {
754 let inner = Arc::clone(&self.0);
755 let fut = async move {
756 <T as MonitorService>::profiling(&inner, request).await
757 };
758 Box::pin(fut)
759 }
760 }
761 let accept_compression_encodings = self.accept_compression_encodings;
762 let send_compression_encodings = self.send_compression_encodings;
763 let max_decoding_message_size = self.max_decoding_message_size;
764 let max_encoding_message_size = self.max_encoding_message_size;
765 let inner = self.inner.clone();
766 let fut = async move {
767 let method = ProfilingSvc(inner);
768 let codec = tonic::codec::ProstCodec::default();
769 let mut grpc = tonic::server::Grpc::new(codec)
770 .apply_compression_config(
771 accept_compression_encodings,
772 send_compression_encodings,
773 )
774 .apply_max_message_size_config(
775 max_decoding_message_size,
776 max_encoding_message_size,
777 );
778 let res = grpc.unary(method, req).await;
779 Ok(res)
780 };
781 Box::pin(fut)
782 }
783 "/monitor_service.MonitorService/HeapProfiling" => {
784 #[allow(non_camel_case_types)]
785 struct HeapProfilingSvc<T: MonitorService>(pub Arc<T>);
786 impl<
787 T: MonitorService,
788 > tonic::server::UnaryService<super::HeapProfilingRequest>
789 for HeapProfilingSvc<T> {
790 type Response = super::HeapProfilingResponse;
791 type Future = BoxFuture<
792 tonic::Response<Self::Response>,
793 tonic::Status,
794 >;
795 fn call(
796 &mut self,
797 request: tonic::Request<super::HeapProfilingRequest>,
798 ) -> Self::Future {
799 let inner = Arc::clone(&self.0);
800 let fut = async move {
801 <T as MonitorService>::heap_profiling(&inner, request).await
802 };
803 Box::pin(fut)
804 }
805 }
806 let accept_compression_encodings = self.accept_compression_encodings;
807 let send_compression_encodings = self.send_compression_encodings;
808 let max_decoding_message_size = self.max_decoding_message_size;
809 let max_encoding_message_size = self.max_encoding_message_size;
810 let inner = self.inner.clone();
811 let fut = async move {
812 let method = HeapProfilingSvc(inner);
813 let codec = tonic::codec::ProstCodec::default();
814 let mut grpc = tonic::server::Grpc::new(codec)
815 .apply_compression_config(
816 accept_compression_encodings,
817 send_compression_encodings,
818 )
819 .apply_max_message_size_config(
820 max_decoding_message_size,
821 max_encoding_message_size,
822 );
823 let res = grpc.unary(method, req).await;
824 Ok(res)
825 };
826 Box::pin(fut)
827 }
828 "/monitor_service.MonitorService/ListHeapProfiling" => {
829 #[allow(non_camel_case_types)]
830 struct ListHeapProfilingSvc<T: MonitorService>(pub Arc<T>);
831 impl<
832 T: MonitorService,
833 > tonic::server::UnaryService<super::ListHeapProfilingRequest>
834 for ListHeapProfilingSvc<T> {
835 type Response = super::ListHeapProfilingResponse;
836 type Future = BoxFuture<
837 tonic::Response<Self::Response>,
838 tonic::Status,
839 >;
840 fn call(
841 &mut self,
842 request: tonic::Request<super::ListHeapProfilingRequest>,
843 ) -> Self::Future {
844 let inner = Arc::clone(&self.0);
845 let fut = async move {
846 <T as MonitorService>::list_heap_profiling(&inner, request)
847 .await
848 };
849 Box::pin(fut)
850 }
851 }
852 let accept_compression_encodings = self.accept_compression_encodings;
853 let send_compression_encodings = self.send_compression_encodings;
854 let max_decoding_message_size = self.max_decoding_message_size;
855 let max_encoding_message_size = self.max_encoding_message_size;
856 let inner = self.inner.clone();
857 let fut = async move {
858 let method = ListHeapProfilingSvc(inner);
859 let codec = tonic::codec::ProstCodec::default();
860 let mut grpc = tonic::server::Grpc::new(codec)
861 .apply_compression_config(
862 accept_compression_encodings,
863 send_compression_encodings,
864 )
865 .apply_max_message_size_config(
866 max_decoding_message_size,
867 max_encoding_message_size,
868 );
869 let res = grpc.unary(method, req).await;
870 Ok(res)
871 };
872 Box::pin(fut)
873 }
874 "/monitor_service.MonitorService/AnalyzeHeap" => {
875 #[allow(non_camel_case_types)]
876 struct AnalyzeHeapSvc<T: MonitorService>(pub Arc<T>);
877 impl<
878 T: MonitorService,
879 > tonic::server::UnaryService<super::AnalyzeHeapRequest>
880 for AnalyzeHeapSvc<T> {
881 type Response = super::AnalyzeHeapResponse;
882 type Future = BoxFuture<
883 tonic::Response<Self::Response>,
884 tonic::Status,
885 >;
886 fn call(
887 &mut self,
888 request: tonic::Request<super::AnalyzeHeapRequest>,
889 ) -> Self::Future {
890 let inner = Arc::clone(&self.0);
891 let fut = async move {
892 <T as MonitorService>::analyze_heap(&inner, request).await
893 };
894 Box::pin(fut)
895 }
896 }
897 let accept_compression_encodings = self.accept_compression_encodings;
898 let send_compression_encodings = self.send_compression_encodings;
899 let max_decoding_message_size = self.max_decoding_message_size;
900 let max_encoding_message_size = self.max_encoding_message_size;
901 let inner = self.inner.clone();
902 let fut = async move {
903 let method = AnalyzeHeapSvc(inner);
904 let codec = tonic::codec::ProstCodec::default();
905 let mut grpc = tonic::server::Grpc::new(codec)
906 .apply_compression_config(
907 accept_compression_encodings,
908 send_compression_encodings,
909 )
910 .apply_max_message_size_config(
911 max_decoding_message_size,
912 max_encoding_message_size,
913 );
914 let res = grpc.unary(method, req).await;
915 Ok(res)
916 };
917 Box::pin(fut)
918 }
919 "/monitor_service.MonitorService/GetStreamingStats" => {
920 #[allow(non_camel_case_types)]
921 struct GetStreamingStatsSvc<T: MonitorService>(pub Arc<T>);
922 impl<
923 T: MonitorService,
924 > tonic::server::UnaryService<super::GetStreamingStatsRequest>
925 for GetStreamingStatsSvc<T> {
926 type Response = super::GetStreamingStatsResponse;
927 type Future = BoxFuture<
928 tonic::Response<Self::Response>,
929 tonic::Status,
930 >;
931 fn call(
932 &mut self,
933 request: tonic::Request<super::GetStreamingStatsRequest>,
934 ) -> Self::Future {
935 let inner = Arc::clone(&self.0);
936 let fut = async move {
937 <T as MonitorService>::get_streaming_stats(&inner, request)
938 .await
939 };
940 Box::pin(fut)
941 }
942 }
943 let accept_compression_encodings = self.accept_compression_encodings;
944 let send_compression_encodings = self.send_compression_encodings;
945 let max_decoding_message_size = self.max_decoding_message_size;
946 let max_encoding_message_size = self.max_encoding_message_size;
947 let inner = self.inner.clone();
948 let fut = async move {
949 let method = GetStreamingStatsSvc(inner);
950 let codec = tonic::codec::ProstCodec::default();
951 let mut grpc = tonic::server::Grpc::new(codec)
952 .apply_compression_config(
953 accept_compression_encodings,
954 send_compression_encodings,
955 )
956 .apply_max_message_size_config(
957 max_decoding_message_size,
958 max_encoding_message_size,
959 );
960 let res = grpc.unary(method, req).await;
961 Ok(res)
962 };
963 Box::pin(fut)
964 }
965 "/monitor_service.MonitorService/TieredCacheTracing" => {
966 #[allow(non_camel_case_types)]
967 struct TieredCacheTracingSvc<T: MonitorService>(pub Arc<T>);
968 impl<
969 T: MonitorService,
970 > tonic::server::UnaryService<super::TieredCacheTracingRequest>
971 for TieredCacheTracingSvc<T> {
972 type Response = super::TieredCacheTracingResponse;
973 type Future = BoxFuture<
974 tonic::Response<Self::Response>,
975 tonic::Status,
976 >;
977 fn call(
978 &mut self,
979 request: tonic::Request<super::TieredCacheTracingRequest>,
980 ) -> Self::Future {
981 let inner = Arc::clone(&self.0);
982 let fut = async move {
983 <T as MonitorService>::tiered_cache_tracing(&inner, request)
984 .await
985 };
986 Box::pin(fut)
987 }
988 }
989 let accept_compression_encodings = self.accept_compression_encodings;
990 let send_compression_encodings = self.send_compression_encodings;
991 let max_decoding_message_size = self.max_decoding_message_size;
992 let max_encoding_message_size = self.max_encoding_message_size;
993 let inner = self.inner.clone();
994 let fut = async move {
995 let method = TieredCacheTracingSvc(inner);
996 let codec = tonic::codec::ProstCodec::default();
997 let mut grpc = tonic::server::Grpc::new(codec)
998 .apply_compression_config(
999 accept_compression_encodings,
1000 send_compression_encodings,
1001 )
1002 .apply_max_message_size_config(
1003 max_decoding_message_size,
1004 max_encoding_message_size,
1005 );
1006 let res = grpc.unary(method, req).await;
1007 Ok(res)
1008 };
1009 Box::pin(fut)
1010 }
1011 "/monitor_service.MonitorService/GetProfileStats" => {
1012 #[allow(non_camel_case_types)]
1013 struct GetProfileStatsSvc<T: MonitorService>(pub Arc<T>);
1014 impl<
1015 T: MonitorService,
1016 > tonic::server::UnaryService<super::GetProfileStatsRequest>
1017 for GetProfileStatsSvc<T> {
1018 type Response = super::GetProfileStatsResponse;
1019 type Future = BoxFuture<
1020 tonic::Response<Self::Response>,
1021 tonic::Status,
1022 >;
1023 fn call(
1024 &mut self,
1025 request: tonic::Request<super::GetProfileStatsRequest>,
1026 ) -> Self::Future {
1027 let inner = Arc::clone(&self.0);
1028 let fut = async move {
1029 <T as MonitorService>::get_profile_stats(&inner, request)
1030 .await
1031 };
1032 Box::pin(fut)
1033 }
1034 }
1035 let accept_compression_encodings = self.accept_compression_encodings;
1036 let send_compression_encodings = self.send_compression_encodings;
1037 let max_decoding_message_size = self.max_decoding_message_size;
1038 let max_encoding_message_size = self.max_encoding_message_size;
1039 let inner = self.inner.clone();
1040 let fut = async move {
1041 let method = GetProfileStatsSvc(inner);
1042 let codec = tonic::codec::ProstCodec::default();
1043 let mut grpc = tonic::server::Grpc::new(codec)
1044 .apply_compression_config(
1045 accept_compression_encodings,
1046 send_compression_encodings,
1047 )
1048 .apply_max_message_size_config(
1049 max_decoding_message_size,
1050 max_encoding_message_size,
1051 );
1052 let res = grpc.unary(method, req).await;
1053 Ok(res)
1054 };
1055 Box::pin(fut)
1056 }
1057 _ => {
1058 Box::pin(async move {
1059 let mut response = http::Response::new(empty_body());
1060 let headers = response.headers_mut();
1061 headers
1062 .insert(
1063 tonic::Status::GRPC_STATUS,
1064 (tonic::Code::Unimplemented as i32).into(),
1065 );
1066 headers
1067 .insert(
1068 http::header::CONTENT_TYPE,
1069 tonic::metadata::GRPC_CONTENT_TYPE,
1070 );
1071 Ok(response)
1072 })
1073 }
1074 }
1075 }
1076 }
1077 impl<T> Clone for MonitorServiceServer<T> {
1078 fn clone(&self) -> Self {
1079 let inner = self.inner.clone();
1080 Self {
1081 inner,
1082 accept_compression_encodings: self.accept_compression_encodings,
1083 send_compression_encodings: self.send_compression_encodings,
1084 max_decoding_message_size: self.max_decoding_message_size,
1085 max_encoding_message_size: self.max_encoding_message_size,
1086 }
1087 }
1088 }
1089 pub const SERVICE_NAME: &str = "monitor_service.MonitorService";
1091 impl<T> tonic::server::NamedService for MonitorServiceServer<T> {
1092 const NAME: &'static str = SERVICE_NAME;
1093 }
1094}