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()