Files
skyg-linux-tracker/tests/peers_config.rs
T

494 lines
16 KiB
Rust

//! Peer seams exercised end to end against the fake transport and fake
//! sources: the peer-less default, the ping route, and registry reads.
use std::net::{IpAddr, Ipv4Addr};
use std::os::unix::fs::PermissionsExt;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::Duration;
use axum::body::{to_bytes, Body};
use axum::http::{Request, StatusCode};
use figment::Jail;
use skyg_linux_tracker::api;
use skyg_linux_tracker::config::{CliOverrides, Config};
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 tower::ServiceExt;
async fn get(app: &axum::Router, uri: &str) -> (StatusCode, String) {
let resp = app
.clone()
.oneshot(Request::get(uri).body(Body::empty()).unwrap())
.await
.unwrap();
let status = resp.status();
let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
(status, String::from_utf8(body.to_vec()).unwrap())
}
fn status(name: &str, up: bool) -> PeerStatus {
PeerStatus {
name: PeerName::parse(name).unwrap(),
enabled: true,
url: format!("http://{name}:1984"),
server: ServerStatus {
up,
..ServerStatus::default()
},
api: ApiStatus::default(),
}
}
const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK";
struct TempDir(PathBuf);
impl TempDir {
fn new() -> Self {
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.subsec_nanos();
let dir =
std::env::temp_dir().join(format!("slinuxm-peers-{}-{nanos}", std::process::id()));
std::fs::create_dir(&dir).unwrap();
Self(dir)
}
fn path(&self) -> &Path {
&self.0
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
fn write_private_token(path: &Path, contents: &str) {
std::fs::write(path, contents).unwrap();
std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600)).unwrap();
}
fn slinuxm(config: &Path, args: &[&str]) -> std::process::Output {
Command::new(env!("CARGO_BIN_EXE_slinuxm"))
.arg("--config")
.arg(config)
.args(args)
.env_clear()
.env("PATH", std::env::var_os("PATH").unwrap_or_default())
.output()
.expect("run slinuxm")
}
#[test]
fn print_config_shows_peer_paths_and_not_token_contents() {
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\
tcp_interval_secs = 20\n\
tcp_timeout_secs = 4\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, &["--print-config"]);
let stdout = String::from_utf8(out.stdout).unwrap();
let stderr = String::from_utf8(out.stderr).unwrap();
assert!(
out.status.success(),
"print-config failed: {stderr}\n{stdout}"
);
assert!(stdout.contains("[peers]"));
assert!(stdout.contains("enabled = true"));
assert!(stdout.contains(&token.display().to_string()));
assert!(!stdout.contains("SHOULD_NOT_LEAK"), "{stdout}");
assert!(!stderr.contains("SHOULD_NOT_LEAK"), "{stderr}");
let bare = dir.path().join("empty.toml");
std::fs::write(&bare, "").unwrap();
let out = slinuxm(&bare, &["--print-config"]);
let stdout = String::from_utf8(out.stdout).unwrap();
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
assert!(stdout.contains("[peers]\n"));
assert!(stdout.contains("enabled = false\n"));
assert!(stdout.contains("port = 1984\n"));
assert!(stdout.contains("peer = []\n"));
assert!(!stdout.contains("SHOULD_NOT_LEAK"));
}
#[tokio::test]
async fn peerless_default_is_off_and_unchanged() {
let config = Config::default();
assert!(!config.peers.enabled);
assert!(config.peers.peer.is_empty());
let state = skyg_linux_tracker::sources::fake::fake_state(config);
assert!(state.peers.is_none());
let (s, b) = get(&api::router(state), "/systemd/units").await;
assert_eq!(s, StatusCode::OK);
assert!(!b.is_empty());
}
#[test]
#[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error
fn vm_peer_entries_load_when_enabled_and_ca_file_are_omitted() {
Jail::expect_with(|jail| {
let beta_token = jail.directory().join("peer-beta");
let gamma_token = jail.directory().join("peer-gamma");
let delta_token = jail.directory().join("peer-delta");
for path in [&beta_token, &gamma_token, &delta_token] {
write_private_token(path, "pending\n");
}
jail.create_file(
"peers.toml",
&format!(
r#"
[server]
bind = "0.0.0.0"
[peers]
enabled = true
tcp_interval_secs = 2
tcp_timeout_secs = 1
api_interval_secs = 3
api_timeout_secs = 2
fail_threshold = 2
request_timeout_secs = 4
[[peers.peer]]
name = "beta"
url = "http://beta:1984"
token_file = "{beta}"
allow_plain_http = true
[[peers.peer]]
name = "gamma"
url = "https://gamma:1984"
token_file = "{gamma}"
ca_file = "/etc/ssl/private-ca.pem"
allow_plain_http = false
[[peers.peer]]
name = "delta"
url = "https://delta:1984"
token_file = "{delta}"
enabled = false
"#,
beta = beta_token.display(),
gamma = gamma_token.display(),
delta = delta_token.display(),
),
)?;
let cfg = Config::load(Some(Path::new("peers.toml")), &CliOverrides::default())
.expect("peer entries must deserialize");
assert!(cfg.auth.enabled);
assert_eq!(cfg.server.bind, IpAddr::V4(Ipv4Addr::UNSPECIFIED));
assert!(cfg.peers.enabled);
assert_eq!(cfg.peers.tcp_interval_secs, 2);
assert_eq!(cfg.peers.api_timeout_secs, 2);
assert_eq!(cfg.peers.request_timeout_secs, 4);
assert_eq!(cfg.peers.max_response_bytes, 8 * 1024 * 1024);
let peer = |name: &str| {
cfg.peers
.peer
.iter()
.find(|p| p.name.as_str() == name)
.unwrap()
};
let beta = peer("beta");
assert!(beta.enabled);
assert!(beta.allow_plain_http);
assert!(beta.ca_file.is_none());
assert_eq!(beta.token_file, beta_token);
let gamma = peer("gamma");
assert!(gamma.enabled);
assert!(!gamma.allow_plain_http);
assert_eq!(
gamma.ca_file.as_deref(),
Some(Path::new("/etc/ssl/private-ca.pem"))
);
let delta = peer("delta");
assert!(!delta.enabled);
assert!(!delta.allow_plain_http);
assert!(delta.ca_file.is_none());
Ok(())
});
}
#[test]
#[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error
fn load_rejects_invalid_peers_and_accepts_a_placeholder_token() {
Jail::expect_with(|jail| {
jail.create_file("empty-peers.toml", "[peers]\nenabled = true\n")?;
Config::load(
Some(Path::new("empty-peers.toml")),
&CliOverrides::default(),
)
.expect("enabled with zero peers is a warning, not an error");
jail.create_file(
"bad-name.toml",
"\
[peers]\n\
[[peers.peer]]\n\
name = \"Beta\"\n\
url = \"https://beta:1984\"\n\
token_file = \"/run/peers/beta\"\n\
",
)?;
let err = Config::load(Some(Path::new("bad-name.toml")), &CliOverrides::default())
.expect_err("peer name regex");
let text = err.to_string();
assert!(
text.contains("must match") || text.contains("Beta"),
"{text}"
);
jail.create_file(
"timeout.toml",
"[peers]\ntcp_interval_secs = 10\ntcp_timeout_secs = 10\n",
)?;
let err = Config::load(Some(Path::new("timeout.toml")), &CliOverrides::default())
.expect_err("timeout below interval");
assert!(err.to_string().contains("tcp_timeout_secs"), "{err}");
jail.create_file(
"userinfo.toml",
"\
[peers]\n\
[[peers.peer]]\n\
name = \"beta\"\n\
url = \"http://user:s3cret@127.0.0.1:1984\"\n\
token_file = \"/run/peers/beta\"\n\
",
)?;
let err = Config::load(Some(Path::new("userinfo.toml")), &CliOverrides::default())
.expect_err("userinfo");
let text = err.to_string();
assert!(text.contains("userinfo"), "{text}");
assert!(!text.contains("s3cret"), "{text}");
let missing = jail.directory().join("not-there");
jail.create_file(
"missing.toml",
&format!(
"\
[peers]\n\
enabled = true\n\
[[peers.peer]]\n\
name = \"beta\"\n\
url = \"https://beta:1984\"\n\
token_file = \"{}\"\n\
",
missing.display()
),
)?;
let err = Config::load(Some(Path::new("missing.toml")), &CliOverrides::default())
.expect_err("missing token file");
let text = err.to_string();
assert!(text.contains("peer beta"), "{text}");
assert!(text.contains("not readable"), "{text}");
let placeholder = jail.directory().join("placeholder");
write_private_token(&placeholder, "pending\n");
jail.create_file(
"ok.toml",
&format!(
"\
[peers]\n\
enabled = true\n\
tcp_interval_secs = 2\n\
tcp_timeout_secs = 1\n\
api_interval_secs = 3\n\
api_timeout_secs = 2\n\
[[peers.peer]]\n\
name = \"beta\"\n\
url = \"http://127.0.0.1:1984\"\n\
token_file = \"{}\"\n\
",
placeholder.display()
),
)?;
let cfg = Config::load(Some(Path::new("ok.toml")), &CliOverrides::default())
.expect("placeholder token file must load");
assert_eq!(cfg.peers.peer[0].name.as_str(), "beta");
assert!(!format!("{cfg:?}").contains("pending"));
Ok(())
});
}
#[tokio::test]
async fn ping_without_a_token_is_unauthorized() {
let pool = sqlx::sqlite::SqlitePoolOptions::new()
.max_connections(1)
.connect("sqlite::memory:")
.await
.unwrap();
skyg_linux_tracker::db::migrate(&pool).await.unwrap();
let token = skyg_linux_tracker::auth::tokens::create(&pool, "ping")
.await
.unwrap();
let mut config = Config::default();
config.auth.enabled = true;
let mut state = skyg_linux_tracker::sources::fake::fake_state(config);
state.db = Some(pool);
let app = skyg_linux_tracker::server::build_router(state);
let (status, body, www) = request(&app, "/api/v1/ping", None).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(www.as_deref(), Some("Bearer"));
assert!(body.contains("unauthorized"));
let (status, body, _) = request(&app, "/api/v1/ping", Some(&format!("Bearer {token}"))).await;
assert_eq!(status, StatusCode::OK);
let v: serde_json::Value = serde_json::from_str(&body).unwrap();
assert_eq!(v["status"], "ok");
assert!(v["version"].as_str().is_some_and(|s| !s.is_empty()));
}
async fn request(
app: &axum::Router,
uri: &str,
authorization: Option<&str>,
) -> (StatusCode, String, Option<String>) {
let mut builder = Request::builder().uri(uri);
if let Some(auth) = authorization {
builder = builder.header("authorization", auth);
}
let resp = app
.clone()
.oneshot(builder.body(Body::empty()).unwrap())
.await
.unwrap();
let status = resp.status();
let www = resp
.headers()
.get(axum::http::header::WWW_AUTHENTICATE)
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
(status, String::from_utf8(body.to_vec()).unwrap(), www)
}
#[tokio::test]
async fn fake_state_carries_the_registry() {
let fake = FakeTransport::new();
let reg = registry_with(fake, fake_peers_config(&["beta", "gamma"]));
let state = fake_state_with_peers(Config::default(), reg);
let peers = state.peers.as_ref().expect("registry present");
let names: Vec<_> = peers
.snapshot()
.into_iter()
.map(|p| p.name.as_str().to_owned())
.collect();
assert_eq!(names, ["beta", "gamma"]);
assert_eq!(peers.status("beta").unwrap().api.auth, AuthState::Unknown);
}
#[tokio::test]
async fn registry_proxies_through_the_fake_and_records_the_request() {
let fake = FakeTransport::new();
fake.peer("beta")
.respond("/systemd/units", 200, "application/json", r#"{"units":[]}"#);
let reg = registry_with(fake.clone(), fake_peers_config(&["beta"]));
let resp = reg
.get(
"beta",
"/systemd/units",
&[("state".into(), "failed".into())],
ProxyOpts::default(),
)
.await
.unwrap();
assert_eq!(resp.status, 200);
let calls = fake.calls();
assert_eq!(calls.len(), 1);
assert_eq!(
calls[0].1.query,
vec![("state".to_owned(), "failed".to_owned())]
);
assert!(calls[0]
.1
.headers
.iter()
.any(|(k, v)| k.as_str() == "x-slinuxm-hop" && v == "1"));
assert!(!calls[0]
.1
.headers
.iter()
.any(|(k, _)| k.as_str() == "authorization"));
}
#[tokio::test]
async fn unknown_peer_and_peer_failures_use_the_shared_mapping() {
let fake = FakeTransport::new();
fake.peer("beta")
.respond_err("/systemd/units", PeerError::Rejected);
let reg = registry_with(fake, fake_peers_config(&["beta"]));
let err = reg
.get("nope", "/systemd/units", &[], ProxyOpts::default())
.await
.unwrap_err();
assert_eq!(err.code(), "not_found");
assert_eq!(err.message(), "peer nope: unknown peer");
let err = reg
.get("beta", "/systemd/units", &[], ProxyOpts::default())
.await
.unwrap_err();
assert_eq!(err.code(), "unavailable");
assert_eq!(err.status(), StatusCode::SERVICE_UNAVAILABLE);
assert!(err.message().contains("beta"));
assert_eq!(err.message(), "peer beta: peer rejected credentials");
}
#[tokio::test]
async fn static_registry_is_sorted_and_serves_rendering() {
let reg = static_registry(vec![status("gamma", false), status("beta", true)]);
let snap = reg.snapshot();
assert_eq!(snap[0].name.as_str(), "beta");
assert_eq!(snap[1].name.as_str(), "gamma");
assert!(reg.status("beta").unwrap().server.up);
assert_eq!(reg.status("nope").unwrap_err().code(), "not_found");
// Static snapshots do not script the transport; unscripted GETs still use
// the fake defaults, so a proxy call is bounded and never touches a socket.
let resp = tokio::time::timeout(
Duration::from_secs(1),
reg.get("beta", "/systemd/units", &[], ProxyOpts::default()),
)
.await
.expect("fake transport must not block")
.unwrap();
assert_eq!(resp.status, 404);
}