Skip to main content

nitr_http/config/
env.rs

1// SPDX-License-Identifier: MIT OR Apache-2.0
2// This file is part of Nitr.
3// See https://nitrweb.com/ for more information
4// Copyright (C) 2024-present Jose Quintana <joseluisq.net>
5
6//! Environment layering: the dotenv-style `[env] file` loaded at startup
7//! and the `NITR_*` override pass applied on top of the parsed TOML.
8
9use std::path::{Path, PathBuf};
10
11use nitr_core::{Error, Result};
12
13use super::{Config, DatabaseConfig, LogFormat};
14
15impl Config {
16    /// Loads the configured dotenv-style file into the process environment.
17    ///
18    /// Called between [`from_file()`](Self::from_file) and
19    /// [`apply_env()`](Self::apply_env); `base` is the directory relative
20    /// paths resolve against (where `nitr.toml` lives, or the working
21    /// directory for a bundle — the env file is external state, like the
22    /// database). Precedence: `NITR_ENV_FILE` names the file outright (it
23    /// can only come from the real environment), else `[env] file` from
24    /// the TOML, else an implicit `.env` under `base` that may be absent —
25    /// only an *explicitly* named file must exist. Loading never
26    /// overwrites variables already present in the process environment.
27    pub fn load_env_file(&self, base: &Path) -> Result {
28        let (path, explicit) = match env_var("NITR_ENV_FILE") {
29            Some(v) => (PathBuf::from(v), true),
30            None => match &self.env.file {
31                Some(file) => (base.join(file), true),
32                None => (base.join(".env"), false),
33            },
34        };
35        if !explicit && !path.is_file() {
36            return Ok(());
37        }
38        dotenvy::from_path(&path).map_err(|err| {
39            Error::Config(format!(
40                "cannot load the env file {}: {err}",
41                path.display()
42            ))
43        })
44    }
45
46    /// Applies `NITR_*` environment variable overrides on top of the
47    /// current values.
48    ///
49    /// Top-level keys keep their plain names: `NITR_LISTEN`,
50    /// `NITR_HANDLER_SCRIPT`, `NITR_CONFIG_SCRIPT`, `NITR_WORKERS`,
51    /// `NITR_MAX_STREAMS`, `NITR_DEV_MODE`, `NITR_PIDFILE`,
52    /// `NITR_TRUST_REQUEST_ID`. A sectioned
53    /// option is named `NITR_<SECTION>_<OPTION>`: `NITR_DATABASE_PATH`,
54    /// `NITR_TEMPLATING_DIR`, `NITR_TESTING_DIR`, `NITR_TESTING_DATABASE`,
55    /// `NITR_ENV_FILE`, `NITR_LUA_MEMORY_LIMIT`,
56    /// `NITR_LUA_EXEC_TIMEOUT_MS`, `NITR_LIMITS_POOL_WAIT_MS`,
57    /// `NITR_SHUTDOWN_GRACE`, `NITR_COMPRESSION_ENABLED`,
58    /// `NITR_TLS_ENABLED`, `NITR_TLS_CERT`, `NITR_TLS_KEY`,
59    /// `NITR_TLS_MIN_VERSION`, `NITR_LOG_FORMAT`, `NITR_LOG_LEVEL`,
60    /// `NITR_OPENAPI_ENABLED`, `NITR_OPENAPI_PATH`, `NITR_SWAGGER_ENABLED`,
61    /// `NITR_SWAGGER_PATH`, `NITR_COOKIES_SECURE`,
62    /// `NITR_RATE_LIMIT_TRUST_FORWARDED_FOR`.
63    pub fn apply_env(&mut self) -> Result {
64        self.apply_env_with(&|name| std::env::var(name).ok())
65    }
66
67    /// [`apply_env()`](Self::apply_env) against an arbitrary lookup.
68    ///
69    /// The process environment is global mutable state, and Rust 2024
70    /// made writing to it `unsafe` — which this workspace forbids
71    /// outright. Taking the lookup as a parameter is what lets the tests
72    /// exercise the layering (env beats TOML, an unparseable value names
73    /// its variable) over a table instead of a shared, order-dependent
74    /// process environment.
75    pub(crate) fn apply_env_with(&mut self, lookup: &dyn Fn(&str) -> Option<String>) -> Result {
76        // An empty value is treated as unset in exactly one place, so the
77        // rule holds for the real environment and for a test table alike:
78        // `NITR_WORKERS=` in a unit file means "I did not set this".
79        let env_var = |name: &str| lookup(name).filter(|v| !v.is_empty());
80        // Superseded names are refused with the rename spelled out:
81        // silently ignoring them would turn a stale deployment manifest
82        // into a config mystery.
83        for (old, new) in [
84            ("NITR_DATABASE", "NITR_DATABASE_PATH"),
85            ("NITR_POOL_WAIT_MS", "NITR_LIMITS_POOL_WAIT_MS"),
86            ("NITR_COMPRESSION", "NITR_COMPRESSION_ENABLED"),
87            ("NITR_TEMPLATES_DIR", "NITR_TEMPLATING_DIR"),
88        ] {
89            if env_var(old).is_some() {
90                return Err(Error::Config(format!(
91                    "{old} was renamed: set {new} instead"
92                )));
93            }
94        }
95        if let Some(v) = env_var("NITR_LISTEN") {
96            self.listen = parse_env("NITR_LISTEN", &v)?;
97        }
98        if let Some(v) = env_var("NITR_HANDLER_SCRIPT") {
99            self.handler_script = PathBuf::from(v);
100        }
101        if let Some(v) = env_var("NITR_CONFIG_SCRIPT") {
102            self.config_script = Some(PathBuf::from(v));
103        }
104        if let Some(v) = env_var("NITR_TEMPLATING_DIR") {
105            self.templating.dir = Some(PathBuf::from(v));
106        }
107        if let Some(v) = env_var("NITR_DATABASE_PATH") {
108            // Overrides only the path; the pragmas stay as configured.
109            match &mut self.database {
110                Some(db) => db.path = PathBuf::from(v),
111                None => self.database = Some(DatabaseConfig::new(v)),
112            }
113        }
114        if let Some(v) = env_var("NITR_TESTING_DIR") {
115            self.testing.dir = PathBuf::from(v);
116        }
117        if let Some(v) = env_var("NITR_TESTING_DATABASE") {
118            self.testing.database = Some(PathBuf::from(v));
119        }
120        if let Some(v) = env_var("NITR_WORKERS") {
121            self.workers = parse_env("NITR_WORKERS", &v)?;
122        }
123        if let Some(v) = env_var("NITR_MAX_STREAMS") {
124            self.max_streams = Some(parse_env("NITR_MAX_STREAMS", &v)?);
125        }
126        if let Some(v) = env_var("NITR_DEV_MODE") {
127            self.dev_mode = parse_env("NITR_DEV_MODE", &v)?;
128        }
129        if let Some(v) = env_var("NITR_TRUST_REQUEST_ID") {
130            self.trust_request_id = parse_env("NITR_TRUST_REQUEST_ID", &v)?;
131        }
132        if let Some(v) = env_var("NITR_RATE_LIMIT_TRUST_FORWARDED_FOR") {
133            self.rate_limit.trust_forwarded_for =
134                parse_env("NITR_RATE_LIMIT_TRUST_FORWARDED_FOR", &v)?;
135        }
136        if let Some(v) = env_var("NITR_COOKIES_SECURE") {
137            self.cookies.secure = parse_env("NITR_COOKIES_SECURE", &v)?;
138        }
139        if let Some(v) = env_var("NITR_LUA_MEMORY_LIMIT") {
140            self.lua.memory_limit = parse_env("NITR_LUA_MEMORY_LIMIT", &v)?;
141        }
142        if let Some(v) = env_var("NITR_LUA_EXEC_TIMEOUT_MS") {
143            self.lua.exec_timeout_ms = parse_env("NITR_LUA_EXEC_TIMEOUT_MS", &v)?;
144        }
145        if let Some(v) = env_var("NITR_LIMITS_POOL_WAIT_MS") {
146            self.limits.pool_wait_ms = parse_env("NITR_LIMITS_POOL_WAIT_MS", &v)?;
147        }
148        if let Some(v) = env_var("NITR_SHUTDOWN_GRACE") {
149            self.shutdown.grace = parse_env("NITR_SHUTDOWN_GRACE", &v)?;
150        }
151        if let Some(v) = env_var("NITR_COMPRESSION_ENABLED") {
152            self.compression.enabled = parse_env("NITR_COMPRESSION_ENABLED", &v)?;
153        }
154        if let Some(v) = env_var("NITR_TLS_ENABLED") {
155            self.tls.enabled = parse_env("NITR_TLS_ENABLED", &v)?;
156        }
157        if let Some(v) = env_var("NITR_OPENAPI_ENABLED") {
158            self.openapi.enabled = parse_env("NITR_OPENAPI_ENABLED", &v)?;
159        }
160        if let Some(v) = env_var("NITR_OPENAPI_PATH") {
161            self.openapi.path = v;
162        }
163        if let Some(v) = env_var("NITR_SWAGGER_ENABLED") {
164            self.swagger.enabled = parse_env("NITR_SWAGGER_ENABLED", &v)?;
165        }
166        if let Some(v) = env_var("NITR_SWAGGER_PATH") {
167            self.swagger.path = v;
168        }
169        if let Some(v) = env_var("NITR_TLS_CERT") {
170            self.tls.cert = Some(PathBuf::from(v));
171        }
172        if let Some(v) = env_var("NITR_TLS_KEY") {
173            self.tls.key = Some(PathBuf::from(v));
174        }
175        if let Some(v) = env_var("NITR_TLS_MIN_VERSION") {
176            self.tls.min_version = Some(v);
177        }
178        if let Some(v) = env_var("NITR_LOG_FORMAT") {
179            self.log.format = match v.as_str() {
180                "text" => LogFormat::Text,
181                "json" => LogFormat::Json,
182                other => {
183                    return Err(Error::Config(format!(
184                        "invalid NITR_LOG_FORMAT `{other}`: expected \"text\" or \"json\""
185                    )));
186                }
187            };
188        }
189        if let Some(v) = env_var("NITR_LOG_LEVEL") {
190            self.log.level = Some(v);
191        }
192        if let Some(v) = env_var("NITR_PIDFILE") {
193            self.pidfile = Some(PathBuf::from(v));
194        }
195        Ok(())
196    }
197}
198
199fn env_var(name: &str) -> Option<String> {
200    std::env::var(name).ok().filter(|v| !v.is_empty())
201}
202
203fn parse_env<T: std::str::FromStr>(name: &str, value: &str) -> Result<T>
204where
205    T::Err: std::fmt::Display,
206{
207    value
208        .parse()
209        .map_err(|err| Error::Config(format!("invalid value for {name}: {err}")))
210}