summaryrefslogtreecommitdiff
path: root/src/rpc/google.bytestream.tonic.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/rpc/google.bytestream.tonic.rs')
-rw-r--r--src/rpc/google.bytestream.tonic.rs452
1 files changed, 0 insertions, 452 deletions
diff --git a/src/rpc/google.bytestream.tonic.rs b/src/rpc/google.bytestream.tonic.rs
deleted file mode 100644
index 4cdd6c30..00000000
--- a/src/rpc/google.bytestream.tonic.rs
+++ /dev/null
@@ -1,452 +0,0 @@
-// @generated
-/// Generated client implementations.
-pub mod byte_stream_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 ByteStreamClient<T> {
- inner: tonic::client::Grpc<T>,
- }
- impl ByteStreamClient<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> ByteStreamClient<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,
- ) -> ByteStreamClient<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,
- {
- ByteStreamClient::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 read(
- &mut self,
- request: impl tonic::IntoRequest<super::ReadRequest>,
- ) -> std::result::Result<
- tonic::Response<tonic::codec::Streaming<super::ReadResponse>>,
- 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.bytestream.ByteStream/Read",
- );
- let mut req = request.into_request();
- req.extensions_mut()
- .insert(GrpcMethod::new("google.bytestream.ByteStream", "Read"));
- self.inner.server_streaming(req, path, codec).await
- }
- pub async fn write(
- &mut self,
- request: impl tonic::IntoStreamingRequest<Message = super::WriteRequest>,
- ) -> std::result::Result<tonic::Response<super::WriteResponse>, 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.bytestream.ByteStream/Write",
- );
- let mut req = request.into_streaming_request();
- req.extensions_mut()
- .insert(GrpcMethod::new("google.bytestream.ByteStream", "Write"));
- self.inner.client_streaming(req, path, codec).await
- }
- pub async fn query_write_status(
- &mut self,
- request: impl tonic::IntoRequest<super::QueryWriteStatusRequest>,
- ) -> std::result::Result<
- tonic::Response<super::QueryWriteStatusResponse>,
- 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.bytestream.ByteStream/QueryWriteStatus",
- );
- let mut req = request.into_request();
- req.extensions_mut()
- .insert(
- GrpcMethod::new("google.bytestream.ByteStream", "QueryWriteStatus"),
- );
- self.inner.unary(req, path, codec).await
- }
- }
-}
-/// Generated server implementations.
-pub mod byte_stream_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 ByteStreamServer.
- #[async_trait]
- pub trait ByteStream: Send + Sync + 'static {
- /// Server streaming response type for the Read method.
- type ReadStream: tonic::codegen::tokio_stream::Stream<
- Item = std::result::Result<super::ReadResponse, tonic::Status>,
- >
- + Send
- + 'static;
- async fn read(
- &self,
- request: tonic::Request<super::ReadRequest>,
- ) -> std::result::Result<tonic::Response<Self::ReadStream>, tonic::Status>;
- async fn write(
- &self,
- request: tonic::Request<tonic::Streaming<super::WriteRequest>>,
- ) -> std::result::Result<tonic::Response<super::WriteResponse>, tonic::Status>;
- async fn query_write_status(
- &self,
- request: tonic::Request<super::QueryWriteStatusRequest>,
- ) -> std::result::Result<
- tonic::Response<super::QueryWriteStatusResponse>,
- tonic::Status,
- >;
- }
- #[derive(Debug)]
- pub struct ByteStreamServer<T: ByteStream> {
- 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: ByteStream> ByteStreamServer<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 ByteStreamServer<T>
- where
- T: ByteStream,
- 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.bytestream.ByteStream/Read" => {
- #[allow(non_camel_case_types)]
- struct ReadSvc<T: ByteStream>(pub Arc<T>);
- impl<
- T: ByteStream,
- > tonic::server::ServerStreamingService<super::ReadRequest>
- for ReadSvc<T> {
- type Response = super::ReadResponse;
- type ResponseStream = T::ReadStream;
- type Future = BoxFuture<
- tonic::Response<Self::ResponseStream>,
- tonic::Status,
- >;
- fn call(
- &mut self,
- request: tonic::Request<super::ReadRequest>,
- ) -> Self::Future {
- let inner = Arc::clone(&self.0);
- let fut = async move {
- <T as ByteStream>::read(&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 = ReadSvc(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.server_streaming(method, req).await;
- Ok(res)
- };
- Box::pin(fut)
- }
- "/google.bytestream.ByteStream/Write" => {
- #[allow(non_camel_case_types)]
- struct WriteSvc<T: ByteStream>(pub Arc<T>);
- impl<
- T: ByteStream,
- > tonic::server::ClientStreamingService<super::WriteRequest>
- for WriteSvc<T> {
- type Response = super::WriteResponse;
- type Future = BoxFuture<
- tonic::Response<Self::Response>,
- tonic::Status,
- >;
- fn call(
- &mut self,
- request: tonic::Request<
- tonic::Streaming<super::WriteRequest>,
- >,
- ) -> Self::Future {
- let inner = Arc::clone(&self.0);
- let fut = async move {
- <T as ByteStream>::write(&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 = WriteSvc(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)
- }
- "/google.bytestream.ByteStream/QueryWriteStatus" => {
- #[allow(non_camel_case_types)]
- struct QueryWriteStatusSvc<T: ByteStream>(pub Arc<T>);
- impl<
- T: ByteStream,
- > tonic::server::UnaryService<super::QueryWriteStatusRequest>
- for QueryWriteStatusSvc<T> {
- type Response = super::QueryWriteStatusResponse;
- type Future = BoxFuture<
- tonic::Response<Self::Response>,
- tonic::Status,
- >;
- fn call(
- &mut self,
- request: tonic::Request<super::QueryWriteStatusRequest>,
- ) -> Self::Future {
- let inner = Arc::clone(&self.0);
- let fut = async move {
- <T as ByteStream>::query_write_status(&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 = QueryWriteStatusSvc(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: ByteStream> Clone for ByteStreamServer<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: ByteStream> 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: ByteStream> tonic::server::NamedService for ByteStreamServer<T> {
- const NAME: &'static str = "google.bytestream.ByteStream";
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-02 02:52:07 +0000