A: A4 peer list and one-shot peer check CLI

This commit is contained in:
ari committed 2026-10-19 22:31:29 -04:00
1 parent 7d10153677
commit 2eb1d2a78b
5 files changed
+342 -2

No files matched your search

-1
View File
@@ -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"] }
+7
View File
@@ -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,
}
}
+233
View File
@@ -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<Arc<dyn PeerTransport>> {
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<String> {
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<u64>) -> 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\"");
}
}
+1
View File
@@ -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;
+101 -1
View File
@@ -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();