OXYGENHUB
# baebdd18aaa2 oxygenhub / crates / hub / src / config.rs
8.4 KiB · Rust · last changed Milestone 0.1: browse 1 month ago source blame history raw
1 
//! Configuration (hub spec §17.1): `hub.toml` in the data directory, every
2 
//! key overridable by `OXYHUB_<SECTION>_<KEY>`.
3
4 
use serde::Deserialize;
5 
use std::net::SocketAddr;
6 
use std::path::{Path, PathBuf};
7
8 
#[derive(Clone, Debug, Deserialize)]
9 
#[serde(default, deny_unknown_fields)]
10 
pub struct Config {
11 
    /// Set from the command line, never from the file.
12 
    #[serde(skip)]
13 
    pub data: PathBuf,
14 
    pub site: Site,
15 
    pub server: Server,
16 
    pub tls: Tls,
17 
    pub auth: Auth,
18 
    pub limits: Limits,
19 
    pub retention: Retention,
20 
}
21
22 
#[derive(Clone, Debug, Deserialize)]
23 
#[serde(default, deny_unknown_fields)]
24 
pub struct Site {
25 
    pub name: String,
26 
    pub description: String,
27 
}
28
29 
#[derive(Clone, Debug, Deserialize)]
30 
#[serde(default, deny_unknown_fields)]
31 
pub struct Server {
32 
    /// Plain HTTP; empty disables it.
33 
    pub bind: String,
34 
    /// HTTPS; empty disables it. Needs `tls`.
35 
    pub tls_bind: String,
36 
    /// What links and clone URLs start with.
37 
    pub base_url: String,
38 
    /// Trust `X-Forwarded-*` from a terminating proxy.
39 
    pub behind_proxy: bool,
40 
}
41
42 
#[derive(Clone, Debug, Deserialize)]
43 
#[serde(default, deny_unknown_fields)]
44 
pub struct Tls {
45 
    /// Generate a certificate at `init` (developer edition).
46 
    pub self_signed: bool,
47 
    /// PEM files; relative paths are under the data directory.
48 
    pub cert: String,
49 
    pub key: String,
50 
}
51
52 
#[derive(Clone, Debug, Default, Deserialize)]
53 
#[serde(default, deny_unknown_fields)]
54 
pub struct Auth {
55 
    /// Bearer tokens allowed to push until accounts exist (hub 0.2). Empty
56 
    /// means every push is accepted, as `oxy serve` does.
57 
    pub push_tokens: Vec<String>,
58 
}
59
60 
#[derive(Clone, Debug, Deserialize)]
61 
#[serde(default, deny_unknown_fields)]
62 
pub struct Limits {
63 
    /// Largest file rendered in the browser, e.g. `2MiB`.
64 
    pub render_limit: ByteSize,
65 
    pub asset_limit: ByteSize,
66 
    pub push_body_limit: ByteSize,
67 
}
68
69 
#[derive(Clone, Debug, Deserialize)]
70 
#[serde(default, deny_unknown_fields)]
71 
pub struct Retention {
72 
    pub trash_days: u32,
73 
    pub webhook_log_days: u32,
74 
}
75
76 
/// A byte count written as `512`, `2MiB`, `4GiB`, `100kB`.
77 
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
78 
pub struct ByteSize(pub u64);
79
80 
impl ByteSize {
81 
    pub fn parse(s: &str) -> Option<ByteSize> {
82 
        let s = s.trim();
83 
        let digits: String = s.chars().take_while(|c| c.is_ascii_digit()).collect();
84 
        let unit = s[digits.len()..].trim();
85 
        let n: u64 = digits.parse().ok()?;
86 
        let mult = match unit {
87 
            "" | "B" => 1,
88 
            "k" | "kB" | "KB" => 1000,
89 
            "KiB" | "K" => 1 << 10,
90 
            "M" | "MB" => 1_000_000,
91 
            "MiB" => 1 << 20,
92 
            "G" | "GB" => 1_000_000_000,
93 
            "GiB" => 1 << 30,
94 
            _ => return None,
95 
        };
96 
        Some(ByteSize(n.checked_mul(mult)?))
97 
    }
98 
}
99
100 
impl<'de> Deserialize<'de> for ByteSize {
101 
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<ByteSize, D::Error> {
102 
        #[derive(Deserialize)]
103 
        #[serde(untagged)]
104 
        enum Raw {
105 
            Number(u64),
106 
            Text(String),
107 
        }
108 
        match Raw::deserialize(d)? {
109 
            Raw::Number(n) => Ok(ByteSize(n)),
110 
            Raw::Text(t) => ByteSize::parse(&t).ok_or_else(|| serde::de::Error::custom(format!("not a byte size: {t:?}"))),
111 
        }
112 
    }
113 
}
114
115 
impl Default for Site {
116 
    fn default() -> Self {
117 
        Site { name: "Oxygenhub".into(), description: "Repositories, proposals and issues for Oxygen".into() }
118 
    }
119 
}
120
121 
impl Default for Server {
122 
    fn default() -> Self {
123 
        Server { bind: "127.0.0.1:7300".into(), tls_bind: String::new(), base_url: "http://127.0.0.1:7300".into(), behind_proxy: false }
124 
    }
125 
}
126
127 
impl Default for Tls {
128 
    fn default() -> Self {
129 
        Tls { self_signed: false, cert: "keys/tls.crt".into(), key: "keys/tls.key".into() }
130 
    }
131 
}
132
133 
impl Default for Limits {
134 
    fn default() -> Self {
135 
        Limits { render_limit: ByteSize(2 << 20), asset_limit: ByteSize(512 << 20), push_body_limit: ByteSize(4 << 30) }
136 
    }
137 
}
138
139 
impl Default for Retention {
140 
    fn default() -> Self {
141 
        Retention { trash_days: 30, webhook_log_days: 30 }
142 
    }
143 
}
144
145 
impl Default for Config {
146 
    fn default() -> Self {
147 
        Config {
148 
            data: PathBuf::from("data"),
149 
            site: Site::default(),
150 
            server: Server::default(),
151 
            tls: Tls::default(),
152 
            auth: Auth::default(),
153 
            limits: Limits::default(),
154 
            retention: Retention::default(),
155 
        }
156 
    }
157 
}
158
159 
impl Config {
160 
    /// Read `<data>/hub.toml` if present, then apply environment overrides.
161 
    pub fn load(data: &Path) -> anyhow::Result<Config> {
162 
        let path = data.join("hub.toml");
163 
        let mut cfg = match std::fs::read_to_string(&path) {
164 
            Ok(text) => Config::parse(&text)?,
165 
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Config::default(),
166 
            Err(e) => return Err(anyhow::anyhow!("reading {}: {e}", path.display())),
167 
        };
168 
        cfg.data = data.to_path_buf();
169 
        cfg.apply_env(|k| std::env::var(k).ok());
170 
        Ok(cfg)
171 
    }
172
173 
    pub fn parse(text: &str) -> anyhow::Result<Config> {
174 
        Ok(toml::from_str(text)?)
175 
    }
176
177 
    /// `OXYHUB_SERVER_BIND`, `OXYHUB_SITE_NAME`, … override the file.
178 
    pub fn apply_env(&mut self, get: impl Fn(&str) -> Option<String>) {
179 
        if let Some(v) = get("OXYHUB_SITE_NAME") {
180 
            self.site.name = v;
181 
        }
182 
        if let Some(v) = get("OXYHUB_SITE_DESCRIPTION") {
183 
            self.site.description = v;
184 
        }
185 
        if let Some(v) = get("OXYHUB_SERVER_BIND") {
186 
            self.server.bind = v;
187 
        }
188 
        if let Some(v) = get("OXYHUB_SERVER_TLS_BIND") {
189 
            self.server.tls_bind = v;
190 
        }
191 
        if let Some(v) = get("OXYHUB_SERVER_BASE_URL") {
192 
            self.server.base_url = v;
193 
        }
194 
        if let Some(v) = get("OXYHUB_SERVER_BEHIND_PROXY") {
195 
            self.server.behind_proxy = matches!(v.as_str(), "1" | "true" | "yes");
196 
        }
197 
        if let Some(v) = get("OXYHUB_TLS_SELF_SIGNED") {
198 
            self.tls.self_signed = matches!(v.as_str(), "1" | "true" | "yes");
199 
        }
200 
        if let Some(v) = get("OXYHUB_AUTH_PUSH_TOKENS") {
201 
            self.auth.push_tokens = v.split(',').map(str::trim).filter(|s| !s.is_empty()).map(String::from).collect();
202 
        }
203 
        if let Some(v) = get("OXYHUB_LIMITS_RENDER_LIMIT").and_then(|v| ByteSize::parse(&v)) {
204 
            self.limits.render_limit = v;
205 
        }
206 
    }
207
208 
    pub fn bind_addr(&self) -> anyhow::Result<Option<SocketAddr>> {
209 
        parse_addr(&self.server.bind)
210 
    }
211
212 
    pub fn tls_bind_addr(&self) -> anyhow::Result<Option<SocketAddr>> {
213 
        parse_addr(&self.server.tls_bind)
214 
    }
215
216 
    pub fn tls_cert(&self) -> PathBuf {
217 
        self.data.join(&self.tls.cert)
218 
    }
219
220 
    pub fn tls_key(&self) -> PathBuf {
221 
        self.data.join(&self.tls.key)
222 
    }
223
224 
    pub fn repos_dir(&self) -> PathBuf {
225 
        self.data.join("repos")
226 
    }
227
228 
    pub fn keys_dir(&self) -> PathBuf {
229 
        self.data.join("keys")
230 
    }
231
232 
    pub fn db_path(&self) -> PathBuf {
233 
        self.data.join("hub.db")
234 
    }
235
236 
    /// The base URL without a trailing slash.
237 
    pub fn base_url(&self) -> &str {
238 
        self.server.base_url.trim_end_matches('/')
239 
    }
240 
}
241
242 
fn parse_addr(s: &str) -> anyhow::Result<Option<SocketAddr>> {
243 
    if s.trim().is_empty() {
244 
        return Ok(None);
245 
    }
246 
    Ok(Some(s.parse().map_err(|e| anyhow::anyhow!("bind address {s:?}: {e}"))?))
247 
}
248
249 
#[cfg(test)]
250 
mod tests {
251 
    use super::*;
252
253 
    #[test]
254 
    fn byte_sizes() {
255 
        assert_eq!(ByteSize::parse("2MiB"), Some(ByteSize(2 << 20)));
256 
        assert_eq!(ByteSize::parse("512"), Some(ByteSize(512)));
257 
        assert_eq!(ByteSize::parse("4 GiB"), Some(ByteSize(4 << 30)));
258 
        assert_eq!(ByteSize::parse("100kB"), Some(ByteSize(100_000)));
259 
        assert_eq!(ByteSize::parse("lots"), None);
260 
    }
261
262 
    #[test]
263 
    fn file_then_environment() {
264 
        let mut cfg = Config::parse("[server]\nbind = \"0.0.0.0:7300\"\n[limits]\nrender_limit = \"1MiB\"\n").unwrap();
265 
        assert_eq!(cfg.server.bind, "0.0.0.0:7300");
266 
        assert_eq!(cfg.limits.render_limit, ByteSize(1 << 20));
267 
        assert_eq!(cfg.site.name, "Oxygenhub");
268 
        cfg.apply_env(|k| match k {
269 
            "OXYHUB_SITE_NAME" => Some("Earth".into()),
270 
            "OXYHUB_AUTH_PUSH_TOKENS" => Some("a, b".into()),
271 
            _ => None,
272 
        });
273 
        assert_eq!(cfg.site.name, "Earth");
274 
        assert_eq!(cfg.auth.push_tokens, ["a", "b"]);
275 
        assert!(Config::parse("[nope]\nx = 1\n").is_err(), "unknown sections are errors, not silence");
276 
    }
277 
}