alien-core 1.10.6

Deploy software into your customers' cloud accounts and keep it fully managed
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Environment info per cloud platform, environment variables, and snapshots.

use crate::Platform;
use serde::{Deserialize, Serialize};

/// AWS-specific environment information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct AwsEnvironmentInfo {
    /// AWS account ID
    pub account_id: String,
    /// AWS region
    pub region: String,
}

/// GCP-specific environment information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct GcpEnvironmentInfo {
    /// GCP project number (e.g., "123456789012")
    pub project_number: String,
    /// GCP project ID (e.g., "my-project")
    pub project_id: String,
    /// GCP region
    pub region: String,
}

/// Azure-specific environment information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct AzureEnvironmentInfo {
    /// Azure tenant ID
    pub tenant_id: String,
    /// Azure subscription ID
    pub subscription_id: String,
    /// Azure location/region
    pub location: String,
}

/// Local platform environment information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct LocalEnvironmentInfo {
    /// Hostname of the machine running the deployment
    pub hostname: String,
    /// Operating system (e.g., "linux", "macos", "windows")
    pub os: String,
    /// Architecture (e.g., "x86_64", "aarch64")
    pub arch: String,
}

/// Test platform environment information (mock)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct TestEnvironmentInfo {
    /// Test identifier for this environment
    pub test_id: String,
}

/// Platform-specific environment information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase", tag = "platform")]
pub enum EnvironmentInfo {
    /// AWS environment information
    Aws(AwsEnvironmentInfo),
    /// GCP environment information
    Gcp(GcpEnvironmentInfo),
    /// Azure environment information
    Azure(AzureEnvironmentInfo),
    /// Local platform environment information
    Local(LocalEnvironmentInfo),
    /// Test platform environment information (mock)
    Test(TestEnvironmentInfo),
}

impl EnvironmentInfo {
    /// Get the platform for this environment info
    pub fn platform(&self) -> Platform {
        match self {
            EnvironmentInfo::Aws(_) => Platform::Aws,
            EnvironmentInfo::Gcp(_) => Platform::Gcp,
            EnvironmentInfo::Azure(_) => Platform::Azure,
            EnvironmentInfo::Local(_) => Platform::Local,
            EnvironmentInfo::Test(_) => Platform::Test,
        }
    }
}

/// Type of environment variable
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "lowercase")]
pub enum EnvironmentVariableType {
    /// Plain variable (injected directly into function config)
    Plain,
    /// Secret variable (stored in vault, loaded at runtime)
    Secret,
}

/// Environment variable for deployment
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct EnvironmentVariable {
    /// Variable name
    pub name: String,
    /// Variable value (decrypted - deployment has access to decryption keys)
    pub value: String,
    /// Variable type (plain or secret)
    #[serde(rename = "type")]
    pub var_type: EnvironmentVariableType,
    /// Target resource patterns (null = all resources, Some = wildcard patterns)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target_resources: Option<Vec<String>>,
}

/// Snapshot of environment variables at a point in time
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(rename_all = "camelCase")]
pub struct EnvironmentVariablesSnapshot {
    /// Environment variables in the snapshot
    pub variables: Vec<EnvironmentVariable>,
    /// Deterministic hash of all variables (for change detection)
    pub hash: String,
    /// ISO 8601 timestamp when snapshot was created
    pub created_at: String,
}