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

nominal_api/proto/
nominal.mesh.v1.rs
