diff --git a/config/reference.toml b/config/reference.toml index 8f55a08e..5208120e 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -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. # diff --git a/extensions/pagetop-cron/README.md b/extensions/pagetop-cron/README.md index 849b16ad..e25fc554 100644 --- a/extensions/pagetop-cron/README.md +++ b/extensions/pagetop-cron/README.md @@ -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). ``` diff --git a/extensions/pagetop-cron/src/config.rs b/extensions/pagetop-cron/src/config.rs index 981f45ca..1e4a9fae 100644 --- a/extensions/pagetop-cron/src/config.rs +++ b/extensions/pagetop-cron/src/config.rs @@ -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 `. 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, /// 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 diff --git a/extensions/pagetop-cron/src/lib.rs b/extensions/pagetop-cron/src/lib.rs index e4694b4e..3ad59bca 100644 --- a/extensions/pagetop-cron/src/lib.rs +++ b/extensions/pagetop-cron/src/lib.rs @@ -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). ``` diff --git a/extensions/pagetop-mail/README.md b/extensions/pagetop-mail/README.md index cd07d953..565892f8 100644 --- a/extensions/pagetop-mail/README.md +++ b/extensions/pagetop-mail/README.md @@ -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"`), diff --git a/extensions/pagetop-mail/src/config.rs b/extensions/pagetop-mail/src/config.rs index 6bfa81e3..b08b11f9 100644 --- a/extensions/pagetop-mail/src/config.rs +++ b/extensions/pagetop-mail/src/config.rs @@ -152,7 +152,8 @@ pub struct SmtpSettings { pub security: SmtpSecurity, /// Usuario para autenticarse en el servidor. Sin valor, no se autentica. pub username: Option, - /// 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, /// Nombre con el que se presenta la aplicación al servidor (`EHLO`). Sin valor, el nombre del /// equipo. diff --git a/extensions/pagetop-mail/src/lib.rs b/extensions/pagetop-mail/src/lib.rs index f2dbd05f..81c28a24 100644 --- a/extensions/pagetop-mail/src/lib.rs +++ b/extensions/pagetop-mail/src/lib.rs @@ -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"`), diff --git a/src/config.rs b/src/config.rs index 03532550..5e4c3c24 100644 --- a/src/config.rs +++ b/src/config.rs @@ -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, 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, +) -> Result, 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 { + 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, +) -> 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) -> 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 { + let mut keys: Vec = 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> = 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> = 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() -> Result<(), ConfigError> { - section_from::(config_values()?).map(|_| ()) + read_section::(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 { - 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(toml: &str) -> Result { 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(config: &Config) -> Result { + 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(config: &Config) -> Result { match config.get::(T::SECTION) { @@ -346,7 +489,7 @@ impl LoadSettings for LazySettings { // mismos. fn load(&self) -> Result<(), BoxError> { if self.0.get().is_none() { - let _ = self.0.set(section_from::(config_values()?)?); + let _ = self.0.set(read_section::(config_values()?)?); } Ok(()) } @@ -355,3 +498,155 @@ impl LoadSettings for LazySettings { 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, + 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 + 'a { + vars.iter().map(|(k, v)| (k.into(), v.into())) + } + + fn load(vars: &[(&str, &str)]) -> Result { + 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::(&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`"); + } +} diff --git a/src/core/extension/all.rs b/src/core/extension/all.rs index 9a9b1658..ccccbb39 100644 --- a/src/core/extension/all.rs +++ b/src/core/extension/all.rs @@ -12,8 +12,9 @@ static EXTENSIONS: OnceLock> = 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(); diff --git a/src/global.rs b/src/global.rs index 802b5da5..baaf7248 100644 --- a/src/global.rs +++ b/src/global.rs @@ -33,10 +33,10 @@ pub static SETTINGS: LazyLock = 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::()?; check_section::()?; check_section::()?;