nominal_api/proto/
nominal.mesh.v1.rs

1// This file is @generated by prost-build.
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct Link {
4    /// Unique identifier for this link.
5    #[prost(string, tag = "1")]
6    pub rid: ::prost::alloc::string::String,
7    /// RID of the local resource.
8    #[prost(string, tag = "2")]
9    pub local_resource_rid: ::prost::alloc::string::String,
10    /// RID of the remote resource.
11    #[prost(string, tag = "3")]
12    pub remote_resource_rid: ::prost::alloc::string::String,
13    /// The remote connection to use for this link.
14    #[prost(string, tag = "4")]
15    pub remote_connection_rid: ::prost::alloc::string::String,
16    /// Whether or not the link should be enabled.
17    #[prost(bool, tag = "5")]
18    pub enabled: bool,
19    /// The type of resource this link is for.
20    #[prost(enumeration = "ResourceType", tag = "6")]
21    pub resource_type: i32,
22}
23#[derive(Clone, PartialEq, ::prost::Message)]
24pub struct CreateLinkRequest {
25    /// RID of the local resource.
26    #[prost(string, tag = "1")]
27    pub local_resource_rid: ::prost::alloc::string::String,
28    /// RID of the remote resource.
29    #[prost(string, tag = "2")]
30    pub remote_resource_rid: ::prost::alloc::string::String,
31    /// The remote connection to use for this link.
32    #[prost(string, tag = "3")]
33    pub remote_connection_rid: ::prost::alloc::string::String,
34    /// Whether or not the link should be enabled.
35    #[prost(bool, tag = "4")]
36    pub enabled: bool,
37    /// The type of resource this link is for.
38    #[prost(enumeration = "ResourceType", tag = "5")]
39    pub resource_type: i32,
40    /// The workspace to register the link in. The source must belong to this workspace.
41    #[prost(string, tag = "6")]
42    pub workspace_rid: ::prost::alloc::string::String,
43}
44#[derive(Clone, Copy, PartialEq, ::prost::Message)]
45pub struct CreateLinkResponse {}
46#[derive(Clone, PartialEq, ::prost::Message)]
47pub struct GetLinkRequest {
48    #[prost(string, tag = "1")]
49    pub link_rid: ::prost::alloc::string::String,
50}
51#[derive(Clone, PartialEq, ::prost::Message)]
52pub struct GetLinkResponse {
53    #[prost(message, optional, tag = "1")]
54    pub link: ::core::option::Option<Link>,
55}
56#[derive(Clone, PartialEq, ::prost::Message)]
57pub struct UpdateLinkRequest {
58    /// Used to identify the link.
59    #[prost(string, tag = "1")]
60    pub link_rid: ::prost::alloc::string::String,
61    /// Optional fields to update.
62    #[prost(string, optional, tag = "2")]
63    pub remote_connection_rid: ::core::option::Option<::prost::alloc::string::String>,
64    #[prost(bool, optional, tag = "3")]
65    pub enabled: ::core::option::Option<bool>,
66}
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct UpdateLinkResponse {
69    #[prost(message, optional, tag = "1")]
70    pub link: ::core::option::Option<Link>,
71}
72#[derive(Clone, PartialEq, ::prost::Message)]
73pub struct DeleteLinkRequest {
74    #[prost(string, tag = "1")]
75    pub link_rid: ::prost::alloc::string::String,
76}
77#[derive(Clone, Copy, PartialEq, ::prost::Message)]
78pub struct DeleteLinkResponse {}
79#[derive(Clone, PartialEq, ::prost::Message)]
80pub struct SearchLinksRequest {
81    #[prost(string, tag = "1")]
82    pub workspace_rid: ::prost::alloc::string::String,
83    #[prost(int32, tag = "2")]
84    pub page_size: i32,
85    #[prost(bool, optional, tag = "3")]
86    pub enabled: ::core::option::Option<bool>,
87    #[prost(enumeration = "ResourceType", optional, tag = "4")]
88    pub resource_type: ::core::option::Option<i32>,
89    #[prost(string, optional, tag = "5")]
90    pub local_resource_rid: ::core::option::Option<::prost::alloc::string::String>,
91    #[prost(string, optional, tag = "6")]
92    pub remote_connection_rid: ::core::option::Option<::prost::alloc::string::String>,
93    #[prost(string, optional, tag = "7")]
94    pub page_token: ::core::option::Option<::prost::alloc::string::String>,
95}
96#[derive(Clone, PartialEq, ::prost::Message)]
97pub struct SearchLinksResponse {
98    #[prost(message, repeated, tag = "1")]
99    pub links: ::prost::alloc::vec::Vec<Link>,
100    #[prost(string, optional, tag = "2")]
101    pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
102}
103#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
104#[repr(i32)]
105pub enum ResourceType {
106    Unspecified = 0,
107    Dataset = 1,
108}
109impl ResourceType {
110    /// String value of the enum field names used in the ProtoBuf definition.
111    ///
112    /// The values are not transformed in any way and thus are considered stable
113    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
114    pub fn as_str_name(&self) -> &'static str {
115        match self {
116            Self::Unspecified => "RESOURCE_TYPE_UNSPECIFIED",
117            Self::Dataset => "RESOURCE_TYPE_DATASET",
118        }
119    }
120    /// Creates an enum from field names used in the ProtoBuf definition.
121    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
122        match value {
123            "RESOURCE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
124            "RESOURCE_TYPE_DATASET" => Some(Self::Dataset),
125            _ => None,
126        }
127    }
128}
129/// buf:lint:ignore ENUM_ZERO_VALUE_SUFFIX
130#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
131#[repr(i32)]
132pub enum MeshServiceError {
133    LinkNotFound = 0,
134    LinkAlreadyExists = 1,
135    RemoteConnectionNotFound = 2,
136    RemoteConnectionAlreadyExists = 3,
137    RemoteConnectionHasDependentLinks = 4,
138}
139impl MeshServiceError {
140    /// String value of the enum field names used in the ProtoBuf definition.
141    ///
142    /// The values are not transformed in any way and thus are considered stable
143    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
144    pub fn as_str_name(&self) -> &'static str {
145        match self {
146            Self::LinkNotFound => "MESH_SERVICE_ERROR_LINK_NOT_FOUND",
147            Self::LinkAlreadyExists => "MESH_SERVICE_ERROR_LINK_ALREADY_EXISTS",
148            Self::RemoteConnectionNotFound => {
149                "MESH_SERVICE_ERROR_REMOTE_CONNECTION_NOT_FOUND"
150            }
151            Self::RemoteConnectionAlreadyExists => {
152                "MESH_SERVICE_ERROR_REMOTE_CONNECTION_ALREADY_EXISTS"
153            }
154            Self::RemoteConnectionHasDependentLinks => {
155                "MESH_SERVICE_ERROR_REMOTE_CONNECTION_HAS_DEPENDENT_LINKS"
156            }
157        }
158    }
159    /// Creates an enum from field names used in the ProtoBuf definition.
160    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
161        match value {
162            "MESH_SERVICE_ERROR_LINK_NOT_FOUND" => Some(Self::LinkNotFound),
163            "MESH_SERVICE_ERROR_LINK_ALREADY_EXISTS" => Some(Self::LinkAlreadyExists),
164            "MESH_SERVICE_ERROR_REMOTE_CONNECTION_NOT_FOUND" => {
165                Some(Self::RemoteConnectionNotFound)
166            }
167            "MESH_SERVICE_ERROR_REMOTE_CONNECTION_ALREADY_EXISTS" => {
168                Some(Self::RemoteConnectionAlreadyExists)
169            }
170            "MESH_SERVICE_ERROR_REMOTE_CONNECTION_HAS_DEPENDENT_LINKS" => {
171                Some(Self::RemoteConnectionHasDependentLinks)
172            }
173            _ => None,
174        }
175    }
176}
177#[derive(Clone, PartialEq, ::prost::Message)]
178pub struct RemoteConnection {
179    /// Unique identifier for this remote connection.
180    #[prost(string, tag = "1")]
181    pub rid: ::prost::alloc::string::String,
182    /// Human readable name for this remote connection.
183    #[prost(string, tag = "2")]
184    pub name: ::prost::alloc::string::String,
185    /// Base URL for the remote environment.
186    #[prost(string, tag = "3")]
187    pub base_url: ::prost::alloc::string::String,
188    /// Secret to be used to authenticate with the remote environment.
189    #[prost(string, tag = "4")]
190    pub secret_rid: ::prost::alloc::string::String,
191}
192#[derive(Clone, PartialEq, ::prost::Message)]
193pub struct CreateRemoteConnectionRequest {
194    #[prost(string, tag = "1")]
195    pub name: ::prost::alloc::string::String,
196    #[prost(string, tag = "2")]
197    pub base_url: ::prost::alloc::string::String,
198    #[prost(string, tag = "3")]
199    pub secret_rid: ::prost::alloc::string::String,
200    /// The workspace to register the remote connection in.
201    #[prost(string, tag = "4")]
202    pub workspace_rid: ::prost::alloc::string::String,
203}
204#[derive(Clone, PartialEq, ::prost::Message)]
205pub struct CreateRemoteConnectionResponse {
206    #[prost(message, optional, tag = "1")]
207    pub remote_connection: ::core::option::Option<RemoteConnection>,
208}
209#[derive(Clone, PartialEq, ::prost::Message)]
210pub struct GetRemoteConnectionRequest {
211    #[prost(string, tag = "1")]
212    pub remote_connection_rid: ::prost::alloc::string::String,
213}
214#[derive(Clone, PartialEq, ::prost::Message)]
215pub struct GetRemoteConnectionResponse {
216    #[prost(message, optional, tag = "1")]
217    pub remote_connection: ::core::option::Option<RemoteConnection>,
218}
219#[derive(Clone, PartialEq, ::prost::Message)]
220pub struct UpdateRemoteConnectionRequest {
221    #[prost(string, tag = "1")]
222    pub remote_connection_rid: ::prost::alloc::string::String,
223    #[prost(string, optional, tag = "2")]
224    pub name: ::core::option::Option<::prost::alloc::string::String>,
225    #[prost(string, optional, tag = "3")]
226    pub base_url: ::core::option::Option<::prost::alloc::string::String>,
227    #[prost(string, optional, tag = "4")]
228    pub secret_rid: ::core::option::Option<::prost::alloc::string::String>,
229}
230#[derive(Clone, PartialEq, ::prost::Message)]
231pub struct UpdateRemoteConnectionResponse {
232    #[prost(message, optional, tag = "1")]
233    pub remote_connection: ::core::option::Option<RemoteConnection>,
234}
235#[derive(Clone, PartialEq, ::prost::Message)]
236pub struct DeleteRemoteConnectionRequest {
237    #[prost(string, tag = "1")]
238    pub remote_connection_rid: ::prost::alloc::string::String,
239}
240#[derive(Clone, Copy, PartialEq, ::prost::Message)]
241pub struct DeleteRemoteConnectionResponse {}
242#[derive(Clone, PartialEq, ::prost::Message)]
243pub struct ListRemoteConnectionsRequest {
244    /// The workspace to list remote connections for.
245    #[prost(string, tag = "1")]
246    pub workspace_rid: ::prost::alloc::string::String,
247    /// Maximum number of remote connections to return per page.
248    #[prost(int32, tag = "2")]
249    pub page_size: i32,
250    /// Token for pagination. If empty, returns the first page.
251    #[prost(string, optional, tag = "3")]
252    pub page_token: ::core::option::Option<::prost::alloc::string::String>,
253}
254#[derive(Clone, PartialEq, ::prost::Message)]
255pub struct ListRemoteConnectionsResponse {
256    #[prost(message, repeated, tag = "1")]
257    pub remote_connections: ::prost::alloc::vec::Vec<RemoteConnection>,
258    /// Token for retrieving the next page of results. Empty if no more pages.
259    #[prost(string, optional, tag = "2")]
260    pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
261}
262/// This is the proto that is sent to remote environments to request mesh operations.
263#[derive(Clone, PartialEq, ::prost::Message)]
264pub struct MeshRequest {
265    #[prost(oneof = "mesh_request::Request", tags = "1, 2")]
266    pub request: ::core::option::Option<mesh_request::Request>,
267}
268/// Nested message and enum types in `MeshRequest`.
269pub mod mesh_request {
270    #[derive(Clone, PartialEq, ::prost::Oneof)]
271    pub enum Request {
272        #[prost(message, tag = "1")]
273        DataStream(super::DataStreamRequest),
274        #[prost(message, tag = "2")]
275        FileIngest(super::FileIngestRequest),
276    }
277}
278#[derive(Clone, Copy, PartialEq, ::prost::Message)]
279pub struct MeshResponse {}
280#[derive(Clone, PartialEq, ::prost::Message)]
281pub struct DataStreamRequest {
282    #[prost(message, repeated, tag = "1")]
283    pub write_batches_request: ::prost::alloc::vec::Vec<
284        super::super::direct_channel_writer::v2::WriteBatchesRequest,
285    >,
286}
287#[derive(Clone, PartialEq, ::prost::Message)]
288pub struct FileIngestRequest {
289    /// JSON-serialized conjure IngestRequest (io.nominal.ingest.api.IngestRequest).
290    /// The receiving side deserializes this using a conjure ObjectMapper.
291    #[prost(bytes = "vec", tag = "1")]
292    pub ingest_request: ::prost::alloc::vec::Vec<u8>,
293}
294#[derive(Clone, Copy, PartialEq, ::prost::Message)]
295pub struct HealthCheckRequest {}
296#[derive(Clone, Copy, PartialEq, ::prost::Message)]
297pub struct HealthCheckResponse {}
298/// Generated client implementations.
299pub mod mesh_service_client {
300    #![allow(
301        unused_variables,
302        dead_code,
303        missing_docs,
304        clippy::wildcard_imports,
305        clippy::let_unit_value,
306    )]
307    use tonic::codegen::*;
308    use tonic::codegen::http::Uri;
309    /// Manages mesh links between local and remote environments.
310    #[derive(Debug, Clone)]
311    pub struct MeshServiceClient<T> {
312        inner: tonic::client::Grpc<T>,
313    }
314    impl MeshServiceClient<tonic::transport::Channel> {
315        /// Attempt to create a new client by connecting to a given endpoint.
316        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
317        where
318            D: TryInto<tonic::transport::Endpoint>,
319            D::Error: Into<StdError>,
320        {
321            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
322            Ok(Self::new(conn))
323        }
324    }
325    impl<T> MeshServiceClient<T>
326    where
327        T: tonic::client::GrpcService<tonic::body::Body>,
328        T::Error: Into<StdError>,
329        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
330        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
331    {
332        pub fn new(inner: T) -> Self {
333            let inner = tonic::client::Grpc::new(inner);
334            Self { inner }
335        }
336        pub fn with_origin(inner: T, origin: Uri) -> Self {
337            let inner = tonic::client::Grpc::with_origin(inner, origin);
338            Self { inner }
339        }
340        pub fn with_interceptor<F>(
341            inner: T,
342            interceptor: F,
343        ) -> MeshServiceClient<InterceptedService<T, F>>
344        where
345            F: tonic::service::Interceptor,
346            T::ResponseBody: Default,
347            T: tonic::codegen::Service<
348                http::Request<tonic::body::Body>,
349                Response = http::Response<
350                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
351                >,
352            >,
353            <T as tonic::codegen::Service<
354                http::Request<tonic::body::Body>,
355            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
356        {
357            MeshServiceClient::new(InterceptedService::new(inner, interceptor))
358        }
359        /// Compress requests with the given encoding.
360        ///
361        /// This requires the server to support it otherwise it might respond with an
362        /// error.
363        #[must_use]
364        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
365            self.inner = self.inner.send_compressed(encoding);
366            self
367        }
368        /// Enable decompressing responses.
369        #[must_use]
370        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
371            self.inner = self.inner.accept_compressed(encoding);
372            self
373        }
374        /// Limits the maximum size of a decoded message.
375        ///
376        /// Default: `4MB`
377        #[must_use]
378        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
379            self.inner = self.inner.max_decoding_message_size(limit);
380            self
381        }
382        /// Limits the maximum size of an encoded message.
383        ///
384        /// Default: `usize::MAX`
385        #[must_use]
386        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
387            self.inner = self.inner.max_encoding_message_size(limit);
388            self
389        }
390        /// Core Mesh operations.
391        /// ------------------------------------------------------------------------------------------------------------
392        /// Used to mesh resources between stacks.
393        pub async fn mesh(
394            &mut self,
395            request: impl tonic::IntoRequest<super::MeshRequest>,
396        ) -> std::result::Result<tonic::Response<super::MeshResponse>, tonic::Status> {
397            self.inner
398                .ready()
399                .await
400                .map_err(|e| {
401                    tonic::Status::unknown(
402                        format!("Service was not ready: {}", e.into()),
403                    )
404                })?;
405            let codec = tonic::codec::ProstCodec::default();
406            let path = http::uri::PathAndQuery::from_static(
407                "/nominal.mesh.v1.MeshService/Mesh",
408            );
409            let mut req = request.into_request();
410            req.extensions_mut()
411                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "Mesh"));
412            self.inner.unary(req, path, codec).await
413        }
414        /// Used to determine the health of a stack and its availability for meshing.
415        pub async fn health_check(
416            &mut self,
417            request: impl tonic::IntoRequest<super::HealthCheckRequest>,
418        ) -> std::result::Result<
419            tonic::Response<super::HealthCheckResponse>,
420            tonic::Status,
421        > {
422            self.inner
423                .ready()
424                .await
425                .map_err(|e| {
426                    tonic::Status::unknown(
427                        format!("Service was not ready: {}", e.into()),
428                    )
429                })?;
430            let codec = tonic::codec::ProstCodec::default();
431            let path = http::uri::PathAndQuery::from_static(
432                "/nominal.mesh.v1.MeshService/HealthCheck",
433            );
434            let mut req = request.into_request();
435            req.extensions_mut()
436                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "HealthCheck"));
437            self.inner.unary(req, path, codec).await
438        }
439        /// Link operations.
440        /// ------------------------------------------------------------------------------------------------------------
441        /// Creates a link which allows the specified resource to be synced between mesh environments.
442        /// Throws MESH_SERVICE_ERROR_LINK_ALREADY_EXISTS if a link already exists.
443        pub async fn create_link(
444            &mut self,
445            request: impl tonic::IntoRequest<super::CreateLinkRequest>,
446        ) -> std::result::Result<
447            tonic::Response<super::CreateLinkResponse>,
448            tonic::Status,
449        > {
450            self.inner
451                .ready()
452                .await
453                .map_err(|e| {
454                    tonic::Status::unknown(
455                        format!("Service was not ready: {}", e.into()),
456                    )
457                })?;
458            let codec = tonic::codec::ProstCodec::default();
459            let path = http::uri::PathAndQuery::from_static(
460                "/nominal.mesh.v1.MeshService/CreateLink",
461            );
462            let mut req = request.into_request();
463            req.extensions_mut()
464                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "CreateLink"));
465            self.inner.unary(req, path, codec).await
466        }
467        /// Retrieves a link for the requested resource, throwing MESH_SERVICE_ERROR_LINK_NOT_FOUND if there is no link.
468        pub async fn get_link(
469            &mut self,
470            request: impl tonic::IntoRequest<super::GetLinkRequest>,
471        ) -> std::result::Result<
472            tonic::Response<super::GetLinkResponse>,
473            tonic::Status,
474        > {
475            self.inner
476                .ready()
477                .await
478                .map_err(|e| {
479                    tonic::Status::unknown(
480                        format!("Service was not ready: {}", e.into()),
481                    )
482                })?;
483            let codec = tonic::codec::ProstCodec::default();
484            let path = http::uri::PathAndQuery::from_static(
485                "/nominal.mesh.v1.MeshService/GetLink",
486            );
487            let mut req = request.into_request();
488            req.extensions_mut()
489                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "GetLink"));
490            self.inner.unary(req, path, codec).await
491        }
492        /// Updates a link for the requested resource, throwing MESH_SERVICE_ERROR_LINK_NOT_FOUND if there is no link.
493        pub async fn update_link(
494            &mut self,
495            request: impl tonic::IntoRequest<super::UpdateLinkRequest>,
496        ) -> std::result::Result<
497            tonic::Response<super::UpdateLinkResponse>,
498            tonic::Status,
499        > {
500            self.inner
501                .ready()
502                .await
503                .map_err(|e| {
504                    tonic::Status::unknown(
505                        format!("Service was not ready: {}", e.into()),
506                    )
507                })?;
508            let codec = tonic::codec::ProstCodec::default();
509            let path = http::uri::PathAndQuery::from_static(
510                "/nominal.mesh.v1.MeshService/UpdateLink",
511            );
512            let mut req = request.into_request();
513            req.extensions_mut()
514                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "UpdateLink"));
515            self.inner.unary(req, path, codec).await
516        }
517        /// Deletes a link for the specified resource.
518        pub async fn delete_link(
519            &mut self,
520            request: impl tonic::IntoRequest<super::DeleteLinkRequest>,
521        ) -> std::result::Result<
522            tonic::Response<super::DeleteLinkResponse>,
523            tonic::Status,
524        > {
525            self.inner
526                .ready()
527                .await
528                .map_err(|e| {
529                    tonic::Status::unknown(
530                        format!("Service was not ready: {}", e.into()),
531                    )
532                })?;
533            let codec = tonic::codec::ProstCodec::default();
534            let path = http::uri::PathAndQuery::from_static(
535                "/nominal.mesh.v1.MeshService/DeleteLink",
536            );
537            let mut req = request.into_request();
538            req.extensions_mut()
539                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "DeleteLink"));
540            self.inner.unary(req, path, codec).await
541        }
542        /// Searches for links with optional filters and pagination.
543        pub async fn search_links(
544            &mut self,
545            request: impl tonic::IntoRequest<super::SearchLinksRequest>,
546        ) -> std::result::Result<
547            tonic::Response<super::SearchLinksResponse>,
548            tonic::Status,
549        > {
550            self.inner
551                .ready()
552                .await
553                .map_err(|e| {
554                    tonic::Status::unknown(
555                        format!("Service was not ready: {}", e.into()),
556                    )
557                })?;
558            let codec = tonic::codec::ProstCodec::default();
559            let path = http::uri::PathAndQuery::from_static(
560                "/nominal.mesh.v1.MeshService/SearchLinks",
561            );
562            let mut req = request.into_request();
563            req.extensions_mut()
564                .insert(GrpcMethod::new("nominal.mesh.v1.MeshService", "SearchLinks"));
565            self.inner.unary(req, path, codec).await
566        }
567        /// Remote Connection operations.
568        /// ------------------------------------------------------------------------------------------------------------
569        /// Creates a remote connection for mesh links.
570        /// Throws MESH_SERVICE_ERROR_REMOTE_CONNECTION_ALREADY_EXISTS if a remote connection with the same name already exists.
571        pub async fn create_remote_connection(
572            &mut self,
573            request: impl tonic::IntoRequest<super::CreateRemoteConnectionRequest>,
574        ) -> std::result::Result<
575            tonic::Response<super::CreateRemoteConnectionResponse>,
576            tonic::Status,
577        > {
578            self.inner
579                .ready()
580                .await
581                .map_err(|e| {
582                    tonic::Status::unknown(
583                        format!("Service was not ready: {}", e.into()),
584                    )
585                })?;
586            let codec = tonic::codec::ProstCodec::default();
587            let path = http::uri::PathAndQuery::from_static(
588                "/nominal.mesh.v1.MeshService/CreateRemoteConnection",
589            );
590            let mut req = request.into_request();
591            req.extensions_mut()
592                .insert(
593                    GrpcMethod::new(
594                        "nominal.mesh.v1.MeshService",
595                        "CreateRemoteConnection",
596                    ),
597                );
598            self.inner.unary(req, path, codec).await
599        }
600        /// Retrieves a remote connection by RID.
601        /// Throws MESH_SERVICE_ERROR_REMOTE_CONNECTION_NOT_FOUND if there is no remote connection.
602        pub async fn get_remote_connection(
603            &mut self,
604            request: impl tonic::IntoRequest<super::GetRemoteConnectionRequest>,
605        ) -> std::result::Result<
606            tonic::Response<super::GetRemoteConnectionResponse>,
607            tonic::Status,
608        > {
609            self.inner
610                .ready()
611                .await
612                .map_err(|e| {
613                    tonic::Status::unknown(
614                        format!("Service was not ready: {}", e.into()),
615                    )
616                })?;
617            let codec = tonic::codec::ProstCodec::default();
618            let path = http::uri::PathAndQuery::from_static(
619                "/nominal.mesh.v1.MeshService/GetRemoteConnection",
620            );
621            let mut req = request.into_request();
622            req.extensions_mut()
623                .insert(
624                    GrpcMethod::new("nominal.mesh.v1.MeshService", "GetRemoteConnection"),
625                );
626            self.inner.unary(req, path, codec).await
627        }
628        /// Updates a remote connection by RID.
629        /// Throws MESH_SERVICE_ERROR_REMOTE_CONNECTION_NOT_FOUND if there is no remote connection.
630        pub async fn update_remote_connection(
631            &mut self,
632            request: impl tonic::IntoRequest<super::UpdateRemoteConnectionRequest>,
633        ) -> std::result::Result<
634            tonic::Response<super::UpdateRemoteConnectionResponse>,
635            tonic::Status,
636        > {
637            self.inner
638                .ready()
639                .await
640                .map_err(|e| {
641                    tonic::Status::unknown(
642                        format!("Service was not ready: {}", e.into()),
643                    )
644                })?;
645            let codec = tonic::codec::ProstCodec::default();
646            let path = http::uri::PathAndQuery::from_static(
647                "/nominal.mesh.v1.MeshService/UpdateRemoteConnection",
648            );
649            let mut req = request.into_request();
650            req.extensions_mut()
651                .insert(
652                    GrpcMethod::new(
653                        "nominal.mesh.v1.MeshService",
654                        "UpdateRemoteConnection",
655                    ),
656                );
657            self.inner.unary(req, path, codec).await
658        }
659        /// Deletes a remote connection by RID.
660        pub async fn delete_remote_connection(
661            &mut self,
662            request: impl tonic::IntoRequest<super::DeleteRemoteConnectionRequest>,
663        ) -> std::result::Result<
664            tonic::Response<super::DeleteRemoteConnectionResponse>,
665            tonic::Status,
666        > {
667            self.inner
668                .ready()
669                .await
670                .map_err(|e| {
671                    tonic::Status::unknown(
672                        format!("Service was not ready: {}", e.into()),
673                    )
674                })?;
675            let codec = tonic::codec::ProstCodec::default();
676            let path = http::uri::PathAndQuery::from_static(
677                "/nominal.mesh.v1.MeshService/DeleteRemoteConnection",
678            );
679            let mut req = request.into_request();
680            req.extensions_mut()
681                .insert(
682                    GrpcMethod::new(
683                        "nominal.mesh.v1.MeshService",
684                        "DeleteRemoteConnection",
685                    ),
686                );
687            self.inner.unary(req, path, codec).await
688        }
689        /// Lists all remote connections.
690        pub async fn list_remote_connections(
691            &mut self,
692            request: impl tonic::IntoRequest<super::ListRemoteConnectionsRequest>,
693        ) -> std::result::Result<
694            tonic::Response<super::ListRemoteConnectionsResponse>,
695            tonic::Status,
696        > {
697            self.inner
698                .ready()
699                .await
700                .map_err(|e| {
701                    tonic::Status::unknown(
702                        format!("Service was not ready: {}", e.into()),
703                    )
704                })?;
705            let codec = tonic::codec::ProstCodec::default();
706            let path = http::uri::PathAndQuery::from_static(
707                "/nominal.mesh.v1.MeshService/ListRemoteConnections",
708            );
709            let mut req = request.into_request();
710            req.extensions_mut()
711                .insert(
712                    GrpcMethod::new(
713                        "nominal.mesh.v1.MeshService",
714                        "ListRemoteConnections",
715                    ),
716                );
717            self.inner.unary(req, path, codec).await
718        }
719    }
720}
nominal_api/proto/nominal.mesh.v1.rs

nominal_api/proto/
nominal.mesh.v1.rs
