cdk-mintd 0.18.1

CDK mint binary
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

//! Remote signatory environment variables

use std::env;

use super::common::*;
use crate::config::Signatory;

impl Signatory {
    pub fn from_env(mut self) -> Self {
        if let Ok(enabled) = env::var(ENV_SIGNATORY_ENABLED) {
            if let Ok(enabled) = enabled.parse() {
                self.enabled = enabled;
            }
        }

        if let Ok(addr) = env::var(ENV_SIGNATORY_ADDRESS) {
            self.address = addr;
        }

        if let Ok(port) = env::var(ENV_SIGNATORY_PORT) {
            if let Ok(port) = port.parse() {
                self.port = port;
            }
        }

        if let Ok(tls_dir) = env::var(ENV_SIGNATORY_TLS_DIR) {
            self.tls_dir = Some(tls_dir.into());
        }

        if let Some(allow_insecure) = super::bool_override(ENV_SIGNATORY_ALLOW_INSECURE) {
            self.allow_insecure = allow_insecure;
        }

        self
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use super::*;

    fn env_lock() -> std::sync::MutexGuard<'static, ()> {
        crate::test_utils::env_lock()
    }

    fn clear_env_vars() {
        env::remove_var(ENV_SIGNATORY_ENABLED);
        env::remove_var(ENV_SIGNATORY_ADDRESS);
        env::remove_var(ENV_SIGNATORY_PORT);
        env::remove_var(ENV_SIGNATORY_TLS_DIR);
        env::remove_var(ENV_SIGNATORY_ALLOW_INSECURE);
    }

    #[test]
    fn signatory_allow_insecure_override_fails_closed() {
        let _guard = env_lock();
        clear_env_vars();
        let config = Signatory {
            allow_insecure: true,
            ..Default::default()
        };
        assert!(config.clone().from_env().allow_insecure);
        for value in ["false", "not-a-boolean"] {
            env::set_var(ENV_SIGNATORY_ALLOW_INSECURE, value);
            assert!(!config.clone().from_env().allow_insecure);
        }
        #[cfg(unix)]
        {
            use std::os::unix::ffi::OsStringExt;
            env::set_var(
                ENV_SIGNATORY_ALLOW_INSECURE,
                std::ffi::OsString::from_vec(vec![0xff]),
            );
            assert!(!config.from_env().allow_insecure);
        }
        clear_env_vars();
    }

    #[test]
    fn signatory_from_env_reads_enabled_and_connection_fields() {
        let _guard = env_lock();
        clear_env_vars();

        env::set_var(ENV_SIGNATORY_ENABLED, "true");
        env::set_var(ENV_SIGNATORY_ADDRESS, "0.0.0.0");
        env::set_var(ENV_SIGNATORY_PORT, "15061");
        env::set_var(ENV_SIGNATORY_TLS_DIR, "/var/lib/cdk/signatory-tls");
        env::set_var(ENV_SIGNATORY_ALLOW_INSECURE, "true");

        let signatory = Signatory::default().from_env();

        assert!(signatory.enabled);
        assert_eq!(signatory.address, "0.0.0.0");
        assert_eq!(signatory.port, 15061);
        assert_eq!(
            signatory.tls_dir,
            Some(PathBuf::from("/var/lib/cdk/signatory-tls"))
        );
        assert!(signatory.allow_insecure);

        clear_env_vars();
    }
}