B: B2/B3 health probes, loops and the in-memory status model
This commit is contained in:
1 parent
bd5b21bcc4
commit
d94c2b3a1d
3 files changed
+994
-126
No files matched your search
+158
-5
@@ -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(®, |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);
|
||||
}
|
||||
Reference in new issue
Block a user