B: B2/B3 health probes, loops and the in-memory status model

This commit is contained in:
ari committed 2026-10-19 20:55:25 -04:00
1 parent bd5b21bcc4
commit d94c2b3a1d
3 files changed
+994 -126

No files matched your search

+158 -5
View File
@@ -1,17 +1,28 @@
//! Peer client against a local HTTP listener.
//! Peer client against a local HTTP listener, then real health loops against
//! a second in-process `slinuxm` with fake sources.
//!
//! The listener is not a full `slinuxm`; it only has to speak enough HTTP/1.1
//! to prove the real transport. Later cases in this file drive a second
//! in-process server 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::peers::registry::ReqwestTransport;
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 {
@@ -131,3 +142,145 @@ async fn client_get_is_capped_and_does_not_follow_redirects() {
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);
}