nominal_api/proto/
nominal.mesh.v1.rs

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

nominal_api/proto/
nominal.mesh.v1.rs
