Skip to main content

secret_vault/simple_sources/
env_source.rs

1use crate::errors::*;
2use crate::*;
3use async_trait::*;
4use rvstruct::*;
5use secret_vault_value::SecretValue;
6use std::collections::HashMap;
7use tracing::*;
8
9#[derive(Debug)]
10pub struct InsecureEnvSource;
11
12impl InsecureEnvSource {
13    pub fn new() -> Self {
14        Self {}
15    }
16}
17
18#[async_trait]
19impl SecretsSource for InsecureEnvSource {
20    fn name(&self) -> String {
21        "InsecureEnvSource".to_string()
22    }
23
24    async fn get_secrets(
25        &self,
26        references: &[SecretVaultRef],
27    ) -> SecretVaultResult<HashMap<SecretVaultRef, Secret>> {
28        let mut result_map: HashMap<SecretVaultRef, Secret> = HashMap::new();
29
30        for secret_ref in references {
31            let env_secret_name: String = format!(
32                "{}{}",
33                secret_ref.key.secret_name.value(),
34                secret_ref
35                    .key
36                    .secret_version
37                    .as_ref()
38                    .map(|sv| { format!("_V{}", sv.value()) })
39                    .unwrap_or_else(|| "".to_string())
40            );
41
42            trace!(
43                "Loading a secret from environment variable: {}",
44                &env_secret_name
45            );
46            match std::env::var_os(env_secret_name.clone())
47                .or_else(|| std::env::var_os(env_secret_name.to_uppercase()))
48                .as_ref()
49                .and_then(|env| env.to_str())
50            {
51                Some(env) => {
52                    let secret_value = SecretValue::from(env);
53                    let metadata = SecretMetadata::create_from_ref(secret_ref);
54                    result_map.insert(secret_ref.clone(), Secret::new(secret_value, metadata));
55                }
56                None if secret_ref.required => {
57                    return Err(SecretVaultError::DataNotFoundError(
58                        SecretVaultDataNotFoundError::new(
59                            SecretVaultErrorPublicGenericDetails::new("ENV_NOT_FOUND".into()),
60                            format!(
61                                "Secret is required but not found in environment variables {}",
62                                &env_secret_name
63                            ),
64                        ),
65                    ));
66                }
67                None => {
68                    debug!("Secret or secret version {} doesn't exist and since it is not required it is skipped",env_secret_name);
69                }
70            }
71        }
72
73        Ok(result_map)
74    }
75}