Skip to main content

gestalt/
remote.rs

1// Code generated by sdkgen. DO NOT EDIT.
2
3//! Generated native types and clients for remote.proto.
4
5use crate::codec::remote::{
6    from_wire_list_remotes_response, from_wire_registration_check_response, from_wire_remote,
7    to_wire_create_remote_request, to_wire_delete_remote_request, to_wire_list_remotes_request,
8    to_wire_registration_check_request,
9};
10use crate::generated::v1;
11use crate::rpc_support::GestaltError;
12
13/// Native message type for `gestalt.provider.v1.CreateRemoteRequest`.
14#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
15#[serde(rename_all = "camelCase")]
16pub struct CreateRemoteRequest {
17    /// The `tunnel` field; None when unset.
18    pub tunnel: Option<TunnelEndpoint>,
19    /// The `providers` field.
20    pub providers: Vec<RemoteProviderDefinition>,
21    /// The `expected_generation` field.
22    pub expected_generation: u64,
23}
24
25/// Native message type for `gestalt.provider.v1.DeleteRemoteRequest`.
26#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
27#[serde(rename_all = "camelCase")]
28pub struct DeleteRemoteRequest {
29    /// The `id` field.
30    pub id: String,
31    /// The `expected_generation` field.
32    pub expected_generation: u64,
33}
34
35/// Native message type for `gestalt.provider.v1.ListRemotesRequest`.
36#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
37#[serde(rename_all = "camelCase")]
38pub struct ListRemotesRequest {}
39
40/// Native message type for `gestalt.provider.v1.ListRemotesResponse`.
41#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
42#[serde(rename_all = "camelCase")]
43pub struct ListRemotesResponse {
44    /// The `remotes` field.
45    pub remotes: Vec<Remote>,
46    /// The `server_identity` field; None when unset.
47    pub server_identity: Option<ServerIdentity>,
48    /// The `tunnel` field; None when unset.
49    pub tunnel: Option<TunnelBootstrap>,
50    #[serde(with = "crate::serde_duration")]
51    /// The `lease_duration` field; None when unset.
52    pub lease_duration: Option<std::time::Duration>,
53}
54
55/// Native message type for `gestalt.provider.v1.ProviderRef`.
56#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
57#[serde(rename_all = "camelCase")]
58pub struct ProviderRef {
59    /// The `kind` field.
60    pub kind: String,
61    /// The `name` field.
62    pub name: String,
63}
64
65/// Native message type for `gestalt.provider.v1.RegistrationCheckRequest`.
66#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
67#[serde(rename_all = "camelCase")]
68pub struct RegistrationCheckRequest {
69    /// The `registration_id` field.
70    pub registration_id: String,
71    /// The `generation` field.
72    pub generation: u64,
73    /// The `providers` field.
74    pub providers: Vec<ProviderRef>,
75}
76
77/// Native message type for `gestalt.provider.v1.RegistrationCheckResponse`.
78#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
79#[serde(rename_all = "camelCase")]
80pub struct RegistrationCheckResponse {
81    /// The `ready` field.
82    pub ready: bool,
83    /// The `message` field.
84    pub message: String,
85}
86
87/// Native message type for `gestalt.provider.v1.Remote`.
88#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
89#[serde(rename_all = "camelCase")]
90pub struct Remote {
91    /// The `id` field.
92    pub id: String,
93    /// The `owner_subject_id` field.
94    pub owner_subject_id: String,
95    /// The `generation` field.
96    pub generation: u64,
97    /// The `providers` field.
98    pub providers: Vec<RemoteProviderSummary>,
99    /// The `reachability` field; None when unset.
100    pub reachability: Option<RemoteReachability>,
101    /// The `server_spki_sha256` field.
102    pub server_spki_sha256: String,
103    #[serde(with = "crate::serde_time")]
104    /// The `created_at` field; None when unset.
105    pub created_at: Option<std::time::SystemTime>,
106    #[serde(with = "crate::serde_time")]
107    /// The `updated_at` field; None when unset.
108    pub updated_at: Option<std::time::SystemTime>,
109    #[serde(with = "crate::serde_time")]
110    /// The `last_checked_at` field; None when unset.
111    pub last_checked_at: Option<std::time::SystemTime>,
112    #[serde(with = "crate::serde_time")]
113    /// The `last_successful_heartbeat_at` field; None when unset.
114    pub last_successful_heartbeat_at: Option<std::time::SystemTime>,
115    /// The `last_error` field.
116    pub last_error: String,
117    #[serde(with = "crate::serde_time")]
118    /// The `lease_expires_at` field; None when unset.
119    pub lease_expires_at: Option<std::time::SystemTime>,
120}
121
122/// Native message type for `gestalt.provider.v1.RemoteProviderDefinition`.
123#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
124#[serde(rename_all = "camelCase")]
125pub struct RemoteProviderDefinition {
126    /// The `kind` field.
127    pub kind: String,
128    /// The `name` field.
129    pub name: String,
130    /// The `definition` field; None when unset.
131    pub definition: Option<serde_json::Map<String, serde_json::Value>>,
132}
133
134/// Native message type for `gestalt.provider.v1.RemoteProviderSummary`.
135#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
136#[serde(rename_all = "camelCase")]
137pub struct RemoteProviderSummary {
138    /// The `kind` field.
139    pub kind: String,
140    /// The `name` field.
141    pub name: String,
142}
143
144/// Native message type for `gestalt.provider.v1.RemoteReachability`.
145#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
146#[serde(rename_all = "camelCase")]
147pub struct RemoteReachability {
148    /// The `reachable` field.
149    pub reachable: bool,
150    /// The `message` field.
151    pub message: String,
152}
153
154/// Native message type for `gestalt.provider.v1.ServerIdentity`.
155#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
156#[serde(rename_all = "camelCase")]
157pub struct ServerIdentity {
158    /// The `client_spki_sha256` field.
159    pub client_spki_sha256: String,
160}
161
162/// Native message type for `gestalt.provider.v1.TunnelBootstrap`.
163#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
164#[serde(rename_all = "camelCase")]
165pub struct TunnelBootstrap {
166    /// The `frps_address` field.
167    pub frps_address: String,
168    #[serde(with = "crate::serde_duration")]
169    /// The `lease_duration` field; None when unset.
170    pub lease_duration: Option<std::time::Duration>,
171}
172
173/// Native message type for `gestalt.provider.v1.TunnelEndpoint`.
174#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
175#[serde(rename_all = "camelCase")]
176pub struct TunnelEndpoint {
177    /// The `host` field.
178    pub host: String,
179    /// The `certificate` field.
180    pub certificate: Vec<u8>,
181    /// The `server_spki_sha256` field.
182    pub server_spki_sha256: String,
183}
184
185/// RegistrationLifecycle is served by local gestaltd over the mutually
186/// authenticated tunnel only. Internal, never public: it carries no http or
187/// visibility annotations so the publicrpc descriptor scan never exposes it.
188///
189/// Client for the `gestalt.provider.v1.RegistrationLifecycle` service.
190pub struct RegistrationLifecycle {
191    inner:
192        v1::registration_lifecycle_client::RegistrationLifecycleClient<tonic::transport::Channel>,
193    timeout: Option<std::time::Duration>,
194}
195
196impl RegistrationLifecycle {
197    /// Creates a client over an established channel.
198    pub fn new(channel: tonic::transport::Channel) -> Self {
199        Self {
200            inner: v1::registration_lifecycle_client::RegistrationLifecycleClient::new(channel),
201            timeout: None,
202        }
203    }
204
205    /// Sets a deadline applied to every unary call; calls that run past it
206    /// fail with DEADLINE_EXCEEDED. Streaming calls are unaffected.
207    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
208        self.timeout = Some(timeout);
209        self
210    }
211
212    /// Check succeeds only when the exact provider set named in the request is
213    /// present and every provider is ready.
214    ///
215    /// Calls `gestalt.provider.v1.RegistrationLifecycle.Check`.
216    pub async fn check(
217        &mut self,
218        request: RegistrationCheckRequest,
219    ) -> Result<RegistrationCheckResponse, GestaltError> {
220        let mut tonic_request = tonic::Request::new(to_wire_registration_check_request(request));
221        if let Some(timeout) = self.timeout {
222            tonic_request.set_timeout(timeout);
223        }
224        let response = self.inner.check(tonic_request).await?;
225        Ok(from_wire_registration_check_response(response.into_inner()))
226    }
227}
228
229/// RemoteManagement is the public management service for reverse remotes. A
230/// developer running `gestaltd serve` calls CreateRemote to publish a provider
231/// set to this upstream; ListRemotes and DeleteRemote read and remove it. REST
232/// and gRPC dispatch through one implementation.
233///
234/// Client for the `gestalt.provider.v1.RemoteManagement` service.
235pub struct RemoteManagement {
236    inner: v1::remote_management_client::RemoteManagementClient<tonic::transport::Channel>,
237    timeout: Option<std::time::Duration>,
238}
239
240impl RemoteManagement {
241    /// Creates a client over an established channel.
242    pub fn new(channel: tonic::transport::Channel) -> Self {
243        Self {
244            inner: v1::remote_management_client::RemoteManagementClient::new(channel),
245            timeout: None,
246        }
247    }
248
249    /// Sets a deadline applied to every unary call; calls that run past it
250    /// fail with DEADLINE_EXCEEDED. Streaming calls are unaffected.
251    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
252        self.timeout = Some(timeout);
253        self
254    }
255
256    /// Calls `gestalt.provider.v1.RemoteManagement.CreateRemote`.
257    pub async fn create_remote(
258        &mut self,
259        request: CreateRemoteRequest,
260    ) -> Result<Remote, GestaltError> {
261        let mut tonic_request = tonic::Request::new(to_wire_create_remote_request(request));
262        if let Some(timeout) = self.timeout {
263            tonic_request.set_timeout(timeout);
264        }
265        let response = self.inner.create_remote(tonic_request).await?;
266        Ok(from_wire_remote(response.into_inner()))
267    }
268
269    /// Calls `gestalt.provider.v1.RemoteManagement.ListRemotes`.
270    pub async fn list_remotes(
271        &mut self,
272        request: ListRemotesRequest,
273    ) -> Result<ListRemotesResponse, GestaltError> {
274        let mut tonic_request = tonic::Request::new(to_wire_list_remotes_request(request));
275        if let Some(timeout) = self.timeout {
276            tonic_request.set_timeout(timeout);
277        }
278        let response = self.inner.list_remotes(tonic_request).await?;
279        Ok(from_wire_list_remotes_response(response.into_inner()))
280    }
281
282    /// Calls `gestalt.provider.v1.RemoteManagement.DeleteRemote`.
283    pub async fn delete_remote(
284        &mut self,
285        request: DeleteRemoteRequest,
286    ) -> Result<(), GestaltError> {
287        let mut tonic_request = tonic::Request::new(to_wire_delete_remote_request(request));
288        if let Some(timeout) = self.timeout {
289            tonic_request.set_timeout(timeout);
290        }
291        self.inner.delete_remote(tonic_request).await?;
292        Ok(())
293    }
294}