greentic-deployer 0.4.35

Greentic deployer runtime for plan construction and deployment-pack dispatch
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use serde::{Deserialize, Serialize};

use crate::config::Provider;
use crate::spec::DeploymentTarget;

/// Top-level execution family behind the unified deployer surface.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AdapterFamily {
    /// Stable OSS path for one Linux VM running one active bundle.
    SingleVm,
    /// Provider-oriented multi-target path used for cloud/k8s/generic adapters.
    ///
    /// Today this mostly represents the older generic deployer layer and is the
    /// integration point for future non-single-vm adapters.
    MultiTarget,
}

/// Unified deployment target selection used to keep adapter families explicit.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "family", content = "target", rename_all = "snake_case")]
pub enum UnifiedTargetSelection {
    SingleVm,
    MultiTarget(MultiTargetKind),
}

impl UnifiedTargetSelection {
    pub fn adapter_family(self) -> AdapterFamily {
        match self {
            Self::SingleVm => AdapterFamily::SingleVm,
            Self::MultiTarget(_) => AdapterFamily::MultiTarget,
        }
    }
}

/// Provider-oriented target kinds that must stay outside the single-vm adapter path.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MultiTargetKind {
    Local,
    Aws,
    Azure,
    Gcp,
    K8s,
    Generic,
}

impl MultiTargetKind {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Local => "local",
            Self::Aws => "aws",
            Self::Azure => "azure",
            Self::Gcp => "gcp",
            Self::K8s => "k8s",
            Self::Generic => "generic",
        }
    }
}

impl From<Provider> for MultiTargetKind {
    fn from(value: Provider) -> Self {
        match value {
            Provider::Local => Self::Local,
            Provider::Aws => Self::Aws,
            Provider::Azure => Self::Azure,
            Provider::Gcp => Self::Gcp,
            Provider::K8s => Self::K8s,
            Provider::Generic => Self::Generic,
        }
    }
}

impl From<DeploymentTarget> for UnifiedTargetSelection {
    fn from(value: DeploymentTarget) -> Self {
        match value {
            DeploymentTarget::SingleVm => Self::SingleVm,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn single_vm_target_stays_in_single_vm_family() {
        let selection = UnifiedTargetSelection::from(DeploymentTarget::SingleVm);
        assert_eq!(selection, UnifiedTargetSelection::SingleVm);
        assert_eq!(selection.adapter_family(), AdapterFamily::SingleVm);
    }

    #[test]
    fn provider_targets_are_classified_as_multi_target_family() {
        for provider in [
            Provider::Local,
            Provider::Aws,
            Provider::Azure,
            Provider::Gcp,
            Provider::K8s,
            Provider::Generic,
        ] {
            let selection = UnifiedTargetSelection::MultiTarget(MultiTargetKind::from(provider));
            assert_eq!(selection.adapter_family(), AdapterFamily::MultiTarget);
        }
    }
}