//! 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>, } 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 { 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 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); }