alien-bindings 1.3.5

Alien platform runtime bindings
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

use alien_error::AlienError;

// Re-export core traits and types
pub use alien_context::AlienContext;
pub use alien_core::{BindingsMode, Platform};
pub use error::{ErrorData, Result};
pub use provider::BindingsProvider;
pub use traits::{
    ArtifactRegistry, ArtifactRegistryCredentials, ArtifactRegistryPermissions,
    AwsServiceAccountInfo, AzureServiceAccountInfo, Binding, BindingsProviderApi, Build, Container,
    Function, GcpServiceAccountInfo, ImpersonationRequest, Kv, Queue, RepositoryResponse,
    ServiceAccount, ServiceAccountInfo, Storage, Vault,
};
pub use wait_until::{DrainConfig, DrainResponse, WaitUntil, WaitUntilContext};

pub mod error;
#[cfg(feature = "grpc")]
pub mod grpc;
pub mod providers;
pub mod traits;
// Re-export presigned types from alien-core
pub mod presigned {
    pub use alien_core::presigned::*;
}
pub mod alien_context;
pub mod http_client;
pub mod provider;

mod wait_until;

#[cfg(feature = "grpc")]
pub use grpc::control;
#[cfg(feature = "grpc")]
pub use grpc::control_service::ControlGrpcServer;
#[cfg(feature = "grpc")]
pub use grpc::GrpcServerHandles;

/// Gets the current platform from the ALIEN_DEPLOYMENT_TYPE environment variable.
/// This is used by the runtime to determine which platform-specific implementations to use.
pub fn get_current_platform() -> Result<Platform> {
    let env_vars: std::collections::HashMap<String, String> = std::env::vars().collect();
    get_platform_from_env(&env_vars)
}

/// Gets the platform from a HashMap of environment variables.
pub fn get_platform_from_env(env: &std::collections::HashMap<String, String>) -> Result<Platform> {
    let deployment_type = env.get("ALIEN_DEPLOYMENT_TYPE").ok_or_else(|| {
        AlienError::new(ErrorData::EnvironmentVariableMissing {
            variable_name: "ALIEN_DEPLOYMENT_TYPE".to_string(),
        })
    })?;

    deployment_type.parse().map_err(|_| {
        AlienError::new(ErrorData::InvalidEnvironmentVariable {
            variable_name: "ALIEN_DEPLOYMENT_TYPE".to_string(),
            value: deployment_type.clone(),
            reason: "Cannot parse the ALIEN_DEPLOYMENT_TYPE environment variable".to_string(),
        })
    })
}

/// Parse ALIEN_BINDINGS_MODE from environment variables.
/// Defaults to Direct if not specified.
pub fn get_bindings_mode_from_env(
    env: &std::collections::HashMap<String, String>,
) -> Result<BindingsMode> {
    let mode_str = env
        .get("ALIEN_BINDINGS_MODE")
        .map(|s| s.as_str())
        .unwrap_or("direct");

    mode_str.parse().map_err(|reason: String| {
        AlienError::new(ErrorData::InvalidEnvironmentVariable {
            variable_name: "ALIEN_BINDINGS_MODE".to_string(),
            value: mode_str.to_string(),
            reason,
        })
    })
}