ydb_grpc/generated/
ydb.scheme.v1.rs

1// This file is @generated by prost-build.
2/// Generated client implementations.
3pub mod scheme_service_client {
4    #![allow(
5        unused_variables,
6        dead_code,
7        missing_docs,
8        clippy::wildcard_imports,
9        clippy::let_unit_value,
10    )]
11    use tonic::codegen::*;
12    use tonic::codegen::http::Uri;
13    #[derive(Debug, Clone)]
14    pub struct SchemeServiceClient<T> {
15        inner: tonic::client::Grpc<T>,
16    }
17    impl SchemeServiceClient<tonic::transport::Channel> {
18        /// Attempt to create a new client by connecting to a given endpoint.
19        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
20        where
21            D: TryInto<tonic::transport::Endpoint>,
22            D::Error: Into<StdError>,
23        {
24            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
25            Ok(Self::new(conn))
26        }
27    }
28    impl<T> SchemeServiceClient<T>
29    where
30        T: tonic::client::GrpcService<tonic::body::Body>,
31        T::Error: Into<StdError>,
32        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
33        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
34    {
35        pub fn new(inner: T) -> Self {
36            let inner = tonic::client::Grpc::new(inner);
37            Self { inner }
38        }
39        pub fn with_origin(inner: T, origin: Uri) -> Self {
40            let inner = tonic::client::Grpc::with_origin(inner, origin);
41            Self { inner }
42        }
43        pub fn with_interceptor<F>(
44            inner: T,
45            interceptor: F,
46        ) -> SchemeServiceClient<InterceptedService<T, F>>
47        where
48            F: tonic::service::Interceptor,
49            T::ResponseBody: Default,
50            T: tonic::codegen::Service<
51                http::Request<tonic::body::Body>,
52                Response = http::Response<
53                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
54                >,
55            >,
56            <T as tonic::codegen::Service<
57                http::Request<tonic::body::Body>,
58            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
59        {
60            SchemeServiceClient::new(InterceptedService::new(inner, interceptor))
61        }
62        /// Compress requests with the given encoding.
63        /// This requires the server to support it otherwise it might respond with an
64        /// error.
65        #[must_use]
66        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
67            self.inner = self.inner.send_compressed(encoding);
68            self
69        }
70        /// Enable decompressing responses.
71        #[must_use]
72        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
73            self.inner = self.inner.accept_compressed(encoding);
74            self
75        }
76        /// Limits the maximum size of a decoded message.
77        /// Default: `4MB`
78        #[must_use]
79        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
80            self.inner = self.inner.max_decoding_message_size(limit);
81            self
82        }
83        /// Limits the maximum size of an encoded message.
84        /// Default: `usize::MAX`
85        #[must_use]
86        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
87            self.inner = self.inner.max_encoding_message_size(limit);
88            self
89        }
90        /// Make Directory.
91        pub async fn make_directory(
92            &mut self,
93            request: impl tonic::IntoRequest<super::super::MakeDirectoryRequest>,
94        ) -> std::result::Result<
95            tonic::Response<super::super::MakeDirectoryResponse>,
96            tonic::Status,
97        > {
98            self.inner
99                .ready()
100                .await
101                .map_err(|e| {
102                    tonic::Status::unknown(
103                        format!("Service was not ready: {}", e.into()),
104                    )
105                })?;
106            let codec = tonic_prost::ProstCodec::default();
107            let path = http::uri::PathAndQuery::from_static(
108                "/Ydb.Scheme.V1.SchemeService/MakeDirectory",
109            );
110            let mut req = request.into_request();
111            req.extensions_mut()
112                .insert(GrpcMethod::new("Ydb.Scheme.V1.SchemeService", "MakeDirectory"));
113            self.inner.unary(req, path, codec).await
114        }
115        /// Remove Directory.
116        pub async fn remove_directory(
117            &mut self,
118            request: impl tonic::IntoRequest<super::super::RemoveDirectoryRequest>,
119        ) -> std::result::Result<
120            tonic::Response<super::super::RemoveDirectoryResponse>,
121            tonic::Status,
122        > {
123            self.inner
124                .ready()
125                .await
126                .map_err(|e| {
127                    tonic::Status::unknown(
128                        format!("Service was not ready: {}", e.into()),
129                    )
130                })?;
131            let codec = tonic_prost::ProstCodec::default();
132            let path = http::uri::PathAndQuery::from_static(
133                "/Ydb.Scheme.V1.SchemeService/RemoveDirectory",
134            );
135            let mut req = request.into_request();
136            req.extensions_mut()
137                .insert(
138                    GrpcMethod::new("Ydb.Scheme.V1.SchemeService", "RemoveDirectory"),
139                );
140            self.inner.unary(req, path, codec).await
141        }
142        /// Returns information about given directory and objects inside it.
143        pub async fn list_directory(
144            &mut self,
145            request: impl tonic::IntoRequest<super::super::ListDirectoryRequest>,
146        ) -> std::result::Result<
147            tonic::Response<super::super::ListDirectoryResponse>,
148            tonic::Status,
149        > {
150            self.inner
151                .ready()
152                .await
153                .map_err(|e| {
154                    tonic::Status::unknown(
155                        format!("Service was not ready: {}", e.into()),
156                    )
157                })?;
158            let codec = tonic_prost::ProstCodec::default();
159            let path = http::uri::PathAndQuery::from_static(
160                "/Ydb.Scheme.V1.SchemeService/ListDirectory",
161            );
162            let mut req = request.into_request();
163            req.extensions_mut()
164                .insert(GrpcMethod::new("Ydb.Scheme.V1.SchemeService", "ListDirectory"));
165            self.inner.unary(req, path, codec).await
166        }
167        /// Returns information about object with given path.
168        pub async fn describe_path(
169            &mut self,
170            request: impl tonic::IntoRequest<super::super::DescribePathRequest>,
171        ) -> std::result::Result<
172            tonic::Response<super::super::DescribePathResponse>,
173            tonic::Status,
174        > {
175            self.inner
176                .ready()
177                .await
178                .map_err(|e| {
179                    tonic::Status::unknown(
180                        format!("Service was not ready: {}", e.into()),
181                    )
182                })?;
183            let codec = tonic_prost::ProstCodec::default();
184            let path = http::uri::PathAndQuery::from_static(
185                "/Ydb.Scheme.V1.SchemeService/DescribePath",
186            );
187            let mut req = request.into_request();
188            req.extensions_mut()
189                .insert(GrpcMethod::new("Ydb.Scheme.V1.SchemeService", "DescribePath"));
190            self.inner.unary(req, path, codec).await
191        }
192        /// Modify permissions.
193        pub async fn modify_permissions(
194            &mut self,
195            request: impl tonic::IntoRequest<super::super::ModifyPermissionsRequest>,
196        ) -> std::result::Result<
197            tonic::Response<super::super::ModifyPermissionsResponse>,
198            tonic::Status,
199        > {
200            self.inner
201                .ready()
202                .await
203                .map_err(|e| {
204                    tonic::Status::unknown(
205                        format!("Service was not ready: {}", e.into()),
206                    )
207                })?;
208            let codec = tonic_prost::ProstCodec::default();
209            let path = http::uri::PathAndQuery::from_static(
210                "/Ydb.Scheme.V1.SchemeService/ModifyPermissions",
211            );
212            let mut req = request.into_request();
213            req.extensions_mut()
214                .insert(
215                    GrpcMethod::new("Ydb.Scheme.V1.SchemeService", "ModifyPermissions"),
216                );
217            self.inner.unary(req, path, codec).await
218        }
219    }
220}