//! `slinuxm peer list|check`, the read-only diagnostic CLI. //! //! Both subcommands work from configuration and (for `check`) the probed //! peer's token file only; they never touch the database, start loops or print //! a token value. `peer list` reads no token file at all. use std::sync::Arc; use std::time::Duration; use anyhow::{Context, Result}; use clap::Subcommand; use crate::config::Config; use crate::peers::config; use crate::peers::health::check_once; use crate::peers::registry::ReqwestTransport; use crate::peers::transport::PeerTransport; use crate::peers::types::{ApiStatus, AuthState, PeerConfig, PeersConfig, ServerStatus}; #[derive(Debug, Clone, Subcommand)] pub enum PeerCmd { /// List configured peers (config only; token files are not read). List, /// Probe one peer once over TCP and the authenticated API. Check { /// Configured peer name. name: String, }, } pub async fn run(cmd: PeerCmd, config: &Config) -> Result<()> { match cmd { PeerCmd::List => print!("{}", list_report(&config.peers)), PeerCmd::Check { name } => { // Resolve the name before the transport exists, so a typo reads // as an unknown peer rather than as a missing transport. let peer = configured_peer(&config.peers, &name)?; // Only this peer's credential is needed to probe it. config::validate_peer_token(peer).map_err(|err| anyhow::anyhow!("{err}"))?; let transport = real_transport(&config.peers)?; print!( "{}", check_report(transport.as_ref(), &config.peers, &name).await? ); } } Ok(()) } /// The real client, built with the configured limits and deny list. One /// process-wide instance is enough for a single probe. fn real_transport(cfg: &PeersConfig) -> Result> { let transport = ReqwestTransport::new(cfg).context("building the peer client")?; Ok(Arc::new(transport)) } /// One row per configured peer, sorted by name. Shows the path of the token /// file, never its contents. pub fn list_report(cfg: &PeersConfig) -> String { if cfg.peer.is_empty() { return "no peers configured\n".to_owned(); } let mut peers: Vec<&PeerConfig> = cfg.peer.iter().collect(); peers.sort_by(|a, b| a.name.cmp(&b.name)); let mut out = format!("{:<24} {:<8} {:<28} TOKEN FILE\n", "NAME", "ENABLED", "URL"); for peer in peers { out.push_str(&format!( "{:<24} {:<8} {:<28} {}\n", peer.name.as_str(), if peer.enabled { "yes" } else { "no" }, peer.display_url(), peer.token_file.display() )); } out } /// Probe one configured peer and render the result. The transport reads the /// token; nothing here can see or print it. pub async fn check_report( transport: &dyn PeerTransport, cfg: &PeersConfig, name: &str, ) -> Result { let peer = configured_peer(cfg, name)?; let (server, api) = check_once( transport, peer, Duration::from_secs(cfg.tcp_timeout_secs), Duration::from_secs(cfg.api_timeout_secs), ) .await; Ok(format!( "peer {}: {}\n {}\n {}\n", peer.name, peer.display_url(), describe_server(&server), describe_api(&api) )) } fn configured_peer<'a>(cfg: &'a PeersConfig, name: &str) -> Result<&'a PeerConfig> { cfg.peer .iter() .find(|p| p.name.as_str() == name) .ok_or_else(|| anyhow::anyhow!("unknown peer {name:?}")) } fn describe_server(status: &ServerStatus) -> String { if status.up { format!("server up ({})", latency(status.latency_ms)) } else { format!("server down ({})", class(status.last_error.as_deref())) } } fn describe_api(status: &ApiStatus) -> String { let auth = match status.auth { AuthState::Ok => "ok", AuthState::Rejected => "rejected", AuthState::Unknown => "unknown", }; if status.up { let latency = status .latency_ms .map(|ms| format!(", {ms} ms")) .unwrap_or_default(); format!("api up, auth {auth}{latency}") } else { format!( "api down ({}), auth {auth}", class(status.last_error.as_deref()) ) } } fn latency(ms: Option) -> String { ms.map(|ms| format!("{ms} ms")) .unwrap_or_else(|| "-".into()) } fn class(error: Option<&str>) -> &str { error.unwrap_or("unknown") } #[cfg(test)] mod tests { use std::path::PathBuf; use super::*; use crate::peers::error::PeerError; use crate::peers::testing::{fake_peers_config, FakeTransport}; const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK"; fn config(names: &[&str]) -> PeersConfig { fake_peers_config(names) } #[test] fn list_is_sorted_and_shows_paths_not_contents() { // `list_report` takes a config and never opens the file: a path that // does not exist must still render, and no content can appear. let missing = PathBuf::from("/run/credentials/skyg-linux-tracker.service/peer-gamma"); let mut cfg = config(&["gamma", "beta"]); cfg.peer[0].token_file = missing.clone(); cfg.peer[1].enabled = false; assert!(!missing.exists(), "fixture must not exist"); let report = list_report(&cfg); assert!(report.contains("NAME")); assert!(report.contains("http://beta:1984")); assert!(report.contains(&missing.display().to_string())); assert!(report.find("beta").unwrap() < report.find("gamma").unwrap()); assert!(report.contains(" no "), "disabled peer is marked: {report}"); assert!(!report.contains(SECRET)); } #[test] fn list_with_no_peers_says_so() { assert_eq!( list_report(&PeersConfig::default()), "no peers configured\n" ); } #[tokio::test] async fn check_reports_latency_and_auth() { let fake = FakeTransport::new(); let report = check_report(fake.as_ref(), &config(&["beta"]), "beta") .await .unwrap(); assert!(report.contains("peer beta: http://beta:1984")); assert!(report.contains("server up (1 ms)"), "{report}"); assert!(report.contains("api up, auth ok"), "{report}"); assert!(!report.contains(SECRET)); } #[tokio::test] async fn check_reports_rejected_credentials_as_api_up() { let fake = FakeTransport::new(); fake.peer("beta") .respond_err("/api/v1/ping", PeerError::Rejected); let report = check_report(fake.as_ref(), &config(&["beta"]), "beta") .await .unwrap(); assert!(report.contains("api up, auth rejected"), "{report}"); } #[tokio::test] async fn check_reports_down_classes_without_token() { let fake = FakeTransport::new(); fake.peer("beta").tcp(Err(PeerError::Timeout)); fake.peer("beta") .respond_err("/api/v1/ping", PeerError::Tls); let report = check_report(fake.as_ref(), &config(&["beta"]), "beta") .await .unwrap(); assert!(report.contains("server down (timeout)"), "{report}"); assert!(report.contains("api down (tls_error)"), "{report}"); assert!(report.contains("auth unknown"), "{report}"); assert!(!report.contains(SECRET)); } #[tokio::test] async fn unknown_peer_is_an_error_without_echoing_the_name_as_a_secret() { let fake = FakeTransport::new(); let err = check_report(fake.as_ref(), &config(&["beta"]), "nope") .await .unwrap_err(); assert_eq!(err.to_string(), "unknown peer \"nope\""); } }