A: A4 peer list and one-shot peer check CLI
This commit is contained in:
1 parent
7d10153677
commit
2eb1d2a78b
5 files changed
+342
-2
No files matched your search
@@ -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\"");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user