1use serde::{Deserialize, Serialize};
6use std::collections::HashMap;
7
8use crate::{ErrorData, KubernetesCloudReference, KubernetesClusterOwnership, Result};
9use alien_error::AlienError;
10use alien_signing::SigningSettings;
11
12#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
14#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
15#[serde(rename_all = "camelCase")]
16pub struct AwsManagementConfig {
17 pub managing_role_arn: String,
19}
20
21#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
23#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
24#[serde(rename_all = "camelCase")]
25pub struct GcpManagementConfig {
26 pub service_account_email: String,
28 #[serde(default, skip_serializing_if = "Option::is_none")]
31 pub federation_trust: Option<crate::GcpFederationTrust>,
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
36#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
37#[serde(rename_all = "camelCase")]
38pub struct AzureManagementConfig {
39 pub managing_tenant_id: String,
41 pub oidc_issuer: String,
43 pub oidc_subject: String,
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
52#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
53#[serde(rename_all = "camelCase", tag = "platform")]
54pub enum ManagementConfig {
55 Aws(AwsManagementConfig),
57 Gcp(GcpManagementConfig),
59 Azure(AzureManagementConfig),
61 Kubernetes,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
81#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
82#[serde(rename_all = "camelCase", tag = "type")]
83pub enum NetworkSettings {
84 #[serde(rename = "use-default")]
98 UseDefault,
99
100 #[serde(rename = "create")]
107 Create {
108 #[serde(skip_serializing_if = "Option::is_none")]
111 cidr: Option<String>,
112
113 #[serde(default = "default_availability_zones")]
115 availability_zones: u8,
116 },
117
118 #[serde(rename = "byo-vpc-aws")]
123 ByoVpcAws {
124 vpc_id: String,
126 #[serde(deserialize_with = "crate::network_ids::deserialize_ids")]
128 public_subnet_ids: Vec<String>,
129 #[serde(deserialize_with = "crate::network_ids::deserialize_ids")]
131 private_subnet_ids: Vec<String>,
132 #[serde(default)]
134 #[serde(deserialize_with = "crate::network_ids::deserialize_ids")]
135 security_group_ids: Vec<String>,
136 },
137
138 #[serde(rename = "byo-vpc-gcp")]
143 ByoVpcGcp {
144 network_name: String,
146 subnet_name: String,
148 region: String,
150 },
151
152 #[serde(rename = "byo-vnet-azure")]
157 ByoVnetAzure {
158 vnet_resource_id: String,
160 public_subnet_name: String,
162 private_subnet_name: String,
164 #[serde(default, skip_serializing_if = "Option::is_none")]
166 application_gateway_subnet_name: Option<String>,
167 #[serde(default, skip_serializing_if = "Option::is_none")]
173 private_endpoint_subnet_name: Option<String>,
174 },
175}
176
177fn default_availability_zones() -> u8 {
178 2
179}
180
181pub const MAX_CREATED_NETWORK_AVAILABILITY_ZONES: u8 = 8;
185
186#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
192#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
193#[serde(rename_all = "camelCase")]
194pub struct ComputeSettings {
195 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
197 pub pools: HashMap<String, ComputePoolSelection>,
198 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
200 pub containers: HashMap<String, ContainerResourceSelection>,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
205#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
206#[serde(rename_all = "camelCase", deny_unknown_fields)]
207pub struct ContainerResourceSelection {
208 #[serde(
210 default,
211 skip_serializing_if = "Option::is_none",
212 deserialize_with = "deserialize_selected_cpu"
213 )]
214 #[cfg_attr(feature = "openapi", schema(value_type = Option<f64>))]
215 pub cpu: Option<serde_json::Number>,
216 #[serde(default, skip_serializing_if = "Option::is_none")]
218 pub memory: Option<String>,
219 #[serde(default, skip_serializing_if = "Option::is_none")]
222 #[serde(deserialize_with = "deserialize_selected_volume_size")]
223 pub volume_size_gib: Option<u32>,
224}
225
226fn deserialize_selected_volume_size<'de, D: serde::Deserializer<'de>>(
227 deserializer: D,
228) -> std::result::Result<Option<u32>, D::Error> {
229 match Option::<serde_json::Value>::deserialize(deserializer)? {
231 None => Ok(None),
232 Some(serde_json::Value::Number(number)) => number
233 .as_u64()
234 .and_then(|number| u32::try_from(number).ok())
235 .map(Some)
236 .ok_or_else(|| {
237 serde::de::Error::custom("volumeSizeGib must be a whole positive capacity")
238 }),
239 Some(serde_json::Value::String(number)) => {
240 number.parse().map(Some).map_err(serde::de::Error::custom)
241 }
242 Some(_) => Err(serde::de::Error::custom(
243 "volumeSizeGib must be a whole positive capacity",
244 )),
245 }
246}
247
248fn deserialize_selected_cpu<'de, D: serde::Deserializer<'de>>(
249 deserializer: D,
250) -> std::result::Result<Option<serde_json::Number>, D::Error> {
251 match Option::<serde_json::Value>::deserialize(deserializer)? {
253 None => Ok(None),
254 Some(serde_json::Value::Number(number)) => Ok(Some(number)),
255 Some(serde_json::Value::String(number)) => {
256 number.parse().map(Some).map_err(serde::de::Error::custom)
257 }
258 Some(_) => Err(serde::de::Error::custom("CPU must be a number")),
259 }
260}
261
262#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
264#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
265#[serde(rename_all = "camelCase")]
266pub struct FailureDomainSelection {
267 pub spread: u8,
269 #[serde(default, skip_serializing_if = "Vec::is_empty")]
272 pub selected_failure_domains: Vec<String>,
273}
274
275#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
277#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
278#[serde(rename_all = "camelCase", tag = "mode")]
279pub enum ComputePoolSelection {
280 Fixed {
282 machines: u32,
284 #[serde(
286 default,
287 skip_serializing_if = "Option::is_none",
288 deserialize_with = "deserialize_machine_override"
289 )]
290 machine: Option<String>,
291 #[serde(default, skip_serializing_if = "Option::is_none")]
293 failure_domains: Option<FailureDomainSelection>,
294 #[serde(
297 rename = "dataDiskGib",
298 default,
299 skip_serializing_if = "Option::is_none",
300 deserialize_with = "deserialize_selected_data_disk_gib"
301 )]
302 data_disk_gib: Option<u32>,
303 },
304 Autoscale {
306 min: u32,
308 max: u32,
310 #[serde(
312 default,
313 skip_serializing_if = "Option::is_none",
314 deserialize_with = "deserialize_machine_override"
315 )]
316 machine: Option<String>,
317 #[serde(default, skip_serializing_if = "Option::is_none")]
319 failure_domains: Option<FailureDomainSelection>,
320 #[serde(
323 rename = "dataDiskGib",
324 default,
325 skip_serializing_if = "Option::is_none",
326 deserialize_with = "deserialize_selected_data_disk_gib"
327 )]
328 data_disk_gib: Option<u32>,
329 },
330}
331
332fn deserialize_selected_data_disk_gib<'de, D: serde::Deserializer<'de>>(
333 deserializer: D,
334) -> std::result::Result<Option<u32>, D::Error> {
335 match Option::<serde_json::Value>::deserialize(deserializer)? {
337 None => Ok(None),
338 Some(serde_json::Value::Number(number)) => number
339 .as_u64()
340 .and_then(|number| u32::try_from(number).ok())
341 .map(Some)
342 .ok_or_else(|| serde::de::Error::custom("dataDiskGib must be a whole number of GiB")),
343 Some(serde_json::Value::String(number)) => number
344 .parse()
345 .map(Some)
346 .map_err(|_| serde::de::Error::custom("dataDiskGib must be a whole number of GiB")),
347 Some(_) => Err(serde::de::Error::custom(
348 "dataDiskGib must be a whole number of GiB",
349 )),
350 }
351}
352
353fn deserialize_machine_override<'de, D: serde::Deserializer<'de>>(
354 deserializer: D,
355) -> std::result::Result<Option<String>, D::Error> {
356 Ok(Option::<String>::deserialize(deserializer)?.filter(|machine| !machine.is_empty()))
358}
359
360impl ComputePoolSelection {
361 pub fn machine(&self) -> Option<&str> {
363 match self {
364 Self::Fixed { machine, .. } | Self::Autoscale { machine, .. } => machine.as_deref(),
365 }
366 }
367
368 pub fn failure_domains(&self) -> Option<&FailureDomainSelection> {
370 match self {
371 Self::Fixed {
372 failure_domains, ..
373 }
374 | Self::Autoscale {
375 failure_domains, ..
376 } => failure_domains.as_ref(),
377 }
378 }
379
380 pub fn data_disk_gib(&self) -> Option<u32> {
382 match self {
383 Self::Fixed { data_disk_gib, .. } | Self::Autoscale { data_disk_gib, .. } => {
384 *data_disk_gib
385 }
386 }
387 }
388
389 pub fn min_size(&self) -> u32 {
391 match self {
392 Self::Fixed { machines, .. } => *machines,
393 Self::Autoscale { min, .. } => *min,
394 }
395 }
396
397 pub fn max_size(&self) -> u32 {
399 match self {
400 Self::Fixed { machines, .. } => *machines,
401 Self::Autoscale { max, .. } => *max,
402 }
403 }
404
405 pub fn validate(&self) -> std::result::Result<(), String> {
407 if self
408 .failure_domains()
409 .is_some_and(|selection| selection.spread == 0)
410 {
411 return Err("failure-domain spread must be at least one".to_string());
412 }
413 if self.failure_domains().is_some_and(|selection| {
414 !selection.selected_failure_domains.is_empty()
415 && selection.selected_failure_domains.len() != usize::from(selection.spread)
416 }) {
417 return Err("selected failure domains must match the requested spread".to_string());
418 }
419 if self.failure_domains().is_some_and(|selection| {
420 selection.selected_failure_domains.len()
421 != selection
422 .selected_failure_domains
423 .iter()
424 .collect::<std::collections::HashSet<_>>()
425 .len()
426 }) {
427 return Err("selected failure domains must be unique".to_string());
428 }
429 match self {
430 Self::Fixed { machines, .. } => {
431 if *machines == 0 {
432 return Err("fixed compute pools must select at least one machine".to_string());
433 }
434 if let Some(failure_domains) = self.failure_domains() {
435 if *machines < u32::from(failure_domains.spread) {
436 return Err(format!(
437 "fixed compute pool machines ({machines}) must be at least failure-domain spread ({})",
438 failure_domains.spread
439 ));
440 }
441 }
442 }
443 Self::Autoscale { min, max, .. } => {
444 if min > max {
445 return Err(format!(
446 "autoscaling compute pool minimum ({min}) cannot exceed maximum ({max})"
447 ));
448 }
449 if let Some(failure_domains) = self.failure_domains() {
450 let spread = u32::from(failure_domains.spread);
451 if *max < spread {
452 return Err(format!(
453 "autoscaling compute pool maximum ({max}) must be at least failure-domain spread ({spread})"
454 ));
455 }
456 if *min < spread {
457 return Err(format!(
458 "autoscaling compute pool minimum ({min}) must be at least failure-domain spread ({spread})"
459 ));
460 }
461 }
462 }
463 }
464 Ok(())
465 }
466}
467
468#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
470#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
471#[serde(rename_all = "camelCase")]
472pub enum DeploymentModel {
473 #[default]
476 Push,
477 Pull,
480}
481
482#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
484#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
485#[serde(rename_all = "kebab-case")]
486pub enum UpdatesMode {
487 #[default]
489 Auto,
490 ApprovalRequired,
492}
493
494#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
496#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
497#[serde(rename_all = "kebab-case")]
498pub enum TelemetryMode {
499 Off,
501 #[default]
503 Auto,
504 ApprovalRequired,
506}
507
508impl TelemetryMode {
509 pub fn is_enabled(&self) -> bool {
511 !matches!(self, TelemetryMode::Off)
512 }
513}
514
515#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
517#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
518#[serde(rename_all = "kebab-case")]
519pub enum HeartbeatsMode {
520 Off,
522 #[default]
524 On,
525}
526
527impl HeartbeatsMode {
528 pub fn is_enabled(&self) -> bool {
530 matches!(self, HeartbeatsMode::On)
531 }
532}
533
534#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
536#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
537#[serde(rename_all = "camelCase")]
538pub enum EndpointAccess {
539 #[default]
541 Internet,
542 Private,
544}
545
546impl EndpointAccess {
547 pub fn as_str(self) -> &'static str {
549 match self {
550 Self::Internet => "internet",
551 Self::Private => "private",
552 }
553 }
554}
555
556#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
561#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
562#[serde(rename_all = "camelCase")]
563pub struct DomainSettings {
564 #[serde(default, skip_serializing_if = "Option::is_none")]
566 pub custom_domains: Option<HashMap<String, CustomDomainConfig>>,
567 #[serde(default, skip_serializing_if = "Option::is_none")]
573 pub public_endpoint_target: Option<PublicEndpointTargetSettings>,
574}
575
576#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
578#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
579#[serde(rename_all = "camelCase", tag = "mode")]
580pub enum PublicEndpointTargetSettings {
581 MachineAddresses,
583 #[serde(rename_all = "camelCase")]
585 LoadBalancer {
586 cname_target: String,
588 },
589}
590
591#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
593#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
594#[serde(rename_all = "camelCase")]
595pub struct CustomDomainConfig {
596 #[serde(default, skip_serializing_if = "String::is_empty")]
598 pub domain: String,
599 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
601 pub endpoints: HashMap<String, String>,
602 pub certificate: CustomCertificateConfig,
604}
605
606#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
608#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
609#[serde(rename_all = "camelCase")]
610pub struct CustomCertificateConfig {
611 #[serde(default, skip_serializing_if = "Option::is_none")]
613 pub managed: Option<ManagedCustomCertificateConfig>,
614 #[serde(default, skip_serializing_if = "Option::is_none")]
616 pub aws: Option<AwsCustomCertificateConfig>,
617 #[serde(default, skip_serializing_if = "Option::is_none")]
619 pub gcp: Option<GcpCustomCertificateConfig>,
620 #[serde(default, skip_serializing_if = "Option::is_none")]
622 pub azure: Option<AzureCustomCertificateConfig>,
623 #[serde(default, skip_serializing_if = "Option::is_none")]
625 pub kubernetes: Option<KubernetesCustomCertificateConfig>,
626}
627
628#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
630#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
631#[serde(rename_all = "camelCase", deny_unknown_fields)]
632pub struct ManagedCustomCertificateConfig {}
633
634#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
635#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
636#[serde(rename_all = "camelCase")]
637pub struct AwsCustomCertificateConfig {
638 pub certificate_arn: String,
639}
640
641#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
642#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
643#[serde(rename_all = "camelCase")]
644pub struct GcpCustomCertificateConfig {
645 pub certificate_name: String,
646}
647
648#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
649#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
650#[serde(rename_all = "camelCase")]
651pub struct AzureCustomCertificateConfig {
652 pub key_vault_certificate_id: String,
653 #[serde(default, skip_serializing_if = "Option::is_none")]
654 pub key_vault_resource_id: Option<String>,
655}
656
657#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
658#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
659#[serde(rename_all = "camelCase")]
660pub struct KubernetesCustomCertificateConfig {
661 pub tls_secret_ref: KubernetesTlsSecretRef,
663}
664
665#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
672#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
673#[serde(rename_all = "camelCase")]
674pub struct KubernetesSettings {
675 #[serde(default, skip_serializing_if = "Option::is_none")]
677 pub cluster: Option<KubernetesClusterSettings>,
678 #[serde(default, skip_serializing_if = "Option::is_none")]
680 pub exposure: Option<KubernetesExposureSettings>,
681}
682
683#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
685#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
686#[serde(rename_all = "camelCase")]
687pub struct KubernetesClusterSettings {
688 pub ownership: KubernetesClusterOwnership,
691 #[serde(default, skip_serializing_if = "Option::is_none")]
693 pub namespace: Option<String>,
694 #[serde(default, skip_serializing_if = "Option::is_none")]
696 pub cloud: Option<KubernetesCloudReference>,
697}
698
699#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
701#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
702#[serde(rename_all = "camelCase", tag = "mode")]
703pub enum KubernetesExposureSettings {
704 Disabled,
706 Generated {
708 route: KubernetesRouteProfile,
710 certificate: KubernetesCertificateMode,
712 },
713 Custom {
715 domain: String,
717 route: KubernetesRouteProfile,
719 certificate: KubernetesCertificateMode,
721 },
722 #[serde(rename_all = "camelCase")]
724 CustomBaseDomain {
725 base_domain: String,
727 route: KubernetesRouteProfile,
729 certificate: KubernetesCertificateMode,
731 },
732}
733
734#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
736#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
737#[serde(rename_all = "camelCase", tag = "routeApi")]
738pub enum KubernetesRouteProfile {
739 Ingress(KubernetesIngressRouteProfile),
741 Gateway(KubernetesGatewayRouteProfile),
743}
744
745#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
747#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
748#[serde(rename_all = "camelCase")]
749pub struct KubernetesIngressRouteProfile {
750 #[serde(default, skip_serializing_if = "Option::is_none")]
752 pub controller: Option<String>,
753 pub ingress_class_name: String,
755 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
757 pub labels: HashMap<String, String>,
758 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
760 pub annotations: HashMap<String, String>,
761 #[serde(default, skip_serializing_if = "Option::is_none")]
763 pub provider: Option<KubernetesRouteProviderOptions>,
764}
765
766#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
768#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
769#[serde(rename_all = "camelCase")]
770pub struct KubernetesGatewayRouteProfile {
771 #[serde(default, skip_serializing_if = "Option::is_none")]
773 pub controller: Option<String>,
774 pub gateway_class_name: String,
776 pub listener_port: u16,
778 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
780 pub labels: HashMap<String, String>,
781 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
783 pub annotations: HashMap<String, String>,
784 #[serde(default, skip_serializing_if = "Option::is_none")]
786 pub provider: Option<KubernetesRouteProviderOptions>,
787}
788
789#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
791#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
792#[serde(rename_all = "camelCase", tag = "provider")]
793pub enum KubernetesRouteProviderOptions {
794 #[serde(rename_all = "camelCase")]
796 AwsAlb {
797 scheme: String,
799 target_type: String,
801 #[serde(default, skip_serializing_if = "Option::is_none")]
803 ip_address_type: Option<String>,
804 #[serde(default, skip_serializing_if = "Vec::is_empty")]
806 subnet_ids: Vec<String>,
807 },
808 #[serde(rename_all = "camelCase")]
810 GkeGateway {
811 #[serde(default, skip_serializing_if = "Option::is_none")]
813 static_address_name: Option<String>,
814 },
815 #[serde(rename_all = "camelCase")]
817 AzureApplicationGatewayForContainers {
818 #[serde(default, skip_serializing_if = "Option::is_none")]
820 alb_namespace: Option<String>,
821 #[serde(default, skip_serializing_if = "Option::is_none")]
823 alb_name: Option<String>,
824 frontend: String,
826 },
827}
828
829#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
831#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
832#[serde(rename_all = "camelCase", tag = "mode")]
833pub enum KubernetesCertificateMode {
834 #[serde(rename_all = "camelCase")]
836 ManagedAcmImport {
837 #[serde(default, skip_serializing_if = "Option::is_none")]
839 region: Option<String>,
840 #[serde(default, skip_serializing_if = "HashMap::is_empty")]
842 tags: HashMap<String, String>,
843 },
844 #[serde(rename_all = "camelCase")]
846 AwsAcmArn {
847 certificate_arn: String,
849 },
850 #[serde(rename_all = "camelCase")]
852 ManagedTlsSecret {
853 secret_name_template: String,
855 },
856 TlsSecretRef(KubernetesTlsSecretRef),
858 None,
860}
861
862#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
864#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
865#[serde(rename_all = "camelCase")]
866pub struct KubernetesTlsSecretRef {
867 pub secret_name: String,
869 #[serde(default, skip_serializing_if = "Option::is_none")]
871 pub namespace: Option<String>,
872}
873
874#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
883#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
884#[serde(rename_all = "camelCase")]
885pub struct StackSettings {
886 #[serde(default, skip_serializing_if = "is_manual_setup_management")]
889 pub setup_management: SetupManagement,
890 #[serde(default, skip_serializing_if = "Vec::is_empty")]
894 pub quota_warning_overrides: Vec<String>,
895
896 #[serde(default)]
899 pub endpoint_access: EndpointAccess,
900
901 #[serde(default, skip_serializing_if = "Option::is_none")]
908 pub network: Option<NetworkSettings>,
909
910 #[serde(default, skip_serializing_if = "Option::is_none")]
912 pub domains: Option<DomainSettings>,
913
914 #[serde(default, skip_serializing_if = "Option::is_none")]
916 pub kubernetes: Option<KubernetesSettings>,
917
918 #[serde(default, skip_serializing_if = "Option::is_none")]
924 pub compute: Option<ComputeSettings>,
925
926 #[serde(default, skip_serializing_if = "Option::is_none")]
932 #[cfg_attr(
933 feature = "openapi",
934 schema(value_type = Option<HashMap<String, HashMap<String, String>>>)
935 )]
936 pub public_endpoints: Option<crate::PublicEndpointUrls>,
937
938 #[serde(default, skip_serializing_if = "is_default_deployment_model")]
947 pub deployment_model: DeploymentModel,
948
949 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
952 pub airgapped: bool,
953
954 #[serde(default, skip_serializing_if = "is_default_updates_mode")]
958 pub updates: UpdatesMode,
959
960 #[serde(default, skip_serializing_if = "is_default_telemetry_mode")]
965 pub telemetry: TelemetryMode,
966
967 #[serde(default, skip_serializing_if = "is_default_heartbeats_mode")]
971 pub heartbeats: HeartbeatsMode,
972
973 #[serde(default, skip_serializing_if = "Option::is_none")]
978 pub external_bindings: Option<crate::ExternalBindings>,
979
980 #[serde(default, skip_serializing_if = "Option::is_none")]
985 pub signing: Option<StackSigning>,
986}
987
988pub fn machine_image_publisher_aws() -> Option<&'static str> {
992 let account = include_str!("../machine-image-publisher-aws.txt").trim();
993 (account.len() == 12 && account.bytes().all(|byte| byte.is_ascii_digit())).then_some(account)
994}
995
996pub fn machine_image_publisher_gcp() -> Option<&'static str> {
1000 let project = include_str!("../machine-image-publisher-gcp.txt").trim();
1001 (!project.is_empty()
1002 && project.len() <= 30
1003 && project
1004 .bytes()
1005 .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-'))
1006 .then_some(project)
1007}
1008
1009pub fn machine_image_publisher_azure() -> Option<&'static str> {
1014 let gallery = include_str!("../machine-image-publisher-azure.txt").trim();
1015 (!gallery.is_empty()
1016 && gallery.len() <= 100
1017 && gallery
1018 .bytes()
1019 .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-'))
1020 .then_some(gallery)
1021}
1022
1023pub fn machine_image_minimum_created() -> Option<chrono::DateTime<chrono::Utc>> {
1028 let text = include_str!("../machine-image-minimum-created.txt").trim();
1029 chrono::DateTime::parse_from_rfc3339(text)
1030 .ok()
1031 .map(|time| time.with_timezone(&chrono::Utc))
1032}
1033
1034pub fn verifier_image_aws() -> Option<&'static str> {
1039 let image = include_str!("../verifier-image-aws.txt").trim();
1040 is_pinned_image(image).then_some(image)
1041}
1042
1043pub fn verifier_image_gcp() -> Option<&'static str> {
1047 let image = include_str!("../verifier-image-gcp.txt").trim();
1048 is_pinned_image(image).then_some(image)
1049}
1050
1051pub fn verifier_image_azure() -> Option<&'static str> {
1056 let image = include_str!("../verifier-image-azure.txt").trim();
1057 is_pinned_image(image).then_some(image)
1058}
1059
1060pub fn is_pinned_image(image: &str) -> bool {
1062 let Some((repository, hex)) = image.split_once("@sha256:") else {
1063 return false;
1064 };
1065 !repository.is_empty()
1066 && repository
1067 .bytes()
1068 .all(|byte| matches!(byte, b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'/'))
1069 && hex.len() == 64
1070 && hex
1071 .bytes()
1072 .all(|byte| matches!(byte, b'0'..=b'9' | b'a'..=b'f'))
1073}
1074
1075pub fn operator_digest() -> Option<&'static str> {
1079 let digest = include_str!("../operator-digest.txt").trim();
1080 let hex = digest.strip_prefix("sha256:")?;
1081 (hex.len() == 64
1082 && hex
1083 .bytes()
1084 .all(|byte| matches!(byte, b'0'..=b'9' | b'a'..=b'f')))
1085 .then_some(digest)
1086}
1087
1088#[derive(Debug, Clone, Default, PartialEq, Eq)]
1093pub struct SetupPins {
1094 pub aws_publisher: Option<String>,
1096 pub aws_verifier_image: Option<String>,
1098 pub gcp_verifier_image: Option<String>,
1100 pub azure_verifier_image: Option<String>,
1102 pub operator_digest: Option<String>,
1104}
1105
1106impl SetupPins {
1107 pub fn compiled_in() -> Self {
1109 Self {
1110 aws_publisher: machine_image_publisher_aws().map(str::to_string),
1111 aws_verifier_image: verifier_image_aws().map(str::to_string),
1112 gcp_verifier_image: verifier_image_gcp().map(str::to_string),
1113 azure_verifier_image: verifier_image_azure().map(str::to_string),
1114 operator_digest: operator_digest().map(str::to_string),
1115 }
1116 }
1117}
1118
1119#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1124#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1125#[serde(rename_all = "camelCase", deny_unknown_fields)]
1126pub struct StackSigning {
1127 pub fingerprint: String,
1129 pub channel: String,
1131}
1132
1133impl StackSigning {
1134 pub fn settings(&self, prefix: &str) -> Result<SigningSettings> {
1137 let settings = SigningSettings {
1138 fingerprint: self.fingerprint.clone(),
1139 prefix: prefix.to_string(),
1140 channel: self.channel.clone(),
1141 };
1142 settings.validate().map_err(|error| {
1143 AlienError::new(ErrorData::SigningSettingsInvalid {
1144 reason: error.message,
1145 })
1146 })?;
1147 Ok(settings)
1148 }
1149}
1150
1151#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
1153#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1154#[serde(rename_all = "camelCase")]
1155pub enum SetupManagement {
1156 #[default]
1158 Manual,
1159 Automatic,
1161}
1162
1163impl SetupManagement {
1164 pub fn as_str(self) -> &'static str {
1166 match self {
1167 Self::Manual => "manual",
1168 Self::Automatic => "automatic",
1169 }
1170 }
1171}
1172
1173fn is_manual_setup_management(mode: &SetupManagement) -> bool {
1174 *mode == SetupManagement::Manual
1175}
1176
1177fn is_default_deployment_model(model: &DeploymentModel) -> bool {
1178 *model == DeploymentModel::default()
1179}
1180
1181fn is_default_updates_mode(mode: &UpdatesMode) -> bool {
1182 *mode == UpdatesMode::default()
1183}
1184
1185fn is_default_telemetry_mode(mode: &TelemetryMode) -> bool {
1186 *mode == TelemetryMode::default()
1187}
1188
1189fn is_default_heartbeats_mode(mode: &HeartbeatsMode) -> bool {
1190 *mode == HeartbeatsMode::default()
1191}
1192
1193#[cfg(test)]
1194mod failure_domain_tests {
1195 use super::*;
1196
1197 #[test]
1198 fn old_compute_selection_deserializes_without_topology() {
1199 let selection: ComputePoolSelection = serde_json::from_value(serde_json::json!({
1200 "mode": "fixed",
1201 "machines": 2,
1202 "machine": "m7i.xlarge"
1203 }))
1204 .expect("existing selection should deserialize");
1205 assert!(selection.failure_domains().is_none());
1206 }
1207
1208 #[test]
1209 fn rejects_duplicate_concrete_failure_domains() {
1210 let selection = ComputePoolSelection::Fixed {
1211 machines: 2,
1212 machine: Some("m7i.xlarge".to_string()),
1213 failure_domains: Some(FailureDomainSelection {
1214 spread: 2,
1215 selected_failure_domains: vec!["us-west-2a".to_string(); 2],
1216 }),
1217 data_disk_gib: None,
1218 };
1219 assert_eq!(
1220 selection.validate(),
1221 Err("selected failure domains must be unique".to_string())
1222 );
1223 }
1224
1225 #[test]
1226 fn fixed_pool_must_have_one_machine_per_failure_domain() {
1227 let invalid = ComputePoolSelection::Fixed {
1228 machines: 1,
1229 machine: None,
1230 failure_domains: Some(FailureDomainSelection {
1231 spread: 2,
1232 selected_failure_domains: Vec::new(),
1233 }),
1234 data_disk_gib: None,
1235 };
1236 assert_eq!(
1237 invalid.validate(),
1238 Err(
1239 "fixed compute pool machines (1) must be at least failure-domain spread (2)"
1240 .to_string()
1241 )
1242 );
1243
1244 let valid = ComputePoolSelection::Fixed {
1245 machines: 2,
1246 machine: None,
1247 failure_domains: Some(FailureDomainSelection {
1248 spread: 2,
1249 selected_failure_domains: Vec::new(),
1250 }),
1251 data_disk_gib: None,
1252 };
1253 assert_eq!(valid.validate(), Ok(()));
1254 }
1255
1256 #[test]
1257 fn autoscaling_pool_bounds_must_cover_every_failure_domain() {
1258 let invalid_max = ComputePoolSelection::Autoscale {
1259 min: 1,
1260 max: 1,
1261 machine: None,
1262 failure_domains: Some(FailureDomainSelection {
1263 spread: 2,
1264 selected_failure_domains: Vec::new(),
1265 }),
1266 data_disk_gib: None,
1267 };
1268 assert_eq!(
1269 invalid_max.validate(),
1270 Err(
1271 "autoscaling compute pool maximum (1) must be at least failure-domain spread (2)"
1272 .to_string()
1273 )
1274 );
1275
1276 let invalid_min = ComputePoolSelection::Autoscale {
1277 min: 1,
1278 max: 3,
1279 machine: None,
1280 failure_domains: Some(FailureDomainSelection {
1281 spread: 2,
1282 selected_failure_domains: Vec::new(),
1283 }),
1284 data_disk_gib: None,
1285 };
1286 assert_eq!(
1287 invalid_min.validate(),
1288 Err(
1289 "autoscaling compute pool minimum (1) must be at least failure-domain spread (2)"
1290 .to_string()
1291 )
1292 );
1293
1294 let valid = ComputePoolSelection::Autoscale {
1295 min: 2,
1296 max: 2,
1297 machine: None,
1298 failure_domains: Some(FailureDomainSelection {
1299 spread: 2,
1300 selected_failure_domains: Vec::new(),
1301 }),
1302 data_disk_gib: None,
1303 };
1304 assert_eq!(valid.validate(), Ok(()));
1305 }
1306
1307 #[test]
1308 fn machine_public_endpoints_round_trip_without_rewriting_urls() {
1309 let settings: StackSettings = serde_json::from_value(serde_json::json!({
1310 "publicEndpoints": {
1311 "loader": {
1312 "api": "https://loader.compute.example.com",
1313 "shares": "https://shares.compute.example.com",
1314 "webhooks": "https://webhooks.compute.example.com"
1315 }
1316 }
1317 }))
1318 .expect("stack settings should deserialize");
1319
1320 assert_eq!(
1321 serde_json::to_value(settings).expect("stack settings should serialize")
1322 ["publicEndpoints"]["loader"]["shares"],
1323 "https://shares.compute.example.com"
1324 );
1325 }
1326
1327 #[test]
1328 fn custom_domains_preserve_managed_endpoint_names_and_supplied_certificates() {
1329 for config in [
1330 serde_json::json!({
1331 "endpoints": {
1332 "api": "q7.m2x.example.com",
1333 "shares": "*.q7.s9t.example.com",
1334 "webhooks": "*.q7.w3h.example.com"
1335 },
1336 "certificate": {"managed": {}}
1337 }),
1338 serde_json::json!({
1339 "domain": "app.example.com",
1340 "certificate": {"aws": {"certificateArn": "arn:example"}}
1341 }),
1342 ] {
1343 let parsed: CustomDomainConfig = serde_json::from_value(config.clone())
1344 .expect("custom domain configuration should deserialize");
1345 assert_eq!(serde_json::to_value(parsed).unwrap(), config);
1346 }
1347 }
1348}