From d1d3a62c8f9b5696dda2719bc04803117dff357e Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sat, 17 Oct 2026 11:27:51 +0200 Subject: [PATCH] =?UTF-8?q?=F0=9F=A5=85=20(config):=20Detiene=20arranque?= =?UTF-8?q?=20si=20config=20falla?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/app.rs | 5 ++++ src/config.rs | 52 ++++++++++++++++++++++++++++++--------- src/core/extension/all.rs | 3 +++ src/global.rs | 18 ++++++++++++++ 4 files changed, 66 insertions(+), 12 deletions(-) diff --git a/src/app.rs b/src/app.rs index ebd1cb22..9a24f45b 100644 --- a/src/app.rs +++ b/src/app.rs @@ -72,6 +72,11 @@ impl Application { // Secuencia de arranque común a new() y prepare(). async fn internal_prepare(root_extension: Option) -> Self { + // Comprueba la configuración global antes de usarla. Un error detiene aquí el arranque. + if let Err(err) = global::check_settings() { + Self::abort_startup(None, err); + } + // Al arrancar muestra una cabecera para la aplicación. Self::show_banner(); diff --git a/src/config.rs b/src/config.rs index b311a653..03532550 100644 --- a/src/config.rs +++ b/src/config.rs @@ -144,9 +144,10 @@ const DEFAULT_CONFIG_DIR: &str = "config"; 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`). 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(|| { +// (`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(|| { // 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 @@ -189,14 +190,38 @@ static CONFIG_VALUES: LazyLock = LazyLock::new(|| { // Guarda el modo de ejecución explícitamente. .set_override("app.run_mode", rm) .and_then(|builder| builder.build()) - .unwrap_or_else(|err| panic!("Failed to read the configuration files: {err}")) + .map_err(|err| err.to_string()) }); +// Configuración combinada, o el error que impidió leer los archivos. +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> { + 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(|_| ()) +} + // Secciones del primer nivel de la configuración. pub(crate) fn sections() -> Vec { - CONFIG_VALUES - .clone() - .try_deserialize::>() + config_values() + .ok() + .and_then(|config| { + config + .clone() + .try_deserialize::>() + .ok() + }) .map(|sections| sections.into_keys().collect()) .unwrap_or_default() } @@ -213,11 +238,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 la sección no -// puede deserializarse (un valor no válido o una clave desconocida), lanza `panic!` con un mensaje -// que indica la sección y el problema. +// 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 +// ocurrir: la aplicación lo comprueba antes y se detiene con un error. pub(crate) fn load() -> T { - section_from(&CONFIG_VALUES) + let config = config_values() + .unwrap_or_else(|err| panic!("Failed to read the configuration files: {err}")); + section_from(config) .unwrap_or_else(|err| panic!("Invalid settings in section [{}]: {err}", T::SECTION)) } @@ -318,7 +346,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(section_from::(config_values()?)?); } Ok(()) } diff --git a/src/core/extension/all.rs b/src/core/extension/all.rs index a2f7b958..641fb097 100644 --- a/src/core/extension/all.rs +++ b/src/core/extension/all.rs @@ -12,6 +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")] + 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. #[error("Settings section [{0}] is already claimed by PageTop or another extension")] diff --git a/src/global.rs b/src/global.rs index a1f21d38..920c7992 100644 --- a/src/global.rs +++ b/src/global.rs @@ -1,5 +1,6 @@ //! Ajustes de configuración globales de PageTop. +use crate::core::extension::all::StartupError; use crate::{config, settings}; use std::sync::LazyLock; @@ -31,6 +32,23 @@ pub static SETTINGS: LazyLock = LazyLock::new(|| Settings { server: config::load(), }); +// Comprueba que los archivos de configuración se pueden 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()))?; + check_section::()?; + check_section::()?; + check_section::()?; + check_section::() +} + +fn check_section() -> Result<(), StartupError> { + config::check::().map_err(|err| StartupError::InvalidSettings { + section: T::SECTION, + source: err.into(), + }) +} + // **< Settings >*********************************************************************************** /// Ajustes globales de [`SETTINGS`].