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

nominal_api/proto/
nominal.mesh.v1.rs
