✨ (config): Admite variables de entorno

Las variables PAGETOP_<SECCIÓN>__<CLAVE> sobrescriben cualquier ajuste
de los archivos, como última capa de la cascada (p. ej.
PAGETOP_DATABASE__DB_PASS para db_pass de [database]).
This commit is contained in:
Manuel Cillero 2026-10-31 19:06:01 +01:00
parent f3228d6b59
commit 1df91ce4c8
10 changed files with 349 additions and 35 deletions

View file

@ -12,8 +12,13 @@
#
# Donde {rm} es el valor de la variable de entorno PAGETOP_RUN_MODE ("default" si no se define o
# está vacía). El directorio config/ puede cambiarse con la variable de entorno CONFIG_DIR (vacía
# equivale a no definirla). No hay más variables de entorno: el resto de opciones sólo se leen de
# estos ficheros.
# equivale a no definirla).
#
# Por último, las variables de entorno con el prefijo PAGETOP_ sobrescriben cualquier opción de los
# ficheros: sección y clave en mayúsculas, con cada nivel separado por dos guiones bajos (p. ej.
# PAGETOP_DATABASE__DB_PASS para db_pass de [database], o PAGETOP_MAIL__SMTP__PASSWORD para password
# de [mail.smtp]). Una variable vacía equivale a no definirla. No sirven para listas ni para claves
# con punto, como "mail.queue" en [cron.jobs."mail.queue"].
#
# Las opciones comentadas no tienen valor por defecto; se muestran con un valor de ejemplo.
#

View file

@ -201,7 +201,8 @@ una clave secreta, una ruta expuesta) y pierde precisión. Mejor `"internal"`.
```toml
[cron]
mode = "external"
trigger_token = "..." # Clave secreta propia, mejor en config/local.toml.
trigger_token = "..." # Clave secreta propia, mejor en config/local.toml o en
# PAGETOP_CRON__TRIGGER_TOKEN.
trigger_interval_secs = 60 # Una llamada por minuto (el valor por defecto).
```

View file

@ -47,7 +47,8 @@ pub struct CronSettings {
/// Clave secreta que autoriza las llamadas a `POST /cron` con [`CronMode::External`], enviada
/// en la cabecera `Authorization: Bearer <clave>`. Obligatoria en ese modo, con 16 caracteres
/// o más (letras, dígitos, `-` o `_`), o la aplicación no arranca. Conviene guardarla en
/// `config/local.toml`, que no se versiona.
/// `config/local.toml`, que no se versiona, o pasarla con la variable de entorno
/// `PAGETOP_CRON__TRIGGER_TOKEN`.
pub trigger_token: Option<String>,
/// Segundos entre dos llamadas a `POST /cron` con [`CronMode::External`]. Cada llamada ejecuta
/// los trabajos programados en el último intervalo de esta duración, contado en múltiplos

View file

@ -206,7 +206,8 @@ una clave secreta, una ruta expuesta) y pierde precisión. Mejor `"internal"`.
```toml
[cron]
mode = "external"
trigger_token = "..." # Clave secreta propia, mejor en config/local.toml.
trigger_token = "..." # Clave secreta propia, mejor en config/local.toml o en
# PAGETOP_CRON__TRIGGER_TOKEN.
trigger_interval_secs = 60 # Una llamada por minuto (el valor por defecto).
```

View file

@ -59,7 +59,8 @@ base_url = "https://example.com"
host = "smtp.example.com"
security = "starttls" # "none", "opportunistic", "starttls" o "tls".
username = "no-reply@example.com"
password = "secreto" # Mejor en config/local.toml, que no se versiona.
password = "secreto" # Mejor en config/local.toml, que no se versiona, o en la
# variable de entorno PAGETOP_MAIL__SMTP__PASSWORD.
```
Sin configurar, los correos se escriben en las trazas en lugar de enviarse (`transport = "log"`),

View file

@ -152,7 +152,8 @@ pub struct SmtpSettings {
pub security: SmtpSecurity,
/// Usuario para autenticarse en el servidor. Sin valor, no se autentica.
pub username: Option<String>,
/// Contraseña del usuario. Conviene guardarla en `config/local.toml`, que no se versiona.
/// Contraseña del usuario. Conviene guardarla en `config/local.toml`, que no se versiona, o
/// pasarla con la variable de entorno `PAGETOP_MAIL__SMTP__PASSWORD`.
pub password: Option<String>,
/// Nombre con el que se presenta la aplicación al servidor (`EHLO`). Sin valor, el nombre del
/// equipo.

View file

@ -60,7 +60,8 @@ base_url = "https://example.com"
host = "smtp.example.com"
security = "starttls" # "none", "opportunistic", "starttls" o "tls".
username = "no-reply@example.com"
password = "secreto" # Mejor en config/local.toml, que no se versiona.
password = "secreto" # Mejor en config/local.toml, que no se versiona, o en la
# variable de entorno PAGETOP_MAIL__SMTP__PASSWORD.
```
Sin configurar, los correos se escriben en las trazas en lugar de enviarse (`transport = "log"`),

View file

@ -5,9 +5,9 @@
//! no se definan.
//!
//! Separar la configuración del código permite que cada despliegue (*dev*, *staging*, *production*,
//! etc.) tenga su propia configuración sin recompilar. Los ajustes sólo se leen de archivos; las
//! variables de entorno no los sobrescriben, únicamente eligen qué archivos cargar (`CONFIG_DIR` y
//! `PAGETOP_RUN_MODE`, cuyo valor queda además en `app.run_mode`).
//! etc.) tenga su propia configuración sin recompilar. Los ajustes se leen de archivos y pueden
//! sobrescribirse con [variables de entorno](#variables-de-entorno), útiles para pasar secretos o
//! ajustes de un despliegue concreto (Docker, systemd, Kubernetes...) sin escribirlos en archivos.
//!
//! # Orden de carga
//!
@ -54,6 +54,37 @@
//! Los archivos se combinan clave a clave en el orden anterior. Cada archivo sobrescribe a los
//! anteriores sólo en las claves que define.
//!
//! # Variables de entorno
//!
//! Por último, las variables de entorno con el prefijo `PAGETOP_` sobrescriben los valores de los
//! archivos. El nombre de la variable se forma con la sección y la clave en mayúsculas, separando
//! cada nivel con dos guiones bajos (`__`), porque las claves ya llevan guiones bajos simples:
//!
//! ```sh
//! PAGETOP_DATABASE__DB_PASS=secreto # [database] db_pass
//! PAGETOP_MAIL__SMTP__PASSWORD=secreto # [mail.smtp] password
//! PAGETOP_SERVER__BIND_PORT=80 # [server] bind_port
//! ```
//!
//! El valor se convierte al tipo del ajuste: un número se escribe en decimal (`80`), un booleano
//! como `true` o `false`, y una cadena tal cual, sin comillas. Como en los archivos, un valor no
//! válido o una clave desconocida detienen el arranque. Además:
//!
//! * Una variable vacía equivale a no definirla, así que no sirve para vaciar un valor de los
//! archivos.
//!
//! * Una variable de ajustes cuyo valor no es Unicode válido también detiene el arranque.
//!
//! * No sirven para las listas ni para las claves que llevan un punto, como `mail.queue` en
//! `[cron.jobs."mail.queue"]`. Ésas se configuran en los archivos. Un trabajo con una clave sin
//! punto, como `cleanup`, sí: `PAGETOP_CRON__JOBS__CLEANUP__ENABLED=false`.
//!
//! * Con la *feature* `testing` se ignoran, como `PAGETOP_RUN_MODE`, para que las variables de la
//! terminal no cambien el resultado de las pruebas.
//!
//! Al arrancar, las trazas indican qué ajustes vienen de variables de entorno (las claves, nunca
//! los valores), para que se sepa de dónde sale un valor que no aparece en los archivos.
//!
//! # Cómo declarar ajustes
//!
//! Cada extensión declara sus ajustes en una estructura con el atributo
@ -117,9 +148,10 @@
//! PageTop carga los ajustes de todas las extensiones durante el arranque, en el orden en que se
//! registran y antes de inicializarlas. Si unos ajustes no pueden cargarse, la aplicación se
//! detiene con un mensaje que indica el problema: el archivo y la línea si un TOML está mal
//! formado, o la sección y el valor no válido o la **clave desconocida** (típicamente una errata).
//! También avisa al arrancar de las secciones de los archivos que no corresponden a PageTop ni a
//! ninguna extensión.
//! formado, o la sección y el valor no válido o la **clave desconocida** (típicamente una errata),
//! junto con los nombres de las variables de entorno que sobrescriben esa sección, si las hay.
//! También avisa al arrancar de las secciones que no corresponden a PageTop ni a ninguna extensión,
//! vengan de los archivos o de variables de entorno.
//!
//! Fuera de una aplicación en marcha (p. ej. en pruebas unitarias) los ajustes se cargan en el
//! primer acceso a la variable, con las mismas reglas.
@ -128,11 +160,12 @@
use crate::{AutoDefault, BoxError, trace, util};
use config::{Config, ConfigError, File, FileFormat};
use config::{Config, ConfigError, Environment, File, FileFormat, Map};
use serde::de::{DeserializeOwned, IgnoredAny};
use std::collections::HashMap;
use std::env;
use std::ffi::OsString;
use std::ops::Deref;
use std::path::PathBuf;
use std::sync::{LazyLock, OnceLock};
@ -143,11 +176,113 @@ const DEFAULT_CONFIG_DIR: &str = "config";
// Modo de ejecución por defecto.
const DEFAULT_RUN_MODE: &str = "default";
// Configuración combinada de los archivos TOML en el orden de carga, más el modo de ejecución
// (`app.run_mode`), o el texto del error si no se pudieron leer (`ConfigError` no implementa
// `Clone`). Se construye una sola vez, en el primer acceso, y sólo la leen las funciones de este
// módulo: así ningún ajuste se salta las comprobaciones de `#[settings]`.
// Prefijo de las variables de entorno que sobrescriben ajustes.
const ENV_PREFIX: &str = "PAGETOP_";
// Separador de niveles (sección, subsección y clave) en el nombre de esas variables.
const ENV_SEPARATOR: &str = "__";
// Variables de entorno que sobrescriben ajustes, o el texto del error si alguna no se puede leer.
// Con la *feature* `testing` no se lee ninguna.
static ENV_VARS: LazyLock<Result<Map<String, String>, String>> = LazyLock::new(|| {
if cfg!(feature = "testing") {
return Ok(Map::new());
}
env_overrides(env::vars_os())
});
// Selecciona las variables que sobrescriben ajustes: las que empiezan por `ENV_PREFIX`, con al
// menos un `ENV_SEPARATOR` tras el prefijo (sección y clave) y un valor no vacío. Un valor que no
// es Unicode válido es un error, como cualquier otro valor no válido; un nombre que no lo es no
// puede ser el de un ajuste y se ignora, como el resto de variables ajenas.
fn env_overrides(
vars: impl IntoIterator<Item = (OsString, OsString)>,
) -> Result<Map<String, String>, String> {
let mut overrides = Map::new();
for (key, value) in vars {
let Some(key) = key.to_str().filter(|key| {
key.strip_prefix(ENV_PREFIX)
.is_some_and(|rest| rest.contains(ENV_SEPARATOR))
}) else {
continue;
};
if value.is_empty() {
continue;
}
let value = value
.into_string()
.map_err(|_| format!("Environment variable {key} is not valid Unicode"))?;
overrides.insert(key.to_string(), value);
}
Ok(overrides)
}
// Nombres de las variables de entorno que sobrescriben ajustes. Ninguno si no se pudieron leer: en
// ese caso falla la lectura de la configuración, que devuelve el error.
fn env_names() -> impl Iterator<Item = &'static str> {
ENV_VARS
.iter()
.flat_map(|vars| vars.keys())
.map(String::as_str)
}
// Añade al error de una sección los nombres de las variables de entorno que la sobrescriben, si
// hay alguna. El error de una clave desconocida no dice de dónde viene, y una que llega de una
// variable no aparece en ningún archivo.
fn with_env_names<'a>(
err: ConfigError,
section: &str,
names: impl Iterator<Item = &'a str>,
) -> ConfigError {
let mut names: Vec<&str> = names
.filter(|name| {
name.strip_prefix(ENV_PREFIX)
.and_then(|rest| rest.split(ENV_SEPARATOR).next())
.is_some_and(|name_section| name_section.eq_ignore_ascii_case(section))
})
.collect();
if names.is_empty() {
return err;
}
names.sort_unstable();
ConfigError::Message(format!(
"{err} (environment variables in this section: {})",
names.join(", ")
))
}
// Fuente de configuración con las variables ya filtradas. Sin `try_parsing`: los valores llegan
// como cadenas y se convierten al deserializar según el tipo de cada ajuste; con él, una
// contraseña `0123` llegaría como el número `123`.
fn env_source(vars: Map<String, String>) -> Environment {
Environment::with_prefix(ENV_PREFIX.trim_end_matches('_'))
.prefix_separator("_")
.separator(ENV_SEPARATOR)
.source(Some(vars))
}
// Clave de cada ajuste sobrescrito por una variable de entorno (p. ej. `database.db_pass`), en
// orden alfabético.
pub(crate) fn env_keys() -> Vec<String> {
let mut keys: Vec<String> = env_names()
.map(|name| {
name[ENV_PREFIX.len()..]
.to_lowercase()
.replace(ENV_SEPARATOR, ".")
})
.collect();
keys.sort();
keys
}
// Configuración combinada de los archivos TOML en el orden de carga y de las variables de entorno,
// más el modo de ejecución (`app.run_mode`), o el texto del error si no se pudieron leer
// (`ConfigError` no implementa `Clone`). Se construye una sola vez, en el primer acceso, y sólo la
// leen las funciones de este módulo: así ningún ajuste se salta las comprobaciones de
// `#[settings]`.
static CONFIG_VALUES: LazyLock<Result<Config, String>> = LazyLock::new(|| {
let env_vars = ENV_VARS.clone()?;
// CONFIG_DIR (si existe) o DEFAULT_CONFIG_DIR. Si no se puede resolver, se usa tal cual. Sólo
// se avisa si CONFIG_DIR está definida: que falte el directorio predeterminado es normal en una
// aplicación sin configuración propia, pero un CONFIG_DIR erróneo podría dejar la aplicación
@ -187,29 +322,31 @@ static CONFIG_VALUES: LazyLock<Result<Config, String>> = LazyLock::new(|| {
.add_source(File::from(config_dir.join(format!("local.{rm}.toml"))).required(false))
// 4. Configuración local común (local.toml).
.add_source(File::from(config_dir.join("local.toml")).required(false))
// 5. Variables de entorno (p. ej. PAGETOP_DATABASE__DB_PASS).
.add_source(env_source(env_vars))
// Guarda el modo de ejecución explícitamente.
.set_override("app.run_mode", rm)
.and_then(|builder| builder.build())
.map_err(|err| err.to_string())
});
// Configuración combinada, o el error que impidió leer los archivos.
// Configuración combinada, o el error que impidió leer los archivos o las variables de entorno.
fn config_values() -> Result<&'static Config, ConfigError> {
CONFIG_VALUES
.as_ref()
.map_err(|message| ConfigError::Message(message.clone()))
}
// Comprueba que los archivos de configuración se pueden leer (p. ej. que ningún TOML está mal
// formado), para detener el arranque con un error en lugar del `panic!` del primer acceso.
pub(crate) fn check_files() -> Result<(), ConfigError> {
// Comprueba que la configuración se puede leer (p. ej. que ningún TOML está mal formado), para
// detener el arranque con un error en lugar del `panic!` del primer acceso.
pub(crate) fn check_sources() -> Result<(), ConfigError> {
config_values().map(|_| ())
}
// Comprueba, sin guardarlos, que los ajustes de la sección de `T` se pueden cargar. Sirve para los
// ajustes que se guardan en otra variable, como los globales de PageTop.
pub(crate) fn check<T: SettingsSection>() -> Result<(), ConfigError> {
section_from::<T>(config_values()?).map(|_| ())
read_section::<T>(config_values()?).map(|_| ())
}
// Secciones del primer nivel de la configuración.
@ -238,14 +375,14 @@ pub trait SettingsSection: DeserializeOwned + Default + Send + Sync + 'static {
}
// Carga los ajustes de la sección `T::SECTION` de la configuración. Las claves ausentes toman su
// valor por defecto, y si falta la sección entera se usan los de todos los campos. Si los archivos
// no se pueden leer o la sección no puede deserializarse (un valor no válido o una clave
// desconocida), lanza `panic!` con un mensaje que indica el problema. Al arrancar no llega a
// valor por defecto, y si falta la sección entera se usan los de todos los campos. Si la
// configuración no se puede leer o la sección no puede deserializarse (un valor no válido o una
// clave desconocida), lanza `panic!` con un mensaje que indica el problema. Al arrancar no llega a
// ocurrir: la aplicación lo comprueba antes y se detiene con un error.
pub(crate) fn load<T: SettingsSection>() -> T {
let config = config_values()
.unwrap_or_else(|err| panic!("Failed to read the configuration files: {err}"));
section_from(config)
let config =
config_values().unwrap_or_else(|err| panic!("Failed to read the configuration: {err}"));
read_section(config)
.unwrap_or_else(|err| panic!("Invalid settings in section [{}]: {err}", T::SECTION))
}
@ -262,6 +399,12 @@ pub fn load_from_str<T: SettingsSection>(toml: &str) -> Result<T, ConfigError> {
section_from(&config)
}
// Lee la sección de `T` de la configuración combinada. Si no puede, el error nombra además las
// variables de entorno que sobrescriben la sección.
fn read_section<T: SettingsSection>(config: &Config) -> Result<T, ConfigError> {
section_from(config).map_err(|err| with_env_names(err, T::SECTION, env_names()))
}
// Lee la sección de `T` de una configuración; si falta entera, usa los valores por defecto.
fn section_from<T: SettingsSection>(config: &Config) -> Result<T, ConfigError> {
match config.get::<T>(T::SECTION) {
@ -346,7 +489,7 @@ impl<T: SettingsSection> LoadSettings for LazySettings<T> {
// mismos.
fn load(&self) -> Result<(), BoxError> {
if self.0.get().is_none() {
let _ = self.0.set(section_from::<T>(config_values()?)?);
let _ = self.0.set(read_section::<T>(config_values()?)?);
}
Ok(())
}
@ -355,3 +498,155 @@ impl<T: SettingsSection> LoadSettings for LazySettings<T> {
T::SECTION
}
}
#[cfg(test)]
mod tests {
use super::{
Config, ConfigError, File, FileFormat, OsString, env_overrides, env_source, section_from,
with_env_names,
};
use crate::settings;
#[settings(section = "sample")]
struct SampleSettings {
#[default = "from-default"]
name: String,
#[default = "from-default"]
password: String,
#[default = 8080]
port: u16,
#[default = false]
enabled: bool,
limit: Option<u16>,
nested: NestedSettings,
}
#[settings]
struct NestedSettings {
#[default = "from-default"]
user: String,
}
const TOML: &str = r#"
[sample]
name = "from-file"
password = "from-file"
port = 3000
"#;
fn os_vars<'a>(vars: &'a [(&str, &str)]) -> impl Iterator<Item = (OsString, OsString)> + 'a {
vars.iter().map(|(k, v)| (k.into(), v.into()))
}
fn load(vars: &[(&str, &str)]) -> Result<SampleSettings, ConfigError> {
let config = Config::builder()
.add_source(File::from_str(TOML, FileFormat::Toml))
.add_source(env_source(env_overrides(os_vars(vars)).unwrap()))
.build()?;
section_from::<SampleSettings>(&config)
}
#[test]
fn env_vars_override_file_values() {
let s = load(&[
("PAGETOP_SAMPLE__PASSWORD", "from-env"),
("PAGETOP_SAMPLE__PORT", "80"),
("PAGETOP_SAMPLE__ENABLED", "true"),
("PAGETOP_SAMPLE__LIMIT", "5"),
("PAGETOP_SAMPLE__NESTED__USER", "from-env"),
])
.unwrap();
assert_eq!(s.name, "from-file");
assert_eq!(s.password, "from-env");
assert_eq!(s.port, 80);
assert!(s.enabled);
assert_eq!(s.limit, Some(5));
assert_eq!(s.nested.user, "from-env");
}
#[test]
fn env_values_are_not_parsed_before_deserializing() {
// A numeric-looking string must keep its leading zeros.
let s = load(&[("PAGETOP_SAMPLE__PASSWORD", "0123")]).unwrap();
assert_eq!(s.password, "0123");
}
#[test]
fn env_var_with_unknown_key_is_rejected() {
let error = load(&[("PAGETOP_SAMPLE__PASWORD", "typo")]).err().unwrap();
assert!(
error.to_string().contains("pasword"),
"unexpected error: {error}"
);
}
#[test]
fn env_var_with_invalid_value_is_rejected() {
assert!(load(&[("PAGETOP_SAMPLE__PORT", "not-a-port")]).is_err());
}
#[test]
fn empty_env_vars_are_ignored() {
let s = load(&[("PAGETOP_SAMPLE__PASSWORD", "")]).unwrap();
assert_eq!(s.password, "from-file");
}
#[test]
fn only_prefixed_vars_with_section_and_key_are_taken() {
let vars = env_overrides(os_vars(&[
("PAGETOP_RUN_MODE", "production"),
("PAGETOP_SAMPLE__NAME", "x"),
("OTHER_SAMPLE__NAME", "x"),
("pagetop_sample__name", "x"),
]))
.unwrap();
assert_eq!(vars.len(), 1);
assert!(vars.contains_key("PAGETOP_SAMPLE__NAME"));
}
#[cfg(unix)]
#[test]
fn non_unicode_values_are_rejected_only_in_setting_vars() {
use std::os::unix::ffi::OsStringExt;
let invalid = || OsString::from_vec(vec![0xff]);
let error = env_overrides([("PAGETOP_SAMPLE__NAME".into(), invalid())]).unwrap_err();
assert!(
error.contains("PAGETOP_SAMPLE__NAME"),
"unexpected error: {error}"
);
// Foreign variables, and names that cannot be settings, are ignored.
assert!(
env_overrides([("OTHER_VAR".into(), invalid())])
.unwrap()
.is_empty()
);
assert!(env_overrides([(invalid(), "x".into())]).unwrap().is_empty());
}
#[test]
fn section_errors_name_the_env_vars_of_that_section() {
let names = [
"PAGETOP_SAMPLE__PASWORD",
"PAGETOP_OTHER__NAME",
"PAGETOP_SAMPLE__NESTED__USER",
];
let error = with_env_names(
ConfigError::Message("unknown field `pasword`".into()),
"sample",
names.into_iter(),
);
assert_eq!(
error.to_string(),
"unknown field `pasword` (environment variables in this section: \
PAGETOP_SAMPLE__NESTED__USER, PAGETOP_SAMPLE__PASWORD)"
);
// Without variables for the section, the error is left as it was.
let error = with_env_names(
ConfigError::Message("unknown field `x`".into()),
"sample",
["PAGETOP_OTHER__NAME"].into_iter(),
);
assert_eq!(error.to_string(), "unknown field `x`");
}
}

View file

@ -12,8 +12,9 @@ static EXTENSIONS: OnceLock<Vec<ExtensionRef>> = OnceLock::new();
/// Errores de las extensiones que detienen el arranque de la aplicación.
#[derive(Debug, thiserror::Error)]
pub enum StartupError {
/// Los archivos de configuración no se pueden leer (p. ej. un TOML mal formado).
#[error("Failed to read the configuration files")]
/// La configuración no se puede leer (p. ej. un TOML mal formado o una variable de entorno de
/// ajustes cuyo valor no es Unicode válido).
#[error("Failed to read the configuration")]
ReadConfig(#[source] BoxError),
/// Dos extensiones, o una extensión y PageTop, reclaman la misma sección de la configuración:
/// cada una la leería con su propia estructura de ajustes.
@ -142,6 +143,13 @@ pub fn load_settings() -> Result<(), StartupError> {
// Separada de `load_settings()` para poder probarla sin el registro global de extensiones.
fn load_settings_of(extensions: &[ExtensionRef]) -> Result<(), StartupError> {
trace::info!("Loading settings for all extensions");
let env_keys = config::env_keys();
if !env_keys.is_empty() {
trace::info!(
"Settings from environment variables: {}",
env_keys.join(", ")
);
}
let mut known: Vec<&str> = global::SECTIONS.to_vec();
for settings in extensions.iter().filter_map(|e| e.settings()) {
let section = settings.section();

View file

@ -33,10 +33,10 @@ pub static SETTINGS: LazyLock<Settings> = LazyLock::new(|| Settings {
upload: config::load(),
});
// Comprueba que los archivos de configuración se pueden leer y que los ajustes globales son válidos.
// Comprueba que la configuración se puede leer y que los ajustes globales son válidos.
// La aplicación lo llama al arrancar, antes del primer acceso a `SETTINGS`, que lanzaría `panic!`.
pub(crate) fn check_settings() -> Result<(), StartupError> {
config::check_files().map_err(|err| StartupError::ReadConfig(err.into()))?;
config::check_sources().map_err(|err| StartupError::ReadConfig(err.into()))?;
check_section::<AppSettings>()?;
check_section::<DevSettings>()?;
check_section::<LogSettings>()?;