spiral/api/workers/
objects.rs

1// Generated by tools/service-contracts/rust.py. Do not edit.
2#![doc = "Generated transport-independent contract objects."]
3
4use std::error::Error as StdError;
5use std::fmt::{self, Display, Formatter};
6
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8use spiral_contract::error::{ErrorEnvelope, ServiceError};
9use spiral_contract::safelong::SafeUnsignedLong;
10use spiral_contract::strict::{DeserializeStrict, Strict};
11use uuid::Uuid;
12
13/// ManagedWorkerPhase contract value.
14#[derive(Clone, Debug, PartialEq, Eq)]
15pub enum ManagedWorkerPhase {
16    /// A known contract value.
17    Disabled,
18    /// A known contract value.
19    Idle,
20    /// A known contract value.
21    Active,
22    /// A known contract value.
23    ScalingDown,
24    /// A known contract value.
25    ScalingUp,
26    /// A known contract value.
27    Provisioning,
28    /// A known contract value.
29    Degraded,
30    /// A value introduced by a newer server.
31    Unknown(String),
32}
33impl Serialize for ManagedWorkerPhase {
34    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
35        serializer.serialize_str(match self {
36            Self::Disabled => "disabled",
37            Self::Idle => "idle",
38            Self::Active => "active",
39            Self::ScalingDown => "scaling_down",
40            Self::ScalingUp => "scaling_up",
41            Self::Provisioning => "provisioning",
42            Self::Degraded => "degraded",
43            Self::Unknown(value) => value,
44        })
45    }
46}
47impl<'de> Deserialize<'de> for ManagedWorkerPhase {
48    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
49        Ok(match String::deserialize(deserializer)?.as_str() {
50            "disabled" => Self::Disabled,
51            "idle" => Self::Idle,
52            "active" => Self::Active,
53            "scaling_down" => Self::ScalingDown,
54            "scaling_up" => Self::ScalingUp,
55            "provisioning" => Self::Provisioning,
56            "degraded" => Self::Degraded,
57            value => Self::Unknown(value.to_owned()),
58        })
59    }
60}
61impl<'de> DeserializeStrict<'de> for ManagedWorkerPhase {
62    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
63        #[derive(Deserialize)]
64        enum __Known {
65            #[serde(rename = "disabled")]
66            Disabled,
67            #[serde(rename = "idle")]
68            Idle,
69            #[serde(rename = "active")]
70            Active,
71            #[serde(rename = "scaling_down")]
72            ScalingDown,
73            #[serde(rename = "scaling_up")]
74            ScalingUp,
75            #[serde(rename = "provisioning")]
76            Provisioning,
77            #[serde(rename = "degraded")]
78            Degraded,
79        }
80        Ok(match __Known::deserialize(deserializer)? {
81            __Known::Disabled => Self::Disabled,
82            __Known::Idle => Self::Idle,
83            __Known::Active => Self::Active,
84            __Known::ScalingDown => Self::ScalingDown,
85            __Known::ScalingUp => Self::ScalingUp,
86            __Known::Provisioning => Self::Provisioning,
87            __Known::Degraded => Self::Degraded,
88        })
89    }
90}
91
92/// ManagedWorkerProviderResponse contract value.
93#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
94pub struct ManagedWorkerProviderResponse {
95    /// Contract field activeWorkers.
96    #[serde(rename = "activeWorkers")]
97    pub active_workers: SafeUnsignedLong,
98    /// Contract field busyWorkers.
99    #[serde(rename = "busyWorkers")]
100    pub busy_workers: SafeUnsignedLong,
101    /// Contract field displayName.
102    #[serde(rename = "displayName")]
103    pub display_name: String,
104    /// Contract field enabled.
105    #[serde(rename = "enabled")]
106    pub enabled: bool,
107    /// Contract field id.
108    #[serde(rename = "id")]
109    pub id: String,
110    /// Contract field phase.
111    #[serde(rename = "phase")]
112    pub phase: ManagedWorkerPhase,
113    /// Contract field workerPoolIds.
114    #[serde(rename = "workerPoolIds")]
115    pub worker_pool_ids: Vec<Uuid>,
116}
117impl<'de> DeserializeStrict<'de> for ManagedWorkerProviderResponse {
118    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
119        #[derive(Deserialize)]
120        #[serde(deny_unknown_fields)]
121        struct __Wire {
122            #[serde(rename = "activeWorkers")]
123            active_workers: Strict<SafeUnsignedLong>,
124            #[serde(rename = "busyWorkers")]
125            busy_workers: Strict<SafeUnsignedLong>,
126            #[serde(rename = "displayName")]
127            display_name: Strict<String>,
128            #[serde(rename = "enabled")]
129            enabled: Strict<bool>,
130            #[serde(rename = "id")]
131            id: Strict<String>,
132            #[serde(rename = "phase")]
133            phase: Strict<ManagedWorkerPhase>,
134            #[serde(rename = "workerPoolIds")]
135            worker_pool_ids: Strict<Vec<Uuid>>,
136        }
137        let wire = __Wire::deserialize(deserializer)?;
138        Ok(Self {
139            active_workers: wire.active_workers.0,
140            busy_workers: wire.busy_workers.0,
141            display_name: wire.display_name.0,
142            enabled: wire.enabled.0,
143            id: wire.id.0,
144            phase: wire.phase.0,
145            worker_pool_ids: wire.worker_pool_ids.0,
146        })
147    }
148}
149
150/// ManagedWorkersResponse contract value.
151#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
152pub struct ManagedWorkersResponse {
153    /// Contract field providers.
154    #[serde(rename = "providers")]
155    pub providers: Vec<ManagedWorkerProviderResponse>,
156    /// Contract field workloadId.
157    #[serde(rename = "workloadId")]
158    pub workload_id: String,
159}
160impl<'de> DeserializeStrict<'de> for ManagedWorkersResponse {
161    fn deserialize_strict<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
162        #[derive(Deserialize)]
163        #[serde(deny_unknown_fields)]
164        struct __Wire {
165            #[serde(rename = "providers")]
166            providers: Strict<Vec<ManagedWorkerProviderResponse>>,
167            #[serde(rename = "workloadId")]
168            workload_id: Strict<String>,
169        }
170        let wire = __Wire::deserialize(deserializer)?;
171        Ok(Self {
172            providers: wire.providers.0,
173            workload_id: wire.workload_id.0,
174        })
175    }
176}
177
178/// Typed errors declared by this service contract.
179#[derive(Clone, Debug, PartialEq, Eq)]
180pub enum WorkersError {
181    /// Workers:Conflict.
182    Conflict { reason: String },
183    /// Workers:InvalidArgument.
184    InvalidArgument { reason: String },
185    /// Workers:LimitReached.
186    LimitReached { reason: String },
187    /// Workers:NotFound.
188    NotFound { resource: String },
189}
190impl WorkersError {
191    /// HTTP status for this declared error.
192    pub fn status(&self) -> u16 {
193        match self {
194            Self::Conflict { .. } => 409,
195            Self::InvalidArgument { .. } => 400,
196            Self::LimitReached { .. } => 412,
197            Self::NotFound { .. } => 404,
198        }
199    }
200    /// Serialize only contract-declared error parameters.
201    pub fn envelope(&self, instance: String) -> ErrorEnvelope {
202        match self {
203            Self::Conflict { reason } => {
204                let mut envelope = ErrorEnvelope::new("CONFLICT", "Workers:Conflict", instance);
205                envelope
206                    .parameters
207                    .insert("reason".into(), reason.to_string());
208                envelope
209            }
210            Self::InvalidArgument { reason } => {
211                let mut envelope =
212                    ErrorEnvelope::new("INVALID_ARGUMENT", "Workers:InvalidArgument", instance);
213                envelope
214                    .parameters
215                    .insert("reason".into(), reason.to_string());
216                envelope
217            }
218            Self::LimitReached { reason } => {
219                let mut envelope =
220                    ErrorEnvelope::new("FAILED_PRECONDITION", "Workers:LimitReached", instance);
221                envelope
222                    .parameters
223                    .insert("reason".into(), reason.to_string());
224                envelope
225            }
226            Self::NotFound { resource } => {
227                let mut envelope = ErrorEnvelope::new("NOT_FOUND", "Workers:NotFound", instance);
228                envelope
229                    .parameters
230                    .insert("resource".into(), resource.to_string());
231                envelope
232            }
233        }
234    }
235    /// Decode a declared error and its typed error parameters.
236    pub fn decode_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
237        if envelope.error_instance_id.len() != 36
238            || Uuid::parse_str(&envelope.error_instance_id).is_err()
239        {
240            return None;
241        }
242        match envelope.error_name.as_str() {
243            "Workers:Conflict" => {
244                if envelope.error_code != "CONFLICT" {
245                    return None;
246                }
247                let reason = envelope.parameters.get("reason")?.clone();
248                Some(Self::Conflict { reason })
249            }
250            "Workers:InvalidArgument" => {
251                if envelope.error_code != "INVALID_ARGUMENT" {
252                    return None;
253                }
254                let reason = envelope.parameters.get("reason")?.clone();
255                Some(Self::InvalidArgument { reason })
256            }
257            "Workers:LimitReached" => {
258                if envelope.error_code != "FAILED_PRECONDITION" {
259                    return None;
260                }
261                let reason = envelope.parameters.get("reason")?.clone();
262                Some(Self::LimitReached { reason })
263            }
264            "Workers:NotFound" => {
265                if envelope.error_code != "NOT_FOUND" {
266                    return None;
267                }
268                let resource = envelope.parameters.get("resource")?.clone();
269                Some(Self::NotFound { resource })
270            }
271            _ => None,
272        }
273    }
274}
275impl Display for WorkersError {
276    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
277        match self {
278            Self::Conflict { reason } => write!(formatter, "Workers:Conflict (reason: {})", reason),
279            Self::InvalidArgument { reason } => {
280                write!(formatter, "Workers:InvalidArgument (reason: {})", reason)
281            }
282            Self::LimitReached { reason } => {
283                write!(formatter, "Workers:LimitReached (reason: {})", reason)
284            }
285            Self::NotFound { resource } => {
286                write!(formatter, "Workers:NotFound (resource: {})", resource)
287            }
288        }
289    }
290}
291impl StdError for WorkersError {}
292impl ServiceError for WorkersError {
293    fn to_envelope(&self, instance: String) -> ErrorEnvelope {
294        Self::envelope(self, instance)
295    }
296    fn from_envelope(envelope: &ErrorEnvelope) -> Option<Self> {
297        Self::decode_envelope(envelope)
298    }
299}
spiral/api/workers/objects.rs

spiral/api/workers/
objects.rs
