From 0a83386de53668078971f6427fbea8c47f87ef40 Mon Sep 17 00:00:00 2001 From: ari Date: Tue, 20 Oct 2026 11:08:23 -0400 Subject: [PATCH] F: one in-process server helper and the shared test TempDir Peer::spawn and Consolidator::start repeated the bind, pool, migrate, mint and serve_listener sequence; serve(config, tls, prepare) does it once and returns the handle, the token and whatever the caller prepared, so the registry is installed before the router is built. The local TempDir copy is gone in favour of peers::testing::TempDir, which already does unique scratch dirs and mode-controlled writes. --- tests/peers.rs | 277 +++++++++++++++++++++++-------------------------- 1 file changed, 130 insertions(+), 147 deletions(-) diff --git a/tests/peers.rs b/tests/peers.rs index 193e69a..2dc2118 100644 --- a/tests/peers.rs +++ b/tests/peers.rs @@ -10,6 +10,7 @@ use std::time::Duration; use skyg_linux_tracker::auth::tokens; use skyg_linux_tracker::config::Config; use skyg_linux_tracker::peers::registry::PeerRegistry; +use skyg_linux_tracker::peers::testing::TempDir; use skyg_linux_tracker::peers::types::{AuthState, PeerConfig, PeerName, PeerStatus, PeersConfig}; use skyg_linux_tracker::server; use skyg_linux_tracker::sources::fake::fake_state; @@ -27,50 +28,6 @@ const EXCHANGE: Duration = Duration::from_secs(20); /// Deadline for a peer to flip its status. const FLIP: Duration = Duration::from_secs(10); -struct TempDir(PathBuf); - -impl TempDir { - fn new(tag: &str) -> Self { - static N: AtomicUsize = AtomicUsize::new(0); - let p = std::env::temp_dir().join(format!( - "slinuxm-peers-e2e-{tag}-{}-{}", - std::process::id(), - N.fetch_add(1, Ordering::SeqCst) - )); - std::fs::create_dir_all(&p).unwrap(); - Self(p) - } - - /// A token file as a credential manager leaves it: private to this user. - fn token(&self, name: &str, contents: &str) -> PathBuf { - use std::io::Write; - use std::os::unix::fs::OpenOptionsExt; - let path = self.0.join(name); - std::fs::OpenOptions::new() - .write(true) - .create(true) - .truncate(true) - .mode(0o600) - .open(&path) - .unwrap() - .write_all(contents.as_bytes()) - .unwrap(); - path - } - - fn file(&self, name: &str, contents: &str) -> PathBuf { - let path = self.0.join(name); - std::fs::write(&path, contents).unwrap(); - path - } -} - -impl Drop for TempDir { - fn drop(&mut self) { - let _ = std::fs::remove_dir_all(&self.0); - } -} - /// One request over a fresh connection, read to EOF. async fn send(port: u16, raw: &str) -> (u16, String, String) { let mut sock = tokio::net::TcpStream::connect(("127.0.0.1", port)) @@ -94,15 +51,78 @@ fn get_raw(path: &str, token: &str, accept: Option<&str>) -> String { common::request("GET", path, "localhost", &headers, None) } -/// A second `slinuxm` acting as the peer: real router, fake sources. -struct Peer { +/// One in-process `slinuxm`: real router and listener over fake sources, auth +/// on, and one minted token. `prepare` runs before the router is built, so a +/// caller can install its peer registry, and its value is returned. +struct Served { port: u16, - /// The token this peer accepts. token: String, shutdown: CancellationToken, join: JoinHandle>, } +impl Served { + async fn stop(self) { + self.shutdown.cancel(); + let _ = self.join.await; + } +} + +async fn serve( + mut config: Config, + tls_pair: Option<(&Path, &Path)>, + prepare: F, +) -> (Served, T) +where + F: FnOnce(&mut skyg_linux_tracker::state::AppState) -> T, +{ + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let port = listener.local_addr().unwrap().port(); + config.server.port = port; + config.auth.enabled = true; + if let Some((cert, key)) = tls_pair { + config.server.tls.enabled = true; + config.server.tls.cert_file = cert.to_path_buf(); + config.server.tls.key_file = key.to_path_buf(); + } + let mut state = fake_state(config); + let pool = SqlitePoolOptions::new() + .max_connections(1) + .connect("sqlite::memory:") + .await + .unwrap(); + skyg_linux_tracker::db::migrate(&pool).await.unwrap(); + let token = tokens::create(&pool, "test").await.unwrap(); + state.db = Some(pool); + let prepared = prepare(&mut state); + let acceptor = tls_pair.map(|_| { + let cert = tls::ReloadableCert::load(&state.config.server.tls).unwrap(); + tls::acceptor(cert).unwrap() + }); + let shutdown = state.shutdown.clone(); + let join = tokio::spawn(server::serve_listener( + listener, + acceptor, + server::build_router(state), + shutdown.clone(), + server::Limits::default(), + )); + ( + Served { + port, + token, + shutdown, + join, + }, + prepared, + ) +} + +/// A second `slinuxm` acting as the peer: real router, fake sources. +struct Peer { + served: Served, +} + impl Peer { async fn start() -> Self { Self::spawn(None).await @@ -112,109 +132,69 @@ impl Peer { Self::spawn(Some((cert, key))).await } - async fn spawn(pair: Option<(&Path, &Path)>) -> Self { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let port = listener.local_addr().unwrap().port(); - let mut config = Config::default(); - config.server.port = port; - config.auth.enabled = true; - if let Some((cert, key)) = pair { - config.server.tls.enabled = true; - config.server.tls.cert_file = cert.to_path_buf(); - config.server.tls.key_file = key.to_path_buf(); - } - let mut state = fake_state(config); - let pool = SqlitePoolOptions::new() - .max_connections(1) - .connect("sqlite::memory:") - .await - .unwrap(); - skyg_linux_tracker::db::migrate(&pool).await.unwrap(); - let token = tokens::create(&pool, "consolidator").await.unwrap(); - state.db = Some(pool); - let acceptor = pair.map(|_| { - let cert = tls::ReloadableCert::load(&state.config.server.tls).unwrap(); - tls::acceptor(cert).unwrap() - }); - let shutdown = state.shutdown.clone(); - let join = tokio::spawn(server::serve_listener( - listener, - acceptor, - server::build_router(state), - shutdown.clone(), - server::Limits::default(), - )); - Self { - port, - token, - shutdown, - join, - } + async fn spawn(tls_pair: Option<(&Path, &Path)>) -> Self { + let (served, ()) = serve(Config::default(), tls_pair, |_| ()).await; + Self { served } } fn url(&self, scheme: &str) -> String { - format!("{scheme}://127.0.0.1:{}", self.port) + format!("{scheme}://127.0.0.1:{}", self.served.port) + } + + fn port(&self) -> u16 { + self.served.port + } + + fn token(&self) -> &str { + &self.served.token } fn token_file(&self, dir: &TempDir) -> PathBuf { - dir.token("peer-token", &format!("{}\n", self.token)) + dir.write( + "peer-token", + format!("{}\n", self.served.token).as_bytes(), + 0o600, + ) } async fn stop(self) { - self.shutdown.cancel(); - let _ = self.join.await; + self.served.stop().await; } } /// The consolidator under test: real registry, real router, own caller token. struct Consolidator { - port: u16, - token: String, + served: Served, registry: Arc, - shutdown: CancellationToken, - join: JoinHandle>, } impl Consolidator { async fn start(peers: PeersConfig) -> Self { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let port = listener.local_addr().unwrap().port(); - let mut config = Config::default(); - config.server.port = port; - config.auth.enabled = true; - config.peers = peers.clone(); - let mut state = fake_state(config); - let pool = SqlitePoolOptions::new() - .max_connections(1) - .connect("sqlite::memory:") - .await - .unwrap(); - skyg_linux_tracker::db::migrate(&pool).await.unwrap(); - let token = tokens::create(&pool, "caller").await.unwrap(); - state.db = Some(pool); - let shutdown = state.shutdown.clone(); - let registry = PeerRegistry::start(peers, shutdown.clone()).unwrap(); - state.peers = Some(registry.clone()); - let join = tokio::spawn(server::serve_listener( - listener, - None, - server::build_router(state), - shutdown.clone(), - server::Limits::default(), - )); - Self { - port, - token, - registry, - shutdown, - join, - } + let config = Config { + peers: peers.clone(), + ..Config::default() + }; + let (served, registry) = serve(config, None, |state| { + let registry = PeerRegistry::start(peers, state.shutdown.clone()).unwrap(); + state.peers = Some(registry.clone()); + registry + }) + .await; + Self { served, registry } + } + + fn port(&self) -> u16 { + self.served.port + } + + fn token(&self) -> &str { + &self.served.token } /// One GET with the caller's own token unless `token` is given. async fn get(&self, path: &str, token: Option<&str>) -> (u16, String, String) { - let raw = get_raw(path, token.unwrap_or(&self.token), None); - send(self.port, &raw).await + let raw = get_raw(path, token.unwrap_or(&self.served.token), None); + send(self.served.port, &raw).await } async fn wait_status(&self, peer: &str, ok: impl Fn(&PeerStatus) -> bool) -> PeerStatus { @@ -233,8 +213,7 @@ impl Consolidator { } async fn stop(self) { - self.shutdown.cancel(); - let _ = self.join.await; + self.served.stop().await; self.registry.shutdown().await; } } @@ -305,9 +284,13 @@ impl Ca { let issuer = rcgen::Issuer::new(self.params, self.key); let cert = params.signed_by(&key, &issuer).unwrap(); ( - dir.file(&format!("{tag}-ca.pem"), &self.cert_pem), - dir.file(&format!("{tag}-cert.pem"), &cert.pem()), - dir.file(&format!("{tag}-key.pem"), &key.serialize_pem()), + dir.write(&format!("{tag}-ca.pem"), self.cert_pem.as_bytes(), 0o600), + dir.write(&format!("{tag}-cert.pem"), cert.pem().as_bytes(), 0o600), + dir.write( + &format!("{tag}-key.pem"), + key.serialize_pem().as_bytes(), + 0o600, + ), ) } } @@ -448,7 +431,7 @@ async fn a_plain_peer_reports_up_and_auth_ok() { assert_eq!(code, 404, "{body}"); assert!(body.contains("unknown peer"), "{body}"); - let auth = format!("Bearer {}", consolidator.token); + let auth = format!("Bearer {}", consolidator.token()); let raw = common::request( "POST", "/api/v1/peers/beta/systemd/units", @@ -456,7 +439,7 @@ async fn a_plain_peer_reports_up_and_auth_ok() { &[("Authorization", &auth)], Some("{}"), ); - assert_eq!(send(consolidator.port, &raw).await.0, 405); + assert_eq!(send(consolidator.port(), &raw).await.0, 405); // A dead peer flips both checks; the proxy fails with the peer's name and // the caller's own token keeps working. @@ -485,8 +468,8 @@ async fn a_plain_peer_serves_its_own_data_through_the_proxy() { .await; // The proxied answer is the peer's own: compare it with a direct call. - let raw = get_raw("/api/v1/systemd/units", &peer.token, None); - let (direct_code, _, direct) = send(peer.port, &raw).await; + let raw = get_raw("/api/v1/systemd/units", peer.token(), None); + let (direct_code, _, direct) = send(peer.port(), &raw).await; assert_eq!(direct_code, 200); let (code, head, proxied) = consolidator .get("/api/v1/peers/beta/systemd/units", None) @@ -511,7 +494,7 @@ async fn a_peer_declared_by_name_is_reached_on_the_family_it_listens_on() { let dir = TempDir::new("localhost"); let peer = Peer::start().await; let token = peer.token_file(&dir); - let url = format!("http://localhost:{}", peer.port); + let url = format!("http://localhost:{}", peer.port()); let consolidator = Consolidator::start(one_peer("beta", url, None, &token)).await; let status = consolidator @@ -594,7 +577,7 @@ async fn a_redirect_is_reported_and_never_followed() { ))) }) .await; - let token = dir.token("peer-token", "redirect-token\n"); + let token = dir.write("peer-token", "redirect-token\n".as_bytes(), 0o600); let consolidator = Consolidator::start(one_peer("beta", source.url("http"), None, &token)).await; @@ -621,7 +604,7 @@ async fn an_oversize_body_is_refused() { let dir = TempDir::new("oversize"); let source = Listener::start(|| Some(Answer::Reply(response("200 OK", "", &[b'x'; 4096])))).await; - let token = dir.token("peer-token", "big-token\n"); + let token = dir.write("peer-token", "big-token\n".as_bytes(), 0o600); let mut cfg = one_peer("beta", source.url("http"), None, &token); cfg.max_response_bytes = 64; let consolidator = Consolidator::start(cfg).await; @@ -638,7 +621,7 @@ async fn an_oversize_body_is_refused() { async fn a_silent_peer_times_out_within_the_request_timeout() { let dir = TempDir::new("slow"); let source = Listener::start(|| None).await; - let token = dir.token("peer-token", "slow-token\n"); + let token = dir.write("peer-token", "slow-token\n".as_bytes(), 0o600); let mut cfg = one_peer("beta", source.url("http"), None, &token); cfg.request_timeout_secs = 1; let consolidator = Consolidator::start(cfg).await; @@ -671,7 +654,7 @@ async fn a_chunked_body_over_the_cap_is_refused() { } raw.extend(b"0\r\n\r\n"); let source = Listener::start(move || Some(Answer::Reply(raw.clone()))).await; - let token = dir.token("peer-token", "chunked-token\n"); + let token = dir.write("peer-token", "chunked-token\n".as_bytes(), 0o600); let mut cfg = one_peer("beta", source.url("http"), None, &token); cfg.max_response_bytes = 64; let consolidator = Consolidator::start(cfg).await; @@ -700,7 +683,7 @@ async fn a_trickling_peer_times_out_within_the_request_timeout() { }) }) .await; - let token = dir.token("peer-token", "trickle-token\n"); + let token = dir.write("peer-token", "trickle-token\n".as_bytes(), 0o600); let mut cfg = one_peer("beta", source.url("http"), None, &token); cfg.request_timeout_secs = 1; let consolidator = Consolidator::start(cfg).await; @@ -754,16 +737,16 @@ async fn shutdown_ends_a_proxied_follow() { )) }) .await; - let token = dir.token("peer-token", "follow-token\n"); + let token = dir.write("peer-token", "follow-token\n".as_bytes(), 0o600); let consolidator = Consolidator::start(one_peer("beta", source.url("http"), None, &token)).await; let raw = get_raw( "/api/v1/peers/beta/journal/follow", - &consolidator.token, + consolidator.token(), Some("text/event-stream"), ); - let mut sock = tokio::net::TcpStream::connect(("127.0.0.1", consolidator.port)) + let mut sock = tokio::net::TcpStream::connect(("127.0.0.1", consolidator.port())) .await .unwrap(); sock.write_all(raw.as_bytes()).await.unwrap(); @@ -776,13 +759,13 @@ async fn shutdown_ends_a_proxied_follow() { assert!(String::from_utf8_lossy(&buf[..n]).contains("200 OK")); // The stream is open and idle on the peer; shutdown must end it. - consolidator.shutdown.cancel(); + consolidator.served.shutdown.cancel(); let mut rest = Vec::new(); tokio::time::timeout(Duration::from_secs(10), sock.read_to_end(&mut rest)) .await .expect("the proxied follow outlived shutdown") .unwrap(); - tokio::time::timeout(Duration::from_secs(10), consolidator.join) + tokio::time::timeout(Duration::from_secs(10), consolidator.served.join) .await .expect("the server did not drain after shutdown") .unwrap()