diff options
Diffstat (limited to 'src/rpc/envoy.service.tap.v2alpha.tonic.rs')
| -rw-r--r-- | src/rpc/envoy.service.tap.v2alpha.tonic.rs | 301 |
1 files changed, 0 insertions, 301 deletions
diff --git a/src/rpc/envoy.service.tap.v2alpha.tonic.rs b/src/rpc/envoy.service.tap.v2alpha.tonic.rs deleted file mode 100644 index 9d9acf54..00000000 --- a/src/rpc/envoy.service.tap.v2alpha.tonic.rs +++ /dev/null @@ -1,301 +0,0 @@ -// @generated -/// Generated client implementations. -pub mod tap_sink_service_client { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - use tonic::codegen::http::Uri; - #[derive(Debug, Clone)] - pub struct TapSinkServiceClient<T> { - inner: tonic::client::Grpc<T>, - } - impl TapSinkServiceClient<tonic::transport::Channel> { - /// Attempt to create a new client by connecting to a given endpoint. - pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error> - where - D: TryInto<tonic::transport::Endpoint>, - D::Error: Into<StdError>, - { - let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; - Ok(Self::new(conn)) - } - } - impl<T> TapSinkServiceClient<T> - where - T: tonic::client::GrpcService<tonic::body::BoxBody>, - T::Error: Into<StdError>, - T::ResponseBody: Body<Data = Bytes> + Send + 'static, - <T::ResponseBody as Body>::Error: Into<StdError> + Send, - { - pub fn new(inner: T) -> Self { - let inner = tonic::client::Grpc::new(inner); - Self { inner } - } - pub fn with_origin(inner: T, origin: Uri) -> Self { - let inner = tonic::client::Grpc::with_origin(inner, origin); - Self { inner } - } - pub fn with_interceptor<F>( - inner: T, - interceptor: F, - ) -> TapSinkServiceClient<InterceptedService<T, F>> - where - F: tonic::service::Interceptor, - T::ResponseBody: Default, - T: tonic::codegen::Service< - http::Request<tonic::body::BoxBody>, - Response = http::Response< - <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, - >, - >, - <T as tonic::codegen::Service< - http::Request<tonic::body::BoxBody>, - >>::Error: Into<StdError> + Send + Sync, - { - TapSinkServiceClient::new(InterceptedService::new(inner, interceptor)) - } - /// Compress requests with the given encoding. - /// - /// This requires the server to support it otherwise it might respond with an - /// error. - #[must_use] - pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.inner = self.inner.send_compressed(encoding); - self - } - /// Enable decompressing responses. - #[must_use] - pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.inner = self.inner.accept_compressed(encoding); - self - } - /// Limits the maximum size of a decoded message. - /// - /// Default: `4MB` - #[must_use] - pub fn max_decoding_message_size(mut self, limit: usize) -> Self { - self.inner = self.inner.max_decoding_message_size(limit); - self - } - /// Limits the maximum size of an encoded message. - /// - /// Default: `usize::MAX` - #[must_use] - pub fn max_encoding_message_size(mut self, limit: usize) -> Self { - self.inner = self.inner.max_encoding_message_size(limit); - self - } - pub async fn stream_taps( - &mut self, - request: impl tonic::IntoStreamingRequest<Message = super::StreamTapsRequest>, - ) -> std::result::Result< - tonic::Response<super::StreamTapsResponse>, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/envoy.service.tap.v2alpha.TapSinkService/StreamTaps", - ); - let mut req = request.into_streaming_request(); - req.extensions_mut() - .insert( - GrpcMethod::new( - "envoy.service.tap.v2alpha.TapSinkService", - "StreamTaps", - ), - ); - self.inner.client_streaming(req, path, codec).await - } - } -} -/// Generated server implementations. -pub mod tap_sink_service_server { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - /// Generated trait containing gRPC methods that should be implemented for use with TapSinkServiceServer. - #[async_trait] - pub trait TapSinkService: Send + Sync + 'static { - async fn stream_taps( - &self, - request: tonic::Request<tonic::Streaming<super::StreamTapsRequest>>, - ) -> std::result::Result< - tonic::Response<super::StreamTapsResponse>, - tonic::Status, - >; - } - #[derive(Debug)] - pub struct TapSinkServiceServer<T: TapSinkService> { - inner: _Inner<T>, - accept_compression_encodings: EnabledCompressionEncodings, - send_compression_encodings: EnabledCompressionEncodings, - max_decoding_message_size: Option<usize>, - max_encoding_message_size: Option<usize>, - } - struct _Inner<T>(Arc<T>); - impl<T: TapSinkService> TapSinkServiceServer<T> { - pub fn new(inner: T) -> Self { - Self::from_arc(Arc::new(inner)) - } - pub fn from_arc(inner: Arc<T>) -> Self { - let inner = _Inner(inner); - Self { - inner, - accept_compression_encodings: Default::default(), - send_compression_encodings: Default::default(), - max_decoding_message_size: None, - max_encoding_message_size: None, - } - } - pub fn with_interceptor<F>( - inner: T, - interceptor: F, - ) -> InterceptedService<Self, F> - where - F: tonic::service::Interceptor, - { - InterceptedService::new(Self::new(inner), interceptor) - } - /// Enable decompressing requests with the given encoding. - #[must_use] - pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.accept_compression_encodings.enable(encoding); - self - } - /// Compress responses with the given encoding, if the client supports it. - #[must_use] - pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.send_compression_encodings.enable(encoding); - self - } - /// Limits the maximum size of a decoded message. - /// - /// Default: `4MB` - #[must_use] - pub fn max_decoding_message_size(mut self, limit: usize) -> Self { - self.max_decoding_message_size = Some(limit); - self - } - /// Limits the maximum size of an encoded message. - /// - /// Default: `usize::MAX` - #[must_use] - pub fn max_encoding_message_size(mut self, limit: usize) -> Self { - self.max_encoding_message_size = Some(limit); - self - } - } - impl<T, B> tonic::codegen::Service<http::Request<B>> for TapSinkServiceServer<T> - where - T: TapSinkService, - B: Body + Send + 'static, - B::Error: Into<StdError> + Send + 'static, - { - type Response = http::Response<tonic::body::BoxBody>; - type Error = std::convert::Infallible; - type Future = BoxFuture<Self::Response, Self::Error>; - fn poll_ready( - &mut self, - _cx: &mut Context<'_>, - ) -> Poll<std::result::Result<(), Self::Error>> { - Poll::Ready(Ok(())) - } - fn call(&mut self, req: http::Request<B>) -> Self::Future { - let inner = self.inner.clone(); - match req.uri().path() { - "/envoy.service.tap.v2alpha.TapSinkService/StreamTaps" => { - #[allow(non_camel_case_types)] - struct StreamTapsSvc<T: TapSinkService>(pub Arc<T>); - impl< - T: TapSinkService, - > tonic::server::ClientStreamingService<super::StreamTapsRequest> - for StreamTapsSvc<T> { - type Response = super::StreamTapsResponse; - type Future = BoxFuture< - tonic::Response<Self::Response>, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request< - tonic::Streaming<super::StreamTapsRequest>, - >, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - <T as TapSinkService>::stream_taps(&inner, request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = StreamTapsSvc(inner); - let codec = tonic::codec::ProstCodec::default(); - let mut grpc = tonic::server::Grpc::new(codec) - .apply_compression_config( - accept_compression_encodings, - send_compression_encodings, - ) - .apply_max_message_size_config( - max_decoding_message_size, - max_encoding_message_size, - ); - let res = grpc.client_streaming(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - _ => { - Box::pin(async move { - Ok( - http::Response::builder() - .status(200) - .header("grpc-status", "12") - .header("content-type", "application/grpc") - .body(empty_body()) - .unwrap(), - ) - }) - } - } - } - } - impl<T: TapSinkService> Clone for TapSinkServiceServer<T> { - fn clone(&self) -> Self { - let inner = self.inner.clone(); - Self { - inner, - accept_compression_encodings: self.accept_compression_encodings, - send_compression_encodings: self.send_compression_encodings, - max_decoding_message_size: self.max_decoding_message_size, - max_encoding_message_size: self.max_encoding_message_size, - } - } - } - impl<T: TapSinkService> Clone for _Inner<T> { - fn clone(&self) -> Self { - Self(Arc::clone(&self.0)) - } - } - impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:?}", self.0) - } - } - impl<T: TapSinkService> tonic::server::NamedService for TapSinkServiceServer<T> { - const NAME: &'static str = "envoy.service.tap.v2alpha.TapSinkService"; - } -} |