diff options
Diffstat (limited to 'src/rpc/google.longrunning.tonic.rs')
| -rw-r--r-- | src/rpc/google.longrunning.tonic.rs | 604 |
1 files changed, 0 insertions, 604 deletions
diff --git a/src/rpc/google.longrunning.tonic.rs b/src/rpc/google.longrunning.tonic.rs deleted file mode 100644 index ffade459..00000000 --- a/src/rpc/google.longrunning.tonic.rs +++ /dev/null @@ -1,604 +0,0 @@ -// @generated -/// Generated client implementations. -pub mod operations_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 OperationsClient<T> { - inner: tonic::client::Grpc<T>, - } - impl OperationsClient<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> OperationsClient<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, - ) -> OperationsClient<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, - { - OperationsClient::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 list_operations( - &mut self, - request: impl tonic::IntoRequest<super::ListOperationsRequest>, - ) -> std::result::Result< - tonic::Response<super::ListOperationsResponse>, - 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( - "/google.longrunning.Operations/ListOperations", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("google.longrunning.Operations", "ListOperations"), - ); - self.inner.unary(req, path, codec).await - } - pub async fn get_operation( - &mut self, - request: impl tonic::IntoRequest<super::GetOperationRequest>, - ) -> std::result::Result<tonic::Response<super::Operation>, 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( - "/google.longrunning.Operations/GetOperation", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("google.longrunning.Operations", "GetOperation"), - ); - self.inner.unary(req, path, codec).await - } - pub async fn delete_operation( - &mut self, - request: impl tonic::IntoRequest<super::DeleteOperationRequest>, - ) -> std::result::Result< - tonic::Response<super::super::protobuf::Empty>, - 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( - "/google.longrunning.Operations/DeleteOperation", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("google.longrunning.Operations", "DeleteOperation"), - ); - self.inner.unary(req, path, codec).await - } - pub async fn cancel_operation( - &mut self, - request: impl tonic::IntoRequest<super::CancelOperationRequest>, - ) -> std::result::Result< - tonic::Response<super::super::protobuf::Empty>, - 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( - "/google.longrunning.Operations/CancelOperation", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("google.longrunning.Operations", "CancelOperation"), - ); - self.inner.unary(req, path, codec).await - } - pub async fn wait_operation( - &mut self, - request: impl tonic::IntoRequest<super::WaitOperationRequest>, - ) -> std::result::Result<tonic::Response<super::Operation>, 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( - "/google.longrunning.Operations/WaitOperation", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("google.longrunning.Operations", "WaitOperation"), - ); - self.inner.unary(req, path, codec).await - } - } -} -/// Generated server implementations. -pub mod operations_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 OperationsServer. - #[async_trait] - pub trait Operations: Send + Sync + 'static { - async fn list_operations( - &self, - request: tonic::Request<super::ListOperationsRequest>, - ) -> std::result::Result< - tonic::Response<super::ListOperationsResponse>, - tonic::Status, - >; - async fn get_operation( - &self, - request: tonic::Request<super::GetOperationRequest>, - ) -> std::result::Result<tonic::Response<super::Operation>, tonic::Status>; - async fn delete_operation( - &self, - request: tonic::Request<super::DeleteOperationRequest>, - ) -> std::result::Result< - tonic::Response<super::super::protobuf::Empty>, - tonic::Status, - >; - async fn cancel_operation( - &self, - request: tonic::Request<super::CancelOperationRequest>, - ) -> std::result::Result< - tonic::Response<super::super::protobuf::Empty>, - tonic::Status, - >; - async fn wait_operation( - &self, - request: tonic::Request<super::WaitOperationRequest>, - ) -> std::result::Result<tonic::Response<super::Operation>, tonic::Status>; - } - #[derive(Debug)] - pub struct OperationsServer<T: Operations> { - 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: Operations> OperationsServer<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 OperationsServer<T> - where - T: Operations, - 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() { - "/google.longrunning.Operations/ListOperations" => { - #[allow(non_camel_case_types)] - struct ListOperationsSvc<T: Operations>(pub Arc<T>); - impl< - T: Operations, - > tonic::server::UnaryService<super::ListOperationsRequest> - for ListOperationsSvc<T> { - type Response = super::ListOperationsResponse; - type Future = BoxFuture< - tonic::Response<Self::Response>, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request<super::ListOperationsRequest>, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - <T as Operations>::list_operations(&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 = ListOperationsSvc(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.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/google.longrunning.Operations/GetOperation" => { - #[allow(non_camel_case_types)] - struct GetOperationSvc<T: Operations>(pub Arc<T>); - impl< - T: Operations, - > tonic::server::UnaryService<super::GetOperationRequest> - for GetOperationSvc<T> { - type Response = super::Operation; - type Future = BoxFuture< - tonic::Response<Self::Response>, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request<super::GetOperationRequest>, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - <T as Operations>::get_operation(&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 = GetOperationSvc(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.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/google.longrunning.Operations/DeleteOperation" => { - #[allow(non_camel_case_types)] - struct DeleteOperationSvc<T: Operations>(pub Arc<T>); - impl< - T: Operations, - > tonic::server::UnaryService<super::DeleteOperationRequest> - for DeleteOperationSvc<T> { - type Response = super::super::protobuf::Empty; - type Future = BoxFuture< - tonic::Response<Self::Response>, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request<super::DeleteOperationRequest>, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - <T as Operations>::delete_operation(&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 = DeleteOperationSvc(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.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/google.longrunning.Operations/CancelOperation" => { - #[allow(non_camel_case_types)] - struct CancelOperationSvc<T: Operations>(pub Arc<T>); - impl< - T: Operations, - > tonic::server::UnaryService<super::CancelOperationRequest> - for CancelOperationSvc<T> { - type Response = super::super::protobuf::Empty; - type Future = BoxFuture< - tonic::Response<Self::Response>, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request<super::CancelOperationRequest>, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - <T as Operations>::cancel_operation(&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 = CancelOperationSvc(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.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/google.longrunning.Operations/WaitOperation" => { - #[allow(non_camel_case_types)] - struct WaitOperationSvc<T: Operations>(pub Arc<T>); - impl< - T: Operations, - > tonic::server::UnaryService<super::WaitOperationRequest> - for WaitOperationSvc<T> { - type Response = super::Operation; - type Future = BoxFuture< - tonic::Response<Self::Response>, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request<super::WaitOperationRequest>, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - <T as Operations>::wait_operation(&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 = WaitOperationSvc(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.unary(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: Operations> Clone for OperationsServer<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: Operations> 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: Operations> tonic::server::NamedService for OperationsServer<T> { - const NAME: &'static str = "google.longrunning.Operations"; - } -} |