332 lines
11 KiB
Rust
332 lines
11 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
|
|
}
|
|
|
|
/// Overwrite a token file in place, as a credential rotation does.
|
|
fn replace_token(path: &Path, contents: &str) {
|
|
use std::io::Write;
|
|
use std::os::unix::fs::OpenOptionsExt;
|
|
std::fs::OpenOptions::new()
|
|
.write(true)
|
|
.create(true)
|
|
.truncate(true)
|
|
.mode(0o600)
|
|
.open(path)
|
|
.unwrap()
|
|
.write_all(contents.as_bytes())
|
|
.unwrap();
|
|
}
|
|
|
|
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,
|
|
/// The token this peer accepts, when auth is on.
|
|
token: Option<String>,
|
|
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);
|
|
let mut token = None;
|
|
if auth {
|
|
let pool = SqlitePoolOptions::new()
|
|
.max_connections(1)
|
|
.connect("sqlite::memory:")
|
|
.await
|
|
.unwrap();
|
|
skyg_linux_tracker::db::migrate(&pool).await.unwrap();
|
|
token = Some(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,
|
|
token,
|
|
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(®, |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(®, |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(®, |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(®, |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(®, |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);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_rotated_token_recovers_without_a_restart() {
|
|
let peer = start_peer_at(0, true).await;
|
|
let valid = peer.token.clone().expect("auth peer has a token");
|
|
let token = token_file("stale-token\n");
|
|
let shutdown = CancellationToken::new();
|
|
let reg = registry_for(peer.port, &token, shutdown.clone());
|
|
|
|
let rejected = wait_for(®, |s| {
|
|
s.api.last_checked.is_some() && s.api.auth == AuthState::Rejected
|
|
})
|
|
.await;
|
|
assert!(rejected.api.up, "a 401 proves the API is running");
|
|
|
|
// Rotation: the transport re-reads the file on every check, so no
|
|
// restart or SIGHUP is needed.
|
|
replace_token(&token, &format!("{valid}\n"));
|
|
let recovered = wait_for(®, |s| s.api.auth == AuthState::Ok).await;
|
|
assert!(recovered.api.up);
|
|
assert_eq!(recovered.api.last_error, None);
|
|
|
|
reg.shutdown().await;
|
|
peer.stop().await;
|
|
let _ = std::fs::remove_file(&token);
|
|
}
|