diff --git a/src/main.rs b/src/main.rs index 308520e..a9b7aac 100644 --- a/src/main.rs +++ b/src/main.rs @@ -11,6 +11,8 @@ use tokio_util::sync::CancellationToken; use skyg_linux_tracker::auth::tokens::{self, TokenCmd}; use skyg_linux_tracker::config::{CliOverrides, Config}; +use skyg_linux_tracker::peers::registry::PeersReloader; +use skyg_linux_tracker::peers::PeerRegistry; use skyg_linux_tracker::state::AppState; use skyg_linux_tracker::{db, server, telemetry, tls}; @@ -93,8 +95,10 @@ async fn main() -> Result<()> { return Ok(()); } + let overrides = cli.overrides(); + let config_path = cli.config.clone(); match cli.command.unwrap_or(Command::Serve) { - Command::Serve => serve(config).await, + Command::Serve => serve(config, config_path, overrides).await, Command::Token { cmd } => tokens::run(cmd, &config).await, } } @@ -104,7 +108,11 @@ async fn main() -> Result<()> { const DRAIN_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10); const EXPORTER_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10); -async fn serve(config: Config) -> Result<()> { +async fn serve( + config: Config, + config_path: Option, + overrides: CliOverrides, +) -> Result<()> { // Install SIGHUP handling before anything else: the default action would // terminate the process, with or without TLS. let hup = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::hangup()) @@ -136,27 +144,29 @@ async fn serve(config: Config) -> Result<()> { .with_context(|| format!("binding {addr}"))?; let shutdown = CancellationToken::new(); - let state = AppState::live(config, db, shutdown.clone()); + let peers_config = config.peers.clone(); + let mut state = AppState::live(config, db, shutdown.clone()); + // A disabled peers section leaves `state.peers = None`: no routes, tools, + // tasks or metrics. + if peers_config.enabled { + state.peers = Some( + PeerRegistry::start(peers_config, shutdown.clone()) + .context("starting peer registry")?, + ); + } + let peers = state.peers.clone(); let exporters = telemetry::spawn_exporters(state.clone()); let pool = state.db.clone(); let app = server::build_router(state); - match &tls { - Some((_, cert)) => tls::spawn_sighup_reload(cert.clone(), hup, shutdown.clone()), - None => { - // Plain path: SIGHUP is ignored (logged only), nothing to reload. - let stop = shutdown.clone(); - let mut hup = hup; - tokio::spawn(async move { - loop { - tokio::select! { - _ = stop.cancelled() => break, - r = hup.recv() => if r.is_none() { break }, - } - tracing::info!("SIGHUP received; nothing to reload (TLS is disabled)"); - } - }); - } - } + let reloader = peers + .as_ref() + .map(|registry| PeersReloader::new(registry.clone(), config_path, overrides)); + tls::spawn_sighup_reload( + tls.as_ref().map(|(_, cert)| cert.clone()), + hup, + shutdown.clone(), + reloader, + ); let signal_token = shutdown.clone(); tokio::spawn(async move { @@ -192,6 +202,9 @@ async fn serve(config: Config) -> Result<()> { }; // Reached on signal or server error: stop everything, then flush OTel. shutdown.cancel(); + if let Some(peers) = &peers { + peers.shutdown().await; + } let join_all = async { for h in exporters { let _ = h.await; diff --git a/src/tls.rs b/src/tls.rs index e9ea12a..a9bd631 100644 --- a/src/tls.rs +++ b/src/tls.rs @@ -22,6 +22,7 @@ use tokio_rustls::TlsAcceptor; use tokio_util::sync::CancellationToken; use crate::config::TlsConfig; +use crate::peers::registry::PeersReloader; /// Hot-swappable server certificate. #[derive(Debug)] @@ -101,10 +102,14 @@ pub fn acceptor(cert: Arc) -> Result { /// Reload on every SIGHUP until `shutdown`. Failures are logged, never fatal. /// `hup` is installed by the caller before binding so no SIGHUP can kill the /// process in the meantime. +/// +/// `cert` is `None` when TLS is disabled; `peers` is `None` when the peers +/// feature is off. The same signal reloads both, with independent failures. pub fn spawn_sighup_reload( - cert: Arc, + cert: Option>, mut hup: tokio::signal::unix::Signal, shutdown: CancellationToken, + peers: Option, ) { tokio::spawn(async move { loop { @@ -112,12 +117,24 @@ pub fn spawn_sighup_reload( _ = shutdown.cancelled() => break, r = hup.recv() => if r.is_none() { break }, } - match cert.reload() { - Ok(()) => tracing::info!("TLS certificate reloaded"), - Err(e) => tracing::error!( - error = %format!("{e:#}"), - "TLS reload failed; keeping previous certificate" - ), + match &cert { + Some(cert) => match cert.reload() { + Ok(()) => tracing::info!("TLS certificate reloaded"), + Err(e) => tracing::error!( + error = %format!("{e:#}"), + "TLS reload failed; keeping previous certificate" + ), + }, + None => tracing::info!("SIGHUP received; TLS is disabled"), + } + if let Some(peers) = &peers { + match peers.reload().await { + Ok(()) => tracing::info!("peer configuration reloaded"), + Err(e) => tracing::error!( + error = %e, + "peer reload failed; keeping previous peers" + ), + } } } });