diff --git a/Cargo.toml b/Cargo.toml index a45653e..7b4880e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -44,7 +44,6 @@ bytes = "1.12.1" serde = { version = "1.0.229", features = ["derive"] } serde_json = "1.0.154" url = { version = "2.5.8", features = ["serde"] } -ipnet = "2.12" percent-encoding = "2.3.2" schemars = { version = "1.2.3", features = ["jiff02"] } jiff = { version = "0.2.38", features = ["serde"] } diff --git a/src/main.rs b/src/main.rs index a9b7aac..f5eba06 100644 --- a/src/main.rs +++ b/src/main.rs @@ -11,6 +11,7 @@ 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::cli::{self, PeerCmd}; use skyg_linux_tracker::peers::registry::PeersReloader; use skyg_linux_tracker::peers::PeerRegistry; use skyg_linux_tracker::state::AppState; @@ -65,6 +66,11 @@ enum Command { #[command(subcommand)] cmd: TokenCmd, }, + /// Inspect configured peers (read-only). + Peer { + #[command(subcommand)] + cmd: PeerCmd, + }, } impl Cli { @@ -100,6 +106,7 @@ async fn main() -> Result<()> { match cli.command.unwrap_or(Command::Serve) { Command::Serve => serve(config, config_path, overrides).await, Command::Token { cmd } => tokens::run(cmd, &config).await, + Command::Peer { cmd } => cli::run(cmd, &config).await, } } diff --git a/src/peers/cli.rs b/src/peers/cli.rs new file mode 100644 index 0000000..7abfa8c --- /dev/null +++ b/src/peers/cli.rs @@ -0,0 +1,233 @@ +//! `slinuxm peer list|check`, the read-only diagnostic CLI. +//! +//! Both subcommands work from configuration and the external token files only; +//! they never touch the database, start loops or print a token value. + +use std::sync::Arc; +use std::time::Duration; + +use anyhow::{bail, Result}; +use clap::Subcommand; + +use crate::config::Config; +use crate::peers::health::check_once; +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. + configured_peer(&config.peers, &name)?; + let transport = real_transport()?; + print!( + "{}", + check_report(transport.as_ref(), &config.peers, &name).await? + ); + } + } + Ok(()) +} + +/// The real transport lands with the peer client workstream. Until then the +/// binary can list peers but cannot contact one. +fn real_transport() -> Result> { + bail!("peer check: transport not available (the peer client is not wired yet)") +} + +/// 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 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() { + let path = std::env::temp_dir().join(format!( + "slinuxm-peer-cli-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .subsec_nanos() + )); + std::fs::write(&path, SECRET).unwrap(); + let mut cfg = config(&["gamma", "beta"]); + cfg.peer[0].token_file = path.clone(); + cfg.peer[1].enabled = false; + let report = list_report(&cfg); + let _ = std::fs::remove_file(&path); + assert!(report.contains("NAME")); + assert!(report.contains("beta")); + assert!(report.contains("gamma")); + assert!(report.contains("http://beta:1984")); + assert!(report.contains(&path.display().to_string())); + assert!(report.find("beta").unwrap() < report.find("gamma").unwrap()); + assert!(report.contains("gamma"), "{report}"); + 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\""); + } +} diff --git a/src/peers/mod.rs b/src/peers/mod.rs index 1851c6e..5d52ea7 100644 --- a/src/peers/mod.rs +++ b/src/peers/mod.rs @@ -4,6 +4,7 @@ //! to the host. The registry read side is lock-light because REST, MCP and //! metrics render status on every scrape. +pub mod cli; pub mod config; pub mod error; pub mod health; diff --git a/tests/peers_config.rs b/tests/peers_config.rs index 7539faf..96e116e 100644 --- a/tests/peers_config.rs +++ b/tests/peers_config.rs @@ -16,7 +16,7 @@ use skyg_linux_tracker::peers::testing::{ fake_peers_config, fake_state_with_peers, registry_with, static_registry, FakeTransport, }; use skyg_linux_tracker::peers::types::{ApiStatus, AuthState, PeerName, PeerStatus, ServerStatus}; -use skyg_linux_tracker::peers::{PeerError, ProxyOpts}; +use skyg_linux_tracker::peers::{cli, PeerError, ProxyOpts}; use tower::ServiceExt; async fn get(app: &axum::Router, uri: &str) -> (StatusCode, String) { @@ -140,6 +140,106 @@ fn print_config_shows_peer_paths_and_not_token_contents() { assert!(!stdout.contains("SHOULD_NOT_LEAK")); } +#[test] +fn peer_list_prints_config_and_never_the_token() { + let dir = TempDir::new(); + let token = dir.path().join("peer.token"); + write_private_token(&token, SECRET); + let cfg = dir.path().join("config.toml"); + std::fs::write( + &cfg, + format!( + "\ + [peers]\n\ + enabled = true\n\ + \n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"http://127.0.0.1:1984\"\n\ + token_file = \"{}\"\n\ + ", + token.display() + ), + ) + .unwrap(); + + let out = slinuxm(&cfg, &["peer", "list"]); + let stdout = String::from_utf8(out.stdout).unwrap(); + let stderr = String::from_utf8(out.stderr).unwrap(); + assert!(out.status.success(), "peer list failed: {stderr}"); + assert!(stdout.contains("beta"), "{stdout}"); + assert!(stdout.contains("http://127.0.0.1:1984"), "{stdout}"); + assert!(stdout.contains(&token.display().to_string()), "{stdout}"); + assert!(!stdout.contains(SECRET), "{stdout}"); + assert!(!stderr.contains(SECRET), "{stderr}"); + + let empty = dir.path().join("empty.toml"); + std::fs::write(&empty, "").unwrap(); + let out = slinuxm(&empty, &["peer", "list"]); + let stdout = String::from_utf8(out.stdout).unwrap(); + assert!(out.status.success(), "{stdout}"); + assert_eq!(stdout, "no peers configured\n"); +} + +#[tokio::test] +async fn peer_check_reports_a_probe_through_the_fake_transport() { + let fake = FakeTransport::new(); + fake.peer("beta").tcp(Ok(Duration::from_millis(4))); + fake.peer("beta").respond( + "/api/v1/ping", + 200, + "application/json", + r#"{"status":"ok"}"#, + ); + let cfg = fake_peers_config(&["beta"]); + + let report = cli::check_report(fake.as_ref(), &cfg, "beta") + .await + .unwrap(); + assert!(report.contains("peer beta"), "{report}"); + assert!(report.contains("server up (4 ms)"), "{report}"); + assert!(report.contains("api up, auth ok"), "{report}"); + assert!(!report.contains(SECRET), "{report}"); +} + +#[test] +fn peer_check_binary_reports_the_missing_transport_without_the_token() { + let dir = TempDir::new(); + let token = dir.path().join("peer.token"); + write_private_token(&token, SECRET); + let cfg = dir.path().join("config.toml"); + std::fs::write( + &cfg, + format!( + "\ + [peers]\n\ + enabled = true\n\ + \n\ + [[peers.peer]]\n\ + name = \"beta\"\n\ + url = \"http://127.0.0.1:1984\"\n\ + token_file = \"{}\"\n\ + ", + token.display() + ), + ) + .unwrap(); + + let out = slinuxm(&cfg, &["peer", "check", "beta"]); + let stdout = String::from_utf8(out.stdout).unwrap(); + let stderr = String::from_utf8(out.stderr).unwrap(); + assert!(!out.status.success(), "no transport yet: {stdout}"); + assert!(stderr.contains("transport not available"), "{stderr}"); + assert!(!stdout.contains(SECRET), "{stdout}"); + assert!(!stderr.contains(SECRET), "{stderr}"); + + let out = slinuxm(&cfg, &["peer", "check", "nope"]); + let stderr = String::from_utf8(out.stderr).unwrap(); + assert!(!out.status.success()); + assert!(stderr.contains("unknown peer"), "{stderr}"); + assert!(!stderr.contains(SECRET), "{stderr}"); +} + #[tokio::test] async fn peerless_default_is_off_and_unchanged() { let config = Config::default();