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

287 lines
9.7 KiB
Rust

//! Peer client against a local HTTP listener, then real health loops against
//! a second in-process `slinuxm` with fake sources.
//!
//! The first cases use a hand-written listener: it only has to speak enough
//! HTTP/1.1 to prove the transport. The later cases run the assembled router
//! so the `PeerTransport`, probing and registry state are exercised together.
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
use skyg_linux_tracker::auth::tokens;
use skyg_linux_tracker::config::Config;
use skyg_linux_tracker::peers::registry::{PeerRegistry, ReqwestTransport};
use skyg_linux_tracker::peers::transport::{PeerBody, PeerRequest, PeerTransport};
use skyg_linux_tracker::peers::types::AuthState;
use skyg_linux_tracker::peers::types::PeerStatus;
use skyg_linux_tracker::peers::types::{PeerConfig, PeerName, PeersConfig};
use skyg_linux_tracker::peers::PeerError;
use skyg_linux_tracker::server;
use skyg_linux_tracker::sources::fake::fake_state;
use sqlx::sqlite::SqlitePoolOptions;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
use tokio_util::sync::CancellationToken;
fn transport() -> ReqwestTransport {
ReqwestTransport::new(&PeersConfig {
enabled: true,
max_response_bytes: 64,
..PeersConfig::default()
})
.unwrap()
}
fn peer(port: u16, token: &std::path::Path) -> PeerConfig {
PeerConfig {
name: PeerName::parse("beta").unwrap(),
url: url::Url::parse(&format!("http://127.0.0.1:{port}")).unwrap(),
token_file: token.to_path_buf(),
ca_file: None,
allow_plain_http: false,
enabled: true,
}
}
fn token_file(contents: &str) -> std::path::PathBuf {
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
let path = std::env::temp_dir().join(format!(
"slinuxm-peers-reg-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&path)
.unwrap()
.write_all(contents.as_bytes())
.unwrap();
path
}
fn ping() -> PeerRequest {
PeerRequest {
path: "/api/v1/ping".into(),
query: vec![],
headers: vec![],
accept: None,
}
}
async fn read_head(sock: &mut tokio::net::TcpStream) -> String {
let mut buf = Vec::new();
let mut tmp = [0u8; 512];
while !buf.windows(4).any(|w| w == b"\r\n\r\n") {
let n = tokio::time::timeout(Duration::from_secs(2), sock.read(&mut tmp))
.await
.unwrap()
.unwrap();
if n == 0 {
break;
}
buf.extend_from_slice(&tmp[..n]);
}
String::from_utf8_lossy(&buf).into_owned()
}
#[tokio::test]
async fn client_get_is_capped_and_does_not_follow_redirects() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let token = token_file("fixture-token\n");
tokio::spawn(async move {
let (mut sock, _) = listener.accept().await.unwrap();
let head = read_head(&mut sock).await;
assert!(head.starts_with("GET /api/v1/ping HTTP/1.1"));
assert!(head
.to_ascii_lowercase()
.contains("authorization: bearer fixture-token"));
let body = "0123456789abcdef";
let resp = format!(
"HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:1/nope\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = sock.write_all(resp.as_bytes()).await;
});
let resp = transport()
.get(&peer(port, &token), ping(), Duration::from_secs(2))
.await
.unwrap();
assert_eq!(resp.status, 302);
match resp.body {
PeerBody::Bytes(b) => assert_eq!(&b[..], b"0123456789abcdef"),
PeerBody::Stream(_) => panic!("expected a buffered body"),
}
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
let (mut sock, _) = listener.accept().await.unwrap();
let _ = read_head(&mut sock).await;
let mut resp =
b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n".to_vec();
let chunk = vec![b'z'; 200];
resp.extend(format!("{:x}\r\n", chunk.len()).into_bytes());
resp.extend_from_slice(&chunk);
resp.extend(b"\r\n0\r\n\r\n");
let _ = sock.write_all(&resp).await;
});
let err = transport()
.get(&peer(port, &token), ping(), Duration::from_secs(2))
.await
.unwrap_err();
assert!(matches!(err, PeerError::Oversize), "{err:?}");
let _ = std::fs::remove_file(&token);
}
/// A second in-process `slinuxm` (fake sources) acting as the peer.
struct RunningPeer {
port: u16,
shutdown: CancellationToken,
join: tokio::task::JoinHandle<anyhow::Result<()>>,
}
impl RunningPeer {
async fn stop(self) {
self.shutdown.cancel();
let _ = self.join.await;
}
}
async fn start_peer_at(port: u16, auth: bool) -> RunningPeer {
let listener = TcpListener::bind(("127.0.0.1", port)).await.unwrap();
let port = listener.local_addr().unwrap().port();
let mut config = Config::default();
config.server.port = port;
config.auth.enabled = auth;
let mut state = fake_state(config);
if auth {
let pool = SqlitePoolOptions::new()
.max_connections(1)
.connect("sqlite::memory:")
.await
.unwrap();
skyg_linux_tracker::db::migrate(&pool).await.unwrap();
let _ = tokens::create(&pool, "peer-consumer").await.unwrap();
state.db = Some(pool);
}
let shutdown = state.shutdown.clone();
let app = server::build_router(state);
let join = tokio::spawn(server::serve_listener(
listener,
None,
app,
shutdown.clone(),
server::Limits::default(),
));
RunningPeer {
port,
shutdown,
join,
}
}
fn registry_for(port: u16, token_path: &Path, shutdown: CancellationToken) -> Arc<PeerRegistry> {
let mut cfg = skyg_linux_tracker::peers::testing::fake_peers_config(&["beta"]);
cfg.peer[0].url = url::Url::parse(&format!("http://127.0.0.1:{port}")).unwrap();
cfg.peer[0].token_file = token_path.to_path_buf();
PeerRegistry::start(cfg, shutdown).unwrap()
}
async fn wait_for<F: Fn(&PeerStatus) -> bool>(reg: &PeerRegistry, f: F) -> PeerStatus {
let deadline = tokio::time::Instant::now() + Duration::from_secs(8);
loop {
let status = reg.status("beta").unwrap();
if f(&status) {
return status;
}
assert!(
tokio::time::Instant::now() < deadline,
"peer status stayed {:?}",
status
);
tokio::time::sleep(Duration::from_millis(25)).await;
}
}
#[tokio::test]
async fn loops_observe_up_down_and_recovery() {
let token = token_file("anything\n");
let peer = start_peer_at(0, false).await;
let port = peer.port;
let shutdown = CancellationToken::new();
let reg = registry_for(port, &token, shutdown.clone());
let up = wait_for(&reg, |s| s.server.up && s.api.up).await;
assert_eq!(up.api.auth, AuthState::Ok);
let since_up = up.server.since.expect("first check records since");
// Port closed: both checks fail within their own timeout.
peer.stop().await;
let down = wait_for(&reg, |s| !s.server.up && !s.api.up).await;
assert!(down.server.last_error.is_some());
assert_eq!(down.api.auth, AuthState::Unknown);
let since_down = down.server.since.expect("flip records since");
assert_ne!(since_down, since_up);
// Same port again: recovery is immediate, not threshold-bound.
let peer = start_peer_at(port, false).await;
let back = wait_for(&reg, |s| s.server.up && s.api.up).await;
assert_ne!(back.server.since, Some(since_down));
reg.shutdown().await;
peer.stop().await;
let _ = std::fs::remove_file(&token);
}
#[tokio::test]
async fn api_down_with_the_listener_still_accepting() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let hang = tokio::spawn(async move {
let mut held = Vec::new();
while let Ok((sock, _)) = listener.accept().await {
held.push(sock);
if held.len() > 8 {
held.remove(0);
}
}
});
let token = token_file("anything\n");
let shutdown = CancellationToken::new();
let reg = registry_for(port, &token, shutdown.clone());
let status = wait_for(&reg, |s| s.api.last_checked.is_some() && !s.api.up).await;
assert!(status.server.up, "TCP connect succeeds");
assert!(!status.api.up, "no HTTP answer before the timeout");
assert_eq!(status.api.last_error.as_deref(), Some("timeout"));
reg.shutdown().await;
hang.abort();
let _ = std::fs::remove_file(&token);
}
#[tokio::test]
async fn a_rejected_token_leaves_the_api_up_and_names_the_auth_state() {
let peer = start_peer_at(0, true).await;
let token = token_file("not-the-peer-token\n");
let shutdown = CancellationToken::new();
let reg = registry_for(peer.port, &token, shutdown.clone());
let status = wait_for(&reg, |s| s.api.last_checked.is_some()).await;
assert!(status.server.up);
assert!(status.api.up, "a 401 proves the API is running");
assert_eq!(status.api.auth, AuthState::Rejected);
assert_eq!(status.api.last_error.as_deref(), Some("unauthorized"));
reg.shutdown().await;
peer.stop().await;
let _ = std::fs::remove_file(&token);
}