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

nominal_api/proto/
nominal.mesh.v1.rs
