summaryrefslogtreecommitdiff
path: root/src/rpc/google.longrunning.tonic.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/rpc/google.longrunning.tonic.rs')
-rw-r--r--src/rpc/google.longrunning.tonic.rs604
1 files changed, 604 insertions, 0 deletions
diff --git a/src/rpc/google.longrunning.tonic.rs b/src/rpc/google.longrunning.tonic.rs
new file mode 100644
index 00000000..ffade459
--- /dev/null
+++ b/src/rpc/google.longrunning.tonic.rs
@@ -0,0 +1,604 @@
+// @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";
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-02 02:51:57 +0000