// @generated /// Generated client implementations. pub mod data_catalog_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 DataCatalogClient<T> { inner: tonic::client::Grpc<T>, } impl DataCatalogClient<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> DataCatalogClient<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, ) -> DataCatalogClient<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, { DataCatalogClient::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 create_dataset( &mut self, request: impl tonic::IntoRequest<super::CreateDatasetRequest>, ) -> std::result::Result< tonic::Response<super::CreateDatasetResponse>, 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( "/datacatalog.DataCatalog/CreateDataset", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "CreateDataset")); self.inner.unary(req, path, codec).await } pub async fn get_dataset( &mut self, request: impl tonic::IntoRequest<super::GetDatasetRequest>, ) -> std::result::Result< tonic::Response<super::GetDatasetResponse>, 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( "/datacatalog.DataCatalog/GetDataset", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "GetDataset")); self.inner.unary(req, path, codec).await } pub async fn create_artifact( &mut self, request: impl tonic::IntoRequest<super::CreateArtifactRequest>, ) -> std::result::Result< tonic::Response<super::CreateArtifactResponse>, 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( "/datacatalog.DataCatalog/CreateArtifact", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "CreateArtifact")); self.inner.unary(req, path, codec).await } pub async fn get_artifact( &mut self, request: impl tonic::IntoRequest<super::GetArtifactRequest>, ) -> std::result::Result< tonic::Response<super::GetArtifactResponse>, 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( "/datacatalog.DataCatalog/GetArtifact", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "GetArtifact")); self.inner.unary(req, path, codec).await } pub async fn add_tag( &mut self, request: impl tonic::IntoRequest<super::AddTagRequest>, ) -> std::result::Result<tonic::Response<super::AddTagResponse>, 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( "/datacatalog.DataCatalog/AddTag", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "AddTag")); self.inner.unary(req, path, codec).await } pub async fn list_artifacts( &mut self, request: impl tonic::IntoRequest<super::ListArtifactsRequest>, ) -> std::result::Result< tonic::Response<super::ListArtifactsResponse>, 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( "/datacatalog.DataCatalog/ListArtifacts", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "ListArtifacts")); self.inner.unary(req, path, codec).await } pub async fn list_datasets( &mut self, request: impl tonic::IntoRequest<super::ListDatasetsRequest>, ) -> std::result::Result< tonic::Response<super::ListDatasetsResponse>, 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( "/datacatalog.DataCatalog/ListDatasets", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "ListDatasets")); self.inner.unary(req, path, codec).await } pub async fn update_artifact( &mut self, request: impl tonic::IntoRequest<super::UpdateArtifactRequest>, ) -> std::result::Result< tonic::Response<super::UpdateArtifactResponse>, 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( "/datacatalog.DataCatalog/UpdateArtifact", ); let mut req = request.into_request(); req.extensions_mut() .insert(GrpcMethod::new("datacatalog.DataCatalog", "UpdateArtifact")); self.inner.unary(req, path, codec).await } pub async fn get_or_extend_reservation( &mut self, request: impl tonic::IntoRequest<super::GetOrExtendReservationRequest>, ) -> std::result::Result< tonic::Response<super::GetOrExtendReservationResponse>, 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( "/datacatalog.DataCatalog/GetOrExtendReservation", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new("datacatalog.DataCatalog", "GetOrExtendReservation"), ); self.inner.unary(req, path, codec).await } pub async fn release_reservation( &mut self, request: impl tonic::IntoRequest<super::ReleaseReservationRequest>, ) -> std::result::Result< tonic::Response<super::ReleaseReservationResponse>, 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( "/datacatalog.DataCatalog/ReleaseReservation", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new("datacatalog.DataCatalog", "ReleaseReservation"), ); self.inner.unary(req, path, codec).await } } } /// Generated server implementations. pub mod data_catalog_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 DataCatalogServer. #[async_trait] pub trait DataCatalog: Send + Sync + 'static { async fn create_dataset( &self, request: tonic::Request<super::CreateDatasetRequest>, ) -> std::result::Result< tonic::Response<super::CreateDatasetResponse>, tonic::Status, >; async fn get_dataset( &self, request: tonic::Request<super::GetDatasetRequest>, ) -> std::result::Result< tonic::Response<super::GetDatasetResponse>, tonic::Status, >; async fn create_artifact( &self, request: tonic::Request<super::CreateArtifactRequest>, ) -> std::result::Result< tonic::Response<super::CreateArtifactResponse>, tonic::Status, >; async fn get_artifact( &self, request: tonic::Request<super::GetArtifactRequest>, ) -> std::result::Result< tonic::Response<super::GetArtifactResponse>, tonic::Status, >; async fn add_tag( &self, request: tonic::Request<super::AddTagRequest>, ) -> std::result::Result<tonic::Response<super::AddTagResponse>, tonic::Status>; async fn list_artifacts( &self, request: tonic::Request<super::ListArtifactsRequest>, ) -> std::result::Result< tonic::Response<super::ListArtifactsResponse>, tonic::Status, >; async fn list_datasets( &self, request: tonic::Request<super::ListDatasetsRequest>, ) -> std::result::Result< tonic::Response<super::ListDatasetsResponse>, tonic::Status, >; async fn update_artifact( &self, request: tonic::Request<super::UpdateArtifactRequest>, ) -> std::result::Result< tonic::Response<super::UpdateArtifactResponse>, tonic::Status, >; async fn get_or_extend_reservation( &self, request: tonic::Request<super::GetOrExtendReservationRequest>, ) -> std::result::Result< tonic::Response<super::GetOrExtendReservationResponse>, tonic::Status, >; async fn release_reservation( &self, request: tonic::Request<super::ReleaseReservationRequest>, ) -> std::result::Result< tonic::Response<super::ReleaseReservationResponse>, tonic::Status, >; } #[derive(Debug)] pub struct DataCatalogServer<T: DataCatalog> { 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: DataCatalog> DataCatalogServer<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 DataCatalogServer<T> where T: DataCatalog, 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() { "/datacatalog.DataCatalog/CreateDataset" => { #[allow(non_camel_case_types)] struct CreateDatasetSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::CreateDatasetRequest> for CreateDatasetSvc<T> { type Response = super::CreateDatasetResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::CreateDatasetRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::create_dataset(&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 = CreateDatasetSvc(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) } "/datacatalog.DataCatalog/GetDataset" => { #[allow(non_camel_case_types)] struct GetDatasetSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::GetDatasetRequest> for GetDatasetSvc<T> { type Response = super::GetDatasetResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::GetDatasetRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::get_dataset(&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 = GetDatasetSvc(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) } "/datacatalog.DataCatalog/CreateArtifact" => { #[allow(non_camel_case_types)] struct CreateArtifactSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::CreateArtifactRequest> for CreateArtifactSvc<T> { type Response = super::CreateArtifactResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::CreateArtifactRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::create_artifact(&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 = CreateArtifactSvc(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) } "/datacatalog.DataCatalog/GetArtifact" => { #[allow(non_camel_case_types)] struct GetArtifactSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::GetArtifactRequest> for GetArtifactSvc<T> { type Response = super::GetArtifactResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::GetArtifactRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::get_artifact(&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 = GetArtifactSvc(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) } "/datacatalog.DataCatalog/AddTag" => { #[allow(non_camel_case_types)] struct AddTagSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::AddTagRequest> for AddTagSvc<T> { type Response = super::AddTagResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::AddTagRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::add_tag(&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 = AddTagSvc(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) } "/datacatalog.DataCatalog/ListArtifacts" => { #[allow(non_camel_case_types)] struct ListArtifactsSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::ListArtifactsRequest> for ListArtifactsSvc<T> { type Response = super::ListArtifactsResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::ListArtifactsRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::list_artifacts(&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 = ListArtifactsSvc(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) } "/datacatalog.DataCatalog/ListDatasets" => { #[allow(non_camel_case_types)] struct ListDatasetsSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::ListDatasetsRequest> for ListDatasetsSvc<T> { type Response = super::ListDatasetsResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::ListDatasetsRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::list_datasets(&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 = ListDatasetsSvc(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) } "/datacatalog.DataCatalog/UpdateArtifact" => { #[allow(non_camel_case_types)] struct UpdateArtifactSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::UpdateArtifactRequest> for UpdateArtifactSvc<T> { type Response = super::UpdateArtifactResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::UpdateArtifactRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::update_artifact(&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 = UpdateArtifactSvc(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) } "/datacatalog.DataCatalog/GetOrExtendReservation" => { #[allow(non_camel_case_types)] struct GetOrExtendReservationSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::GetOrExtendReservationRequest> for GetOrExtendReservationSvc<T> { type Response = super::GetOrExtendReservationResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::GetOrExtendReservationRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::get_or_extend_reservation( &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 = GetOrExtendReservationSvc(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) } "/datacatalog.DataCatalog/ReleaseReservation" => { #[allow(non_camel_case_types)] struct ReleaseReservationSvc<T: DataCatalog>(pub Arc<T>); impl< T: DataCatalog, > tonic::server::UnaryService<super::ReleaseReservationRequest> for ReleaseReservationSvc<T> { type Response = super::ReleaseReservationResponse; type Future = BoxFuture< tonic::Response<Self::Response>, tonic::Status, >; fn call( &mut self, request: tonic::Request<super::ReleaseReservationRequest>, ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { <T as DataCatalog>::release_reservation(&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 = ReleaseReservationSvc(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: DataCatalog> Clone for DataCatalogServer<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: DataCatalog> 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: DataCatalog> tonic::server::NamedService for DataCatalogServer<T> { const NAME: &'static str = "datacatalog.DataCatalog"; } }