scratchstack-config 0.1.2

Scratchstack configuration schema and logic
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

mod iam;
mod sts;

use {
    super::TlsConfig,
    crate::error::ConfigError,
    serde::Deserialize,
    std::{
        fmt::{Debug, Formatter, Result as FmtResult},
        net::{IpAddr, Ipv6Addr, SocketAddr},
    },
    rustls::ServerConfig as TlsServerConfig,
};

pub use self::{
    iam::{Iam, ResolvedIam},
    sts::{Sts, ResolvedSts},
};

/// Configuration for all services.
#[derive(Debug, Deserialize)]
pub struct ServiceConfig {
    pub iam: Option<Iam>,
    pub sts: Option<Sts>,
}

const DEFAULT_ADDRESS: IpAddr = IpAddr::V6(Ipv6Addr::LOCALHOST);

const DEFAULT_PARTITION: &str = "aws";

const DEFAULT_THREADS: usize = 1;

/// Base configuration data for a service. This allows for optional fields and references  to files for things like
/// TLS certificates and keys.
#[derive(Debug, Deserialize)]
pub struct BaseServiceConfig {
    #[serde(default)]
    pub address: Option<IpAddr>,

    #[serde(default)]
    pub port: Option<u16>,

    #[serde(default)]
    pub partition: Option<String>,

    pub region: String,

    #[serde(default)]
    pub tls: Option<TlsConfig>,

    #[serde(default)]
    pub threads: Option<usize>,
}

impl BaseServiceConfig {
    pub fn resolve(&self, default_port: u16) -> Result<ResolvedBaseServiceConfig, ConfigError> {
        let address = self.address.unwrap_or(DEFAULT_ADDRESS);

        let port = self.port.unwrap_or(default_port);
        if port == 0 {
            return Err(ConfigError::InvalidPort);
        }

        let partition = self.partition.clone().unwrap_or_else(|| DEFAULT_PARTITION.to_string());
        if partition.is_empty() {
            return Err(ConfigError::InvalidPartition);
        }

        let region = self.region.clone();
        if region.is_empty() {
            return Err(ConfigError::InvalidRegion);
        }

        let threads = self.threads.unwrap_or(DEFAULT_THREADS);

        let tls = match &self.tls {
            None => None,
            Some(c) => Some(c.to_server_config()?),
        };

        Ok(ResolvedBaseServiceConfig {
            address: SocketAddr::new(address, port),
            partition,
            region,
            threads,
            tls,
        })
    }
}

/// The resolved configuration: optional values have been replaced
pub struct ResolvedBaseServiceConfig {
    pub address: SocketAddr,
    pub partition: String,
    pub region: String,
    pub threads: usize,
    pub tls: Option<TlsServerConfig>,
}

impl Debug for ResolvedBaseServiceConfig {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        let tls_debug = match &self.tls {
            None => "None",
            Some(_) => "Some(TlsServerConfig)",
        };

        f.debug_struct("ResolvedConfig")
            .field("address", &self.address)
            .field("partition", &self.partition)
            .field("region", &self.region)
            .field("threads", &self.threads)
            .field("tls", &tls_debug)
            .finish()
    }
}