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
116
117
118
119
120
121
122
123

use {
    rustls::Error as TlsError,
    std::{
        error::Error,
        fmt::{Debug, Display, Formatter, Result as FmtResult},
        io::Error as IOError,
        net::AddrParseError,
        str::Utf8Error,
    },
    toml::de::Error as TomlDeError,
};

#[derive(Debug)]
pub enum ConfigError {
    DeserError(TomlDeError),
    IO(IOError),
    InvalidConfig(String),
    InvalidTlsConfig(TlsConfigErrorKind),
    InvalidDatabaseConfig(DatabaseConfigErrorKind),
    InvalidAddress(AddrParseError),
    InvalidPartition,
    InvalidPort,
    InvalidRegion,
}

impl Display for ConfigError {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match &self {
            Self::DeserError(e) => write!(f, "Deserialization error: {e}"),
            Self::IO(e) => write!(f, "I/O error: {e}"),
            Self::InvalidConfig(msg) => write!(f, "Invalid config: {msg}"),
            Self::InvalidTlsConfig(e) => write!(f, "Invalid TLS configuration: {e}"),
            Self::InvalidDatabaseConfig(e) => write!(f, "Invalid database configuration: {e}"),
            Self::InvalidAddress(e) => write!(f, "Invalid address: {e}"),
            Self::InvalidPartition => write!(f, "Invalid partition"),
            Self::InvalidPort => write!(f, "Invalid port"),
            Self::InvalidRegion => write!(f, "Invalid region"),
        }
    }
}

impl Error for ConfigError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::IO(e) => Some(e),
            Self::DeserError(e) => Some(e),
            Self::InvalidTlsConfig(TlsConfigErrorKind::TlsSetupFailed(e)) => Some(e),
            Self::InvalidDatabaseConfig(DatabaseConfigErrorKind::InvalidPasswordFileEncoding(_, e)) => Some(e),
            Self::InvalidAddress(e) => Some(e),
            _ => None,
        }
    }
}

impl From<AddrParseError> for ConfigError {
    fn from(e: AddrParseError) -> Self {
        ConfigError::InvalidAddress(e)
    }
}

impl From<DatabaseConfigErrorKind> for ConfigError {
    fn from(e: DatabaseConfigErrorKind) -> Self {
        ConfigError::InvalidDatabaseConfig(e)
    }
}

impl From<IOError> for ConfigError {
    fn from(e: IOError) -> Self {
        ConfigError::IO(e)
    }
}

impl From<TlsConfigErrorKind> for ConfigError {
    fn from(e: TlsConfigErrorKind) -> Self {
        ConfigError::InvalidTlsConfig(e)
    }
}

impl From<TomlDeError> for ConfigError {
    fn from(e: TomlDeError) -> Self {
        ConfigError::DeserError(e)
    }
}

#[derive(Debug)]
pub enum DatabaseConfigErrorKind {
    InvalidPasswordFileEncoding(String, Utf8Error),
    MissingPassword,
}

impl Display for DatabaseConfigErrorKind {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match &self {
            Self::InvalidPasswordFileEncoding(s, e) => write!(f, "Invalid password file encoding: {s}: {e}"),
            Self::MissingPassword => {
                write!(f, "Database URL specifies a password placeholder but a password was not supplied")
            }
        }
    }
}

#[derive(Debug)]
pub enum TlsConfigErrorKind {
    TlsSetupFailed(TlsError),
    InvalidCertificate,
    InvalidPrivateKey,
}

impl Display for TlsConfigErrorKind {
    fn fmt(&self, f: &mut Formatter) -> FmtResult {
        match &self {
            TlsConfigErrorKind::TlsSetupFailed(e) => {
                write!(f, "Invalid TLS configuration: {e}")
            }
            TlsConfigErrorKind::InvalidCertificate => {
                write!(f, "Invalid certificate")
            }
            TlsConfigErrorKind::InvalidPrivateKey => {
                write!(f, "Invalid private key")
            }
        }
    }
}