1use std::collections::HashMap;
4
5use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
12#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
13#[serde(rename_all = "camelCase")]
14pub struct HorizonClusterConfig {
15 pub cluster_id: String,
17
18 pub management_token: String,
21
22 #[serde(default, skip_serializing_if = "Option::is_none")]
25 pub runtime_identity: Option<MachineRuntimeIdentity>,
26
27 #[serde(default, skip_serializing_if = "Option::is_none")]
31 pub horizon_machine_image: Option<HorizonMachineImage>,
32
33 #[serde(default, skip_serializing_if = "Option::is_none")]
38 pub machine_url: Option<String>,
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
43#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
44#[serde(rename_all = "camelCase", deny_unknown_fields)]
45pub struct MachineRuntimeIdentity {
46 pub exchange_url: String,
47 pub deployment_id: String,
48 pub audience: String,
49}
50
51#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
53#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
54#[serde(rename_all = "camelCase")]
55pub enum HorizonMachineArchitecture {
56 #[serde(rename = "arm64")]
58 Arm64,
59 #[serde(rename = "amd64")]
61 Amd64,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
66#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
67#[serde(rename_all = "camelCase")]
68pub struct HorizonAwsMachineImages {
69 pub amis: HashMap<HorizonMachineArchitecture, HashMap<String, String>>,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
75#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
76#[serde(rename_all = "camelCase")]
77pub struct HorizonGcpMachineImage {
78 pub source_image: String,
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
84#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
85#[serde(rename_all = "camelCase")]
86pub struct HorizonGcpMachineImages {
87 pub images: HashMap<HorizonMachineArchitecture, HorizonGcpMachineImage>,
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
93#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
94#[serde(rename_all = "camelCase")]
95pub struct HorizonAzureMachineImage {
96 pub image_version_id: String,
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
102#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
103#[serde(rename_all = "camelCase")]
104pub struct HorizonMachineBaseImage {
105 pub name: String,
107 pub version: String,
109}
110
111#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
113#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
114#[serde(rename_all = "camelCase")]
115pub struct HorizonAzureMachineImages {
116 pub images: HashMap<HorizonMachineArchitecture, HorizonAzureMachineImage>,
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
122#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
123#[serde(rename_all = "camelCase")]
124pub struct HorizondArtifact {
125 #[serde(default)]
127 pub runtime_isolation_generation: u32,
128 pub url: String,
130 pub sha256: String,
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
138#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
139#[serde(rename_all = "camelCase")]
140pub struct HorizonMachineImage {
141 #[serde(default)]
143 pub runtime_isolation_generation: u32,
144 pub channel: String,
146 pub machine_image_version: String,
148 pub horizond_version: String,
150 pub git_sha: String,
152 pub created_at: String,
154 pub base_image: HorizonMachineBaseImage,
156 pub horizond_artifacts: HashMap<String, HorizondArtifact>,
158 #[serde(default, skip_serializing_if = "Option::is_none")]
160 pub aws: Option<HorizonAwsMachineImages>,
161 #[serde(default, skip_serializing_if = "Option::is_none")]
163 pub gcp: Option<HorizonGcpMachineImages>,
164 #[serde(default, skip_serializing_if = "Option::is_none")]
166 pub azure: Option<HorizonAzureMachineImages>,
167}
168
169#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
175#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
176#[serde(rename_all = "camelCase")]
177pub struct HorizonConfig {
178 pub url: String,
180
181 #[serde(default, skip_serializing_if = "Option::is_none")]
183 pub horizon_machine_image: Option<HorizonMachineImage>,
184
185 pub clusters: HashMap<String, HorizonClusterConfig>,
189}
190
191impl HorizonConfig {
192 pub fn machine_image_for(&self, resource_id: &str) -> Option<&HorizonMachineImage> {
195 self.clusters
196 .get(resource_id)
197 .and_then(|cluster| cluster.horizon_machine_image.as_ref())
198 .or(self.horizon_machine_image.as_ref())
199 }
200}
201
202#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
207#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
208#[serde(tag = "type", rename_all = "camelCase")]
209pub enum ComputeBackend {
210 Horizon(HorizonConfig),
212 }
218
219#[cfg(test)]
220mod tests {
221 use serde_json::{json, Value};
222
223 use std::collections::HashMap;
224
225 use serde::Deserialize;
226
227 use super::{HorizonClusterConfig, HorizonConfig, HorizonMachineImage, HorizondArtifact};
228
229 fn legacy_catalog() -> Value {
230 json!({
231 "channel": "stable",
232 "machineImageVersion": "1",
233 "horizondVersion": "1",
234 "gitSha": "abc123",
235 "createdAt": "2026-01-01T00:00:00Z",
236 "baseImage": { "name": "linux", "version": "1" },
237 "horizondArtifacts": {
238 "linux-arm64": { "url": "https://example.com/arm64", "sha256": "a".repeat(64) },
239 "linux-amd64": { "url": "https://example.com/amd64", "sha256": "b".repeat(64) }
240 },
241 "aws": { "amis": { "arm64": { "us-east-1": "ami-example" } } },
242 "gcp": { "images": { "arm64": { "sourceImage": "example-image" } } },
243 "azure": { "images": { "arm64": { "imageVersionId": "example-version" } } }
244 })
245 }
246
247 #[test]
248 fn runtime_isolation_generation_legacy_catalog_defaults_to_zero() {
249 let mut expected = legacy_catalog();
250 let catalog: HorizonMachineImage = serde_json::from_value(expected.clone()).unwrap();
251 assert_eq!(catalog.runtime_isolation_generation, 0);
252 expected["runtimeIsolationGeneration"] = json!(0);
253 for (arch, artifact) in &catalog.horizond_artifacts {
254 assert_eq!(artifact.runtime_isolation_generation, 0);
255 let decoded: HorizondArtifact =
256 serde_json::from_value(expected["horizondArtifacts"][arch].clone()).unwrap();
257 assert_eq!(&decoded, artifact);
258 expected["horizondArtifacts"][arch]["runtimeIsolationGeneration"] = json!(0);
259 assert_eq!(
260 serde_json::to_value(decoded).unwrap(),
261 expected["horizondArtifacts"][arch]
262 );
263 }
264 assert_eq!(serde_json::to_value(catalog).unwrap(), expected);
265 }
266
267 #[test]
268 fn runtime_isolation_generation_roundtrips_catalog_and_each_artifact() {
269 let mut expected = legacy_catalog();
270 expected["runtimeIsolationGeneration"] = json!(1);
271 for artifact in expected["horizondArtifacts"]
272 .as_object_mut()
273 .unwrap()
274 .values_mut()
275 {
276 artifact["runtimeIsolationGeneration"] = json!(1);
277 }
278 let catalog: HorizonMachineImage = serde_json::from_value(expected.clone()).unwrap();
279 assert_eq!(catalog.runtime_isolation_generation, 1);
280 for (arch, artifact) in &catalog.horizond_artifacts {
281 assert_eq!(artifact.runtime_isolation_generation, 1);
282 let encoded = serde_json::to_value(artifact).unwrap();
283 assert_eq!(encoded, expected["horizondArtifacts"][arch]);
284 assert_eq!(
285 serde_json::from_value::<HorizondArtifact>(encoded).unwrap(),
286 *artifact
287 );
288 }
289 assert_eq!(serde_json::to_value(catalog).unwrap(), expected);
290 }
291
292 #[test]
293 fn runtime_isolation_generation_rejects_invalid_numbers_and_types() {
294 for invalid in [
295 json!(-1),
296 json!(1.5),
297 json!("1"),
298 json!(null),
299 json!(4294967296_u64),
300 ] {
301 let mut catalog = legacy_catalog();
302 catalog["runtimeIsolationGeneration"] = invalid.clone();
303 assert!(serde_json::from_value::<HorizonMachineImage>(catalog).is_err());
304 for arch in ["linux-arm64", "linux-amd64"] {
305 let mut catalog = legacy_catalog();
306 catalog["horizondArtifacts"][arch]["runtimeIsolationGeneration"] = invalid.clone();
307 assert!(serde_json::from_value::<HorizondArtifact>(
308 catalog["horizondArtifacts"][arch].clone()
309 )
310 .is_err());
311 assert!(serde_json::from_value::<HorizonMachineImage>(catalog).is_err());
312 }
313 }
314 }
315
316 fn catalog_version(version: &str) -> Value {
317 let mut catalog = legacy_catalog();
318 catalog["machineImageVersion"] = json!(version);
319 catalog
320 }
321
322 #[test]
323 fn cluster_without_its_own_machine_image_reads_as_before() {
324 let config: HorizonConfig = serde_json::from_value(json!({
325 "url": "https://horizon.example.com",
326 "horizonMachineImage": catalog_version("2"),
327 "clusters": {
328 "compute": { "clusterId": "cluster-1", "managementToken": "hm_test" }
329 }
330 }))
331 .expect("a config written before the field existed must deserialize");
332
333 assert_eq!(config.clusters["compute"].horizon_machine_image, None);
334 assert_eq!(
335 config
336 .machine_image_for("compute")
337 .map(|image| image.machine_image_version.as_str()),
338 Some("2")
339 );
340 let written = serde_json::to_value(&config.clusters["compute"]).unwrap();
342 assert_eq!(
343 written,
344 json!({ "clusterId": "cluster-1", "managementToken": "hm_test" })
345 );
346 }
347
348 #[test]
349 fn each_cluster_uses_its_own_machine_image_when_it_has_one() {
350 let config: HorizonConfig = serde_json::from_value(json!({
351 "url": "https://horizon.example.com",
352 "horizonMachineImage": catalog_version("2"),
353 "clusters": {
354 "held": {
355 "clusterId": "cluster-1",
356 "managementToken": "hm_test",
357 "horizonMachineImage": catalog_version("1")
358 },
359 "moving": { "clusterId": "cluster-2", "managementToken": "hm_test" }
360 }
361 }))
362 .unwrap();
363
364 let version = |resource_id| {
365 config
366 .machine_image_for(resource_id)
367 .map(|image| image.machine_image_version.clone())
368 };
369 assert_eq!(version("held").as_deref(), Some("1"));
370 assert_eq!(version("moving").as_deref(), Some("2"));
371 assert_eq!(version("unknown").as_deref(), Some("2"));
372 }
373
374 #[derive(Debug, Deserialize, PartialEq)]
378 #[serde(rename_all = "camelCase")]
379 struct PreviousHorizonClusterConfig {
380 cluster_id: String,
381 management_token: String,
382 }
383
384 #[derive(Debug, Deserialize)]
385 #[serde(rename_all = "camelCase")]
386 struct PreviousHorizonConfig {
387 #[allow(dead_code)]
388 url: String,
389 #[serde(default)]
390 horizon_machine_image: Option<HorizonMachineImage>,
391 clusters: HashMap<String, PreviousHorizonClusterConfig>,
392 }
393
394 #[test]
395 fn readers_that_predate_cluster_machine_images_ignore_them() {
396 let config = HorizonConfig {
397 url: "https://horizon.example.com".to_string(),
398 horizon_machine_image: Some(serde_json::from_value(catalog_version("2")).unwrap()),
399 clusters: HashMap::from([(
400 "compute".to_string(),
401 HorizonClusterConfig {
402 machine_url: None,
403 cluster_id: "cluster-1".to_string(),
404 management_token: "hm_test".to_string(),
405 runtime_identity: None,
406 horizon_machine_image: Some(
407 serde_json::from_value(catalog_version("1")).unwrap(),
408 ),
409 },
410 )]),
411 };
412 let written = serde_json::to_value(&config).unwrap();
413 assert!(written["clusters"]["compute"]["horizonMachineImage"].is_object());
414
415 let previous: PreviousHorizonConfig = serde_json::from_value(written)
416 .expect("an older reader must accept a cluster that carries its own image");
417 assert_eq!(
418 previous.clusters["compute"],
419 PreviousHorizonClusterConfig {
420 cluster_id: "cluster-1".to_string(),
421 management_token: "hm_test".to_string(),
422 }
423 );
424 assert_eq!(
425 previous
426 .horizon_machine_image
427 .map(|image| image.machine_image_version),
428 Some("2".to_string())
429 );
430 }
431
432 #[test]
433 fn cluster_machine_url_is_optional_and_ignored_by_older_readers() {
434 let config: HorizonConfig = serde_json::from_value(json!({
435 "url": "https://horizon.example.com",
436 "clusters": {
437 "relayed": {
438 "clusterId": "cluster-1",
439 "managementToken": "hm_test",
440 "machineUrl": "https://relay.example.com/v1/horizon"
441 },
442 "direct": { "clusterId": "cluster-2", "managementToken": "hm_test" }
443 }
444 }))
445 .expect("a config written before the field existed must deserialize");
446
447 assert_eq!(
448 config.clusters["relayed"].machine_url.as_deref(),
449 Some("https://relay.example.com/v1/horizon")
450 );
451 assert_eq!(config.clusters["direct"].machine_url, None);
452 assert_eq!(
454 serde_json::to_value(&config.clusters["direct"]).unwrap(),
455 json!({ "clusterId": "cluster-2", "managementToken": "hm_test" })
456 );
457 let previous: PreviousHorizonConfig =
459 serde_json::from_value(serde_json::to_value(&config).unwrap()).unwrap();
460 assert_eq!(previous.clusters["relayed"].cluster_id, "cluster-1");
461 }
462}