weaverpb/generated/
relay.datatransfer.rs

1/// Generated client implementations.
2pub mod data_transfer_client {
3    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
4    use tonic::codegen::*;
5    use tonic::codegen::http::Uri;
6    /// definitions of all messages used in the datatransfer protocol
7    #[derive(Debug, Clone)]
8    pub struct DataTransferClient<T> {
9        inner: tonic::client::Grpc<T>,
10    }
11    impl DataTransferClient<tonic::transport::Channel> {
12        /// Attempt to create a new client by connecting to a given endpoint.
13        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
14        where
15            D: std::convert::TryInto<tonic::transport::Endpoint>,
16            D::Error: Into<StdError>,
17        {
18            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
19            Ok(Self::new(conn))
20        }
21    }
22    impl<T> DataTransferClient<T>
23    where
24        T: tonic::client::GrpcService<tonic::body::BoxBody>,
25        T::Error: Into<StdError>,
26        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
27        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
28    {
29        pub fn new(inner: T) -> Self {
30            let inner = tonic::client::Grpc::new(inner);
31            Self { inner }
32        }
33        pub fn with_origin(inner: T, origin: Uri) -> Self {
34            let inner = tonic::client::Grpc::with_origin(inner, origin);
35            Self { inner }
36        }
37        pub fn with_interceptor<F>(
38            inner: T,
39            interceptor: F,
40        ) -> DataTransferClient<InterceptedService<T, F>>
41        where
42            F: tonic::service::Interceptor,
43            T::ResponseBody: Default,
44            T: tonic::codegen::Service<
45                http::Request<tonic::body::BoxBody>,
46                Response = http::Response<
47                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
48                >,
49            >,
50            <T as tonic::codegen::Service<
51                http::Request<tonic::body::BoxBody>,
52            >>::Error: Into<StdError> + Send + Sync,
53        {
54            DataTransferClient::new(InterceptedService::new(inner, interceptor))
55        }
56        /// Compress requests with the given encoding.
57        ///
58        /// This requires the server to support it otherwise it might respond with an
59        /// error.
60        #[must_use]
61        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
62            self.inner = self.inner.send_compressed(encoding);
63            self
64        }
65        /// Enable decompressing responses.
66        #[must_use]
67        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
68            self.inner = self.inner.accept_compressed(encoding);
69            self
70        }
71        /// the requesting relay sends a RequestState request to the remote relay with a
72        /// query defining the data it wants to receive
73        pub async fn request_state(
74            &mut self,
75            request: impl tonic::IntoRequest<super::super::super::common::query::Query>,
76        ) -> Result<
77            tonic::Response<super::super::super::common::ack::Ack>,
78            tonic::Status,
79        > {
80            self.inner
81                .ready()
82                .await
83                .map_err(|e| {
84                    tonic::Status::new(
85                        tonic::Code::Unknown,
86                        format!("Service was not ready: {}", e.into()),
87                    )
88                })?;
89            let codec = tonic::codec::ProstCodec::default();
90            let path = http::uri::PathAndQuery::from_static(
91                "/relay.datatransfer.DataTransfer/RequestState",
92            );
93            self.inner.unary(request.into_request(), path, codec).await
94        }
95        /// the remote relay asynchronously sends back the requested data with
96        /// SendState
97        pub async fn send_state(
98            &mut self,
99            request: impl tonic::IntoRequest<
100                super::super::super::common::state::ViewPayload,
101            >,
102        ) -> Result<
103            tonic::Response<super::super::super::common::ack::Ack>,
104            tonic::Status,
105        > {
106            self.inner
107                .ready()
108                .await
109                .map_err(|e| {
110                    tonic::Status::new(
111                        tonic::Code::Unknown,
112                        format!("Service was not ready: {}", e.into()),
113                    )
114                })?;
115            let codec = tonic::codec::ProstCodec::default();
116            let path = http::uri::PathAndQuery::from_static(
117                "/relay.datatransfer.DataTransfer/SendState",
118            );
119            self.inner.unary(request.into_request(), path, codec).await
120        }
121        /// Handling state sent from the driver.
122        pub async fn send_driver_state(
123            &mut self,
124            request: impl tonic::IntoRequest<
125                super::super::super::common::state::ViewPayload,
126            >,
127        ) -> Result<
128            tonic::Response<super::super::super::common::ack::Ack>,
129            tonic::Status,
130        > {
131            self.inner
132                .ready()
133                .await
134                .map_err(|e| {
135                    tonic::Status::new(
136                        tonic::Code::Unknown,
137                        format!("Service was not ready: {}", e.into()),
138                    )
139                })?;
140            let codec = tonic::codec::ProstCodec::default();
141            let path = http::uri::PathAndQuery::from_static(
142                "/relay.datatransfer.DataTransfer/SendDriverState",
143            );
144            self.inner.unary(request.into_request(), path, codec).await
145        }
146    }
147}
148/// Generated server implementations.
149pub mod data_transfer_server {
150    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
151    use tonic::codegen::*;
152    /// Generated trait containing gRPC methods that should be implemented for use with DataTransferServer.
153    #[async_trait]
154    pub trait DataTransfer: Send + Sync + 'static {
155        /// the requesting relay sends a RequestState request to the remote relay with a
156        /// query defining the data it wants to receive
157        async fn request_state(
158            &self,
159            request: tonic::Request<super::super::super::common::query::Query>,
160        ) -> Result<
161            tonic::Response<super::super::super::common::ack::Ack>,
162            tonic::Status,
163        >;
164        /// the remote relay asynchronously sends back the requested data with
165        /// SendState
166        async fn send_state(
167            &self,
168            request: tonic::Request<super::super::super::common::state::ViewPayload>,
169        ) -> Result<
170            tonic::Response<super::super::super::common::ack::Ack>,
171            tonic::Status,
172        >;
173        /// Handling state sent from the driver.
174        async fn send_driver_state(
175            &self,
176            request: tonic::Request<super::super::super::common::state::ViewPayload>,
177        ) -> Result<
178            tonic::Response<super::super::super::common::ack::Ack>,
179            tonic::Status,
180        >;
181    }
182    /// definitions of all messages used in the datatransfer protocol
183    #[derive(Debug)]
184    pub struct DataTransferServer<T: DataTransfer> {
185        inner: _Inner<T>,
186        accept_compression_encodings: EnabledCompressionEncodings,
187        send_compression_encodings: EnabledCompressionEncodings,
188    }
189    struct _Inner<T>(Arc<T>);
190    impl<T: DataTransfer> DataTransferServer<T> {
191        pub fn new(inner: T) -> Self {
192            Self::from_arc(Arc::new(inner))
193        }
194        pub fn from_arc(inner: Arc<T>) -> Self {
195            let inner = _Inner(inner);
196            Self {
197                inner,
198                accept_compression_encodings: Default::default(),
199                send_compression_encodings: Default::default(),
200            }
201        }
202        pub fn with_interceptor<F>(
203            inner: T,
204            interceptor: F,
205        ) -> InterceptedService<Self, F>
206        where
207            F: tonic::service::Interceptor,
208        {
209            InterceptedService::new(Self::new(inner), interceptor)
210        }
211        /// Enable decompressing requests with the given encoding.
212        #[must_use]
213        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
214            self.accept_compression_encodings.enable(encoding);
215            self
216        }
217        /// Compress responses with the given encoding, if the client supports it.
218        #[must_use]
219        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
220            self.send_compression_encodings.enable(encoding);
221            self
222        }
223    }
224    impl<T, B> tonic::codegen::Service<http::Request<B>> for DataTransferServer<T>
225    where
226        T: DataTransfer,
227        B: Body + Send + 'static,
228        B::Error: Into<StdError> + Send + 'static,
229    {
230        type Response = http::Response<tonic::body::BoxBody>;
231        type Error = std::convert::Infallible;
232        type Future = BoxFuture<Self::Response, Self::Error>;
233        fn poll_ready(
234            &mut self,
235            _cx: &mut Context<'_>,
236        ) -> Poll<Result<(), Self::Error>> {
237            Poll::Ready(Ok(()))
238        }
239        fn call(&mut self, req: http::Request<B>) -> Self::Future {
240            let inner = self.inner.clone();
241            match req.uri().path() {
242                "/relay.datatransfer.DataTransfer/RequestState" => {
243                    #[allow(non_camel_case_types)]
244                    struct RequestStateSvc<T: DataTransfer>(pub Arc<T>);
245                    impl<
246                        T: DataTransfer,
247                    > tonic::server::UnaryService<
248                        super::super::super::common::query::Query,
249                    > for RequestStateSvc<T> {
250                        type Response = super::super::super::common::ack::Ack;
251                        type Future = BoxFuture<
252                            tonic::Response<Self::Response>,
253                            tonic::Status,
254                        >;
255                        fn call(
256                            &mut self,
257                            request: tonic::Request<
258                                super::super::super::common::query::Query,
259                            >,
260                        ) -> Self::Future {
261                            let inner = self.0.clone();
262                            let fut = async move {
263                                (*inner).request_state(request).await
264                            };
265                            Box::pin(fut)
266                        }
267                    }
268                    let accept_compression_encodings = self.accept_compression_encodings;
269                    let send_compression_encodings = self.send_compression_encodings;
270                    let inner = self.inner.clone();
271                    let fut = async move {
272                        let inner = inner.0;
273                        let method = RequestStateSvc(inner);
274                        let codec = tonic::codec::ProstCodec::default();
275                        let mut grpc = tonic::server::Grpc::new(codec)
276                            .apply_compression_config(
277                                accept_compression_encodings,
278                                send_compression_encodings,
279                            );
280                        let res = grpc.unary(method, req).await;
281                        Ok(res)
282                    };
283                    Box::pin(fut)
284                }
285                "/relay.datatransfer.DataTransfer/SendState" => {
286                    #[allow(non_camel_case_types)]
287                    struct SendStateSvc<T: DataTransfer>(pub Arc<T>);
288                    impl<
289                        T: DataTransfer,
290                    > tonic::server::UnaryService<
291                        super::super::super::common::state::ViewPayload,
292                    > for SendStateSvc<T> {
293                        type Response = super::super::super::common::ack::Ack;
294                        type Future = BoxFuture<
295                            tonic::Response<Self::Response>,
296                            tonic::Status,
297                        >;
298                        fn call(
299                            &mut self,
300                            request: tonic::Request<
301                                super::super::super::common::state::ViewPayload,
302                            >,
303                        ) -> Self::Future {
304                            let inner = self.0.clone();
305                            let fut = async move { (*inner).send_state(request).await };
306                            Box::pin(fut)
307                        }
308                    }
309                    let accept_compression_encodings = self.accept_compression_encodings;
310                    let send_compression_encodings = self.send_compression_encodings;
311                    let inner = self.inner.clone();
312                    let fut = async move {
313                        let inner = inner.0;
314                        let method = SendStateSvc(inner);
315                        let codec = tonic::codec::ProstCodec::default();
316                        let mut grpc = tonic::server::Grpc::new(codec)
317                            .apply_compression_config(
318                                accept_compression_encodings,
319                                send_compression_encodings,
320                            );
321                        let res = grpc.unary(method, req).await;
322                        Ok(res)
323                    };
324                    Box::pin(fut)
325                }
326                "/relay.datatransfer.DataTransfer/SendDriverState" => {
327                    #[allow(non_camel_case_types)]
328                    struct SendDriverStateSvc<T: DataTransfer>(pub Arc<T>);
329                    impl<
330                        T: DataTransfer,
331                    > tonic::server::UnaryService<
332                        super::super::super::common::state::ViewPayload,
333                    > for SendDriverStateSvc<T> {
334                        type Response = super::super::super::common::ack::Ack;
335                        type Future = BoxFuture<
336                            tonic::Response<Self::Response>,
337                            tonic::Status,
338                        >;
339                        fn call(
340                            &mut self,
341                            request: tonic::Request<
342                                super::super::super::common::state::ViewPayload,
343                            >,
344                        ) -> Self::Future {
345                            let inner = self.0.clone();
346                            let fut = async move {
347                                (*inner).send_driver_state(request).await
348                            };
349                            Box::pin(fut)
350                        }
351                    }
352                    let accept_compression_encodings = self.accept_compression_encodings;
353                    let send_compression_encodings = self.send_compression_encodings;
354                    let inner = self.inner.clone();
355                    let fut = async move {
356                        let inner = inner.0;
357                        let method = SendDriverStateSvc(inner);
358                        let codec = tonic::codec::ProstCodec::default();
359                        let mut grpc = tonic::server::Grpc::new(codec)
360                            .apply_compression_config(
361                                accept_compression_encodings,
362                                send_compression_encodings,
363                            );
364                        let res = grpc.unary(method, req).await;
365                        Ok(res)
366                    };
367                    Box::pin(fut)
368                }
369                _ => {
370                    Box::pin(async move {
371                        Ok(
372                            http::Response::builder()
373                                .status(200)
374                                .header("grpc-status", "12")
375                                .header("content-type", "application/grpc")
376                                .body(empty_body())
377                                .unwrap(),
378                        )
379                    })
380                }
381            }
382        }
383    }
384    impl<T: DataTransfer> Clone for DataTransferServer<T> {
385        fn clone(&self) -> Self {
386            let inner = self.inner.clone();
387            Self {
388                inner,
389                accept_compression_encodings: self.accept_compression_encodings,
390                send_compression_encodings: self.send_compression_encodings,
391            }
392        }
393    }
394    impl<T: DataTransfer> Clone for _Inner<T> {
395        fn clone(&self) -> Self {
396            Self(self.0.clone())
397        }
398    }
399    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
400        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401            write!(f, "{:?}", self.0)
402        }
403    }
404    impl<T: DataTransfer> tonic::server::NamedService for DataTransferServer<T> {
405        const NAME: &'static str = "relay.datatransfer.DataTransfer";
406    }
407}
weaverpb/generated/relay.datatransfer.rs

weaverpb/generated/
relay.datatransfer.rs
