use super::*; use std::io::Write; use std::os::unix::fs::OpenOptionsExt; use std::path::PathBuf; use axum::http::HeaderValue as Hv; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::TcpListener; fn limits(per: usize, total: usize, max_bytes: u64) -> PeersConfig { PeersConfig { enabled: true, max_concurrent_per_peer: per, max_concurrent_total: total, max_response_bytes: max_bytes, ..PeersConfig::default() } } fn write_token(contents: &str, mode: u32) -> PathBuf { static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); let path = std::env::temp_dir().join(format!( "slinuxm-peer-token-{}-{}", std::process::id(), N.fetch_add(1, std::sync::atomic::Ordering::Relaxed) )); let mut opts = std::fs::OpenOptions::new(); opts.write(true).create(true).truncate(true).mode(mode); opts.open(&path) .unwrap() .write_all(contents.as_bytes()) .unwrap(); path } fn peer(port: u16, token: &Path, ca: Option) -> 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: ca, allow_plain_http: false, enabled: true, } } fn req(path: &str) -> PeerRequest { PeerRequest { path: path.into(), query: vec![("n".into(), "1".into())], headers: vec![( HeaderName::from_static("x-slinuxm-hop"), Hv::from_static("1"), )], accept: None, } } async fn read_req(sock: &mut tokio::net::TcpStream) -> String { let mut buf = Vec::new(); let mut tmp = [0u8; 1024]; 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() } async fn serve(response: Vec) -> u16 { 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_req(&mut sock).await; let _ = sock.write_all(&response).await; }); port } /// The client has no loader of its own: a token file the shared loader /// refuses is a `TokenFile` error and never reaches the wire. #[tokio::test] async fn a_refused_token_file_sends_nothing() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let transport = ReqwestTransport::new(&limits(4, 8, 1024)).unwrap(); for (body, mode) in [ ("ok-token\r\nsmuggled: 1\n", 0o600), ("ok-token\0", 0o600), ("ok-token\n", 0o644), ("", 0o600), ] { let token = write_token(body, mode); let err = transport .get( &peer(port, &token, None), req("/api/v1/ping"), Duration::from_secs(2), ) .await .unwrap_err(); assert!( matches!(err, PeerError::TokenFile(_)), "{body:?} {mode:o}: {err:?}" ); assert!(!format!("{err:?}").contains("ok-token")); let _ = std::fs::remove_file(&token); } // The listener stayed open for every case, so any attempt to reach the // peer is still queued here rather than lost in a timing window. assert!( tokio::time::timeout(Duration::from_millis(250), listener.accept()) .await .is_err(), "a peer was contacted without a usable token" ); } #[test] fn rejects_zero_limits_and_bad_urls() { let mut cfg = limits(0, 1, 10); assert!(ReqwestTransport::new(&cfg).is_err()); cfg.max_concurrent_per_peer = 1; cfg.max_concurrent_total = 0; assert!(ReqwestTransport::new(&cfg).is_err()); cfg.max_concurrent_total = 1; cfg.max_response_bytes = 0; assert!(ReqwestTransport::new(&cfg).is_err()); let token = write_token("t", 0o600); let mut p = peer(9, &token, None); p.url = url::Url::parse("http://user:pw@127.0.0.1:9/").unwrap(); assert!(request_url(&p, &req("/api/v1/ping")).is_err()); p.url = url::Url::parse("http://127.0.0.1:9/?q=1").unwrap(); assert!(request_url(&p, &req("/x")).is_err()); p.url = url::Url::parse("ftp://127.0.0.1/").unwrap(); assert!(request_url(&p, &req("/x")).is_err()); let _ = std::fs::remove_file(&token); } #[tokio::test] async fn get_is_get_and_sends_the_token_not_a_redirect() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let token = write_token("peer-token-a\n", 0o600); tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); let head = read_req(&mut sock).await; assert!(head.starts_with("GET /api/v1/ping?n=1 HTTP/1.1")); assert!(head .to_ascii_lowercase() .contains("authorization: bearer peer-token-a")); assert!(head.contains("x-slinuxm-hop: 1")); let body = "{\"status\":\"ok\",\"version\":\"9\"}"; let resp = format!( "HTTP/1.1 302 Found\r\nLocation: http://127.0.0.1:1/gone\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() ); let _ = sock.write_all(resp.as_bytes()).await; }); let transport = ReqwestTransport::new(&limits(4, 8, 1024)).unwrap(); let resp = transport .get( &peer(port, &token, None), req("/api/v1/ping"), Duration::from_secs(2), ) .await .unwrap(); assert_eq!(resp.status, 302, "redirects are not followed"); match resp.body { PeerBody::Bytes(b) => assert!(b.windows(3).any(|w| w == b"9\"}")), PeerBody::Stream(_) => panic!("buffered"), } let _ = std::fs::remove_file(&token); } #[tokio::test] async fn rereads_the_token_file() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let token = write_token("first-token\n", 0o600); tokio::spawn(async move { for _ in 0..2 { let (mut sock, _) = listener.accept().await.unwrap(); let head = read_req(&mut sock).await; let line = head .lines() .find(|l| l.to_ascii_lowercase().starts_with("authorization:")) .unwrap() .to_owned(); let body = line; let resp = format!( "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len() ); let _ = sock.write_all(resp.as_bytes()).await; } }); let transport = ReqwestTransport::new(&limits(4, 8, 4096)).unwrap(); let p = peer(port, &token, None); let first = transport .get(&p, req("/api/v1/ping"), Duration::from_secs(2)) .await .unwrap(); std::fs::OpenOptions::new() .write(true) .truncate(true) .mode(0o600) .open(&token) .unwrap() .write_all(b"second-token\n") .unwrap(); let second = transport .get(&p, req("/api/v1/ping"), Duration::from_secs(2)) .await .unwrap(); let text = |r: PeerResponse| match r.body { PeerBody::Bytes(b) => String::from_utf8(b.to_vec()).unwrap(), PeerBody::Stream(_) => panic!("buffered"), }; assert!(text(first).contains("first-token")); assert!(text(second).contains("second-token")); let _ = std::fs::remove_file(&token); } #[tokio::test] async fn timeout_and_closed_port() { let open = TcpListener::bind("127.0.0.1:0").await.unwrap(); let open_port = open.local_addr().unwrap().port(); tokio::spawn(async move { let (_sock, _) = open.accept().await.unwrap(); tokio::time::sleep(Duration::from_secs(2)).await; }); let hang = TcpListener::bind("127.0.0.1:0").await.unwrap(); let hang_port = hang.local_addr().unwrap().port(); tokio::spawn(async move { let (mut sock, _) = hang.accept().await.unwrap(); let _ = read_req(&mut sock).await; tokio::time::sleep(Duration::from_secs(5)).await; }); let transport = ReqwestTransport::new(&limits(2, 2, 1024)).unwrap(); let token = write_token("t", 0o600); assert!(transport .tcp_check(&peer(open_port, &token, None), Duration::from_secs(1)) .await .is_ok()); let started = tokio::time::Instant::now(); let err = transport .get( &peer(hang_port, &token, None), req("/api/v1/ping"), Duration::from_millis(200), ) .await .unwrap_err(); assert!(matches!(err, PeerError::Timeout), "{err:?}"); assert!(started.elapsed() < Duration::from_secs(2)); let closed = TcpListener::bind("127.0.0.1:0").await.unwrap(); let closed_port = closed.local_addr().unwrap().port(); drop(closed); let err = transport .tcp_check(&peer(closed_port, &token, None), Duration::from_secs(1)) .await .unwrap_err(); assert!(matches!(err, PeerError::Unreachable), "{err:?}"); let _ = std::fs::remove_file(&token); } #[tokio::test] async fn byte_cap_ignores_a_lying_content_length_and_counts_chunks() { let transport = ReqwestTransport::new(&limits(2, 2, 32)).unwrap(); let token = write_token("t", 0o600); 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_req(&mut sock).await; let _ = sock .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 1000000\r\nConnection: close\r\n\r\n") .await; tokio::time::sleep(Duration::from_secs(5)).await; }); let started = tokio::time::Instant::now(); let err = transport .get( &peer(port, &token, None), req("/big"), Duration::from_secs(2), ) .await .unwrap_err(); assert!(matches!(err, PeerError::Oversize), "{err:?}"); assert!(started.elapsed() < Duration::from_secs(1)); let body = vec![b'x'; 200]; let mut bytes = b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n".to_vec(); bytes.extend(format!("{:x}\r\n", body.len()).into_bytes()); bytes.extend_from_slice(&body); bytes.extend(b"\r\n0\r\n\r\n"); let port = serve(bytes).await; let err = transport .get( &peer(port, &token, None), req("/chunked"), Duration::from_secs(2), ) .await .unwrap_err(); assert!(matches!(err, PeerError::Oversize), "{err:?}"); let _ = std::fs::remove_file(&token); } #[tokio::test] async fn semaphores_are_per_peer_and_global() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let (ready_tx, ready_rx) = tokio::sync::oneshot::channel(); tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); let _ = read_req(&mut sock).await; let _ = ready_tx.send(()); tokio::time::sleep(Duration::from_secs(5)).await; }); let transport = Arc::new(ReqwestTransport::new(&limits(1, 4, 1024)).unwrap()); let token = write_token("t", 0o600); let p = peer(port, &token, None); let t2 = transport.clone(); let p2 = p.clone(); let hung = tokio::spawn(async move { t2.get(&p2, req("/hang"), Duration::from_secs(4)).await }); ready_rx.await.unwrap(); let started = tokio::time::Instant::now(); let err = transport .get(&p, req("/other"), Duration::from_millis(500)) .await .unwrap_err(); assert!(matches!(err, PeerError::Saturated), "{err:?}"); assert!(started.elapsed() < Duration::from_millis(400)); let mut gamma = p.clone(); gamma.name = PeerName::parse("gamma").unwrap(); // gamma is not blocked by beta's permit; it fails because nothing is listening twice. // Use a fresh accepting server so the call is not Saturated. let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let gport = listener.local_addr().unwrap().port(); tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); let _ = read_req(&mut sock).await; let _ = sock .write_all(b"HTTP/1.1 204 No Content\r\nContent-Length: 0\r\nConnection: close\r\n\r\n") .await; }); gamma.url = url::Url::parse(&format!("http://127.0.0.1:{gport}")).unwrap(); let resp = transport .get(&gamma, req("/ok"), Duration::from_secs(2)) .await .unwrap(); assert_eq!(resp.status, 204); hung.abort(); let _ = std::fs::remove_file(&token); } #[tokio::test] async fn global_semaphore() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let (ready_tx, ready_rx) = tokio::sync::oneshot::channel(); tokio::spawn(async move { let (mut sock, _) = listener.accept().await.unwrap(); let _ = read_req(&mut sock).await; let _ = ready_tx.send(()); tokio::time::sleep(Duration::from_secs(5)).await; }); let transport = Arc::new(ReqwestTransport::new(&limits(4, 1, 1024)).unwrap()); let token = write_token("t", 0o600); let beta = peer(port, &token, None); let mut gamma = beta.clone(); gamma.name = PeerName::parse("gamma").unwrap(); let t2 = transport.clone(); let b2 = beta.clone(); let hung = tokio::spawn(async move { t2.get(&b2, req("/hang"), Duration::from_secs(4)).await }); ready_rx.await.unwrap(); let err = transport .get(&gamma, req("/x"), Duration::from_millis(500)) .await .unwrap_err(); assert!(matches!(err, PeerError::Saturated), "{err:?}"); hung.abort(); let _ = std::fs::remove_file(&token); } #[tokio::test] async fn custom_ca_is_required_for_a_private_cert() { let ck = rcgen::generate_simple_self_signed(vec!["localhost".into(), "127.0.0.1".into()]).unwrap(); let cert_pem = ck.cert.pem(); let key_pem = ck.signing_key.serialize_pem(); let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); let certs: Vec<_> = CertificateDer::pem_slice_iter(cert_pem.as_bytes()) .map(|c| c.unwrap()) .collect(); let key = rustls::pki_types::PrivateKeyDer::from_pem_slice(key_pem.as_bytes()).unwrap(); let provider = Arc::new(rustls::crypto::ring::default_provider()); let mut scfg = rustls::ServerConfig::builder_with_provider(provider) .with_safe_default_protocol_versions() .unwrap() .with_no_client_auth() .with_single_cert(certs, key) .unwrap(); scfg.alpn_protocols = vec![b"http/1.1".to_vec()]; let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(scfg)); tokio::spawn(async move { for _ in 0..2 { let (sock, _) = listener.accept().await.unwrap(); let Ok(mut tls) = acceptor.accept(sock).await else { continue; }; let mut buf = [0u8; 2048]; let _ = tokio::time::timeout(Duration::from_secs(2), tls.read(&mut buf)).await; let _ = tls .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok") .await; } }); let token = write_token("t", 0o600); let ca_path = std::env::temp_dir().join(format!("slinuxm-ca-{}-{}", std::process::id(), port)); std::fs::write(&ca_path, &cert_pem).unwrap(); let transport = ReqwestTransport::new(&limits(2, 2, 1024)).unwrap(); let mut https = peer(port, &token, None); https.url = url::Url::parse(&format!("https://127.0.0.1:{port}")).unwrap(); let err = transport .get(&https, req("/api/v1/ping"), Duration::from_secs(2)) .await .unwrap_err(); assert!(matches!(err, PeerError::Tls), "{err:?}"); https.ca_file = Some(ca_path.clone()); let resp = transport .get(&https, req("/api/v1/ping"), Duration::from_secs(2)) .await .unwrap(); assert_eq!(resp.status, 200); let _ = std::fs::remove_file(&token); let _ = std::fs::remove_file(&ca_path); } #[tokio::test] async fn deny_cidrs_are_enforced_at_connect_time() { let mut cfg = limits(2, 2, 1024); cfg.deny_cidrs = vec!["127.0.0.0/8".into()]; let transport = ReqwestTransport::new(&cfg).unwrap(); let token = write_token("t", 0o600); let p = peer(9, &token, None); assert!(matches!( transport.tcp_check(&p, Duration::from_secs(1)).await, Err(PeerError::Unreachable) )); assert!(matches!( transport .get(&p, req("/api/v1/ping"), Duration::from_secs(1)) .await, Err(PeerError::Unreachable) )); let _ = std::fs::remove_file(&token); } /// An IPv4-mapped literal resolves to a socket address in the IPv6 family. /// Without canonicalising it the IPv4 deny list would miss it and the /// metadata endpoint would be contacted. #[tokio::test] async fn an_ipv4_mapped_address_is_matched_against_the_v4_deny_list() { let token = write_token("t", 0o600); let mut p = peer(80, &token, None); p.url = url("http://[::ffff:169.254.169.254]/"); p.allow_plain_http = true; let deny = deny_networks(&PeersConfig::default().deny_cidrs).unwrap(); assert!(matches!( resolve_target(&p, &deny).await, Err(PeerError::Unreachable) )); let transport = ReqwestTransport::new(&PeersConfig::default()).unwrap(); assert!(matches!( transport.tcp_check(&p, Duration::from_secs(1)).await, Err(PeerError::Unreachable) )); let _ = std::fs::remove_file(&token); } #[test] fn invalid_deny_cidr_and_plain_http_opt_in() { let mut cfg = limits(2, 2, 1024); cfg.deny_cidrs = vec!["not-a-cidr".into()]; assert!(ReqwestTransport::new(&cfg).is_err()); let transport = ReqwestTransport::new(&limits(2, 2, 1024)).unwrap(); let token = write_token("t", 0o600); let mut p = peer(9, &token, None); p.url = url::Url::parse("http://10.0.0.5:1984").unwrap(); assert!(!p.allow_plain_http); assert!(validate_target(&p).is_err()); p.allow_plain_http = true; assert!(validate_target(&p).is_ok()); assert!(transport .deny_list() .iter() .any(|n| n.to_string() == "169.254.0.0/16")); let _ = std::fs::remove_file(&token); } fn url(s: &str) -> url::Url { url::Url::parse(s).unwrap() } #[test] fn ipv6_plain_http_to_loopback_needs_no_opt_in() { let mut p = peer(9, Path::new("/tmp/does-not-matter"), None); p.url = url("http://[::1]:9"); assert!(!p.allow_plain_http); assert!(validate_target(&p).is_ok()); } #[tokio::test] async fn ipv6_literal_peers_resolve_and_connect() { let Ok(listener) = TcpListener::bind("[::1]:0").await else { return; // no IPv6 loopback in this environment }; let port = listener.local_addr().unwrap().port(); tokio::spawn(async move { loop { let Ok((mut sock, _)) = listener.accept().await else { return; }; let _ = read_req(&mut sock).await; let _ = sock .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok") .await; } }); let token = write_token("t", 0o600); let transport = ReqwestTransport::new(&limits(2, 2, 1024)).unwrap(); let mut p = peer(0, &token, None); p.url = url(&format!("http://[::1]:{port}")); assert!(transport .tcp_check(&p, Duration::from_secs(1)) .await .is_ok()); let resp = transport .get(&p, req("/api/v1/ping"), Duration::from_secs(2)) .await; let resp = resp.unwrap(); assert_eq!(resp.status, 200); let _ = std::fs::remove_file(&token); } /// A name is resolved to every address, and one denied address refuses /// the name rather than being skipped in favour of a permitted one. #[tokio::test] async fn every_resolved_address_is_returned_and_checked() { let token = write_token("t", 0o600); let mut p = peer(9, &token, None); p.url = url("http://localhost:9"); let (pin, addrs) = resolve_target(&p, &[]).await.unwrap(); assert_eq!(pin.as_deref(), Some("localhost")); assert!(!addrs.is_empty()); // `localhost` may resolve to both loopback families. Denying one of // them must refuse the whole name. let denied_family = if addrs.iter().any(|a| a.is_ipv4()) { "127.0.0.0/8" } else { "::1/128" }; let deny = deny_networks(&[denied_family.to_owned()]).unwrap(); assert!(matches!( resolve_target(&p, &deny).await, Err(PeerError::Unreachable) )); let _ = std::fs::remove_file(&token); } /// A peer declared by name must be reached on the family it listens on: /// the listener takes one family only, so an address of the other family /// has to be tried and refused before the reachable one. Driven with an /// explicit address list, because what `localhost` resolves to depends on /// /etc/hosts. #[tokio::test] async fn tcp_check_tries_every_resolved_address() { let mut served = Vec::new(); for bind in ["127.0.0.1", "[::1]"] { let Ok(listener) = TcpListener::bind(format!("{bind}:0")).await else { continue; // this environment has no loopback of that family }; let port = listener.local_addr().unwrap().port(); tokio::spawn(async move { while let Ok((mut sock, _)) = listener.accept().await { let _ = read_req(&mut sock).await; let _ = sock .write_all( b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok", ) .await; } }); let live: SocketAddr = format!("{bind}:{port}").parse().unwrap(); // Nothing listens on that port on any other loopback, so a check // that gave up on the first address would fail here. let dead: Vec = ["127.0.0.1", "[::1]"] .iter() .filter(|other| **other != bind) .filter_map(|other| format!("{other}:{port}").parse().ok()) .collect(); let addrs: Vec = dead.into_iter().chain([live]).collect(); let deadline = tokio::time::Instant::now() + Duration::from_secs(2); assert!(connect_any(&addrs, deadline).await.is_ok(), "{addrs:?}"); served.push(bind); } assert!(!served.is_empty(), "no loopback address to listen on"); } /// The request timeout bounds preparation, not a follow stream: chunks /// keep arriving long after it would have expired. #[tokio::test] async fn a_stream_outlives_the_request_timeout() { 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_req(&mut sock).await; let _ = sock .write_all( b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nTransfer-Encoding: chunked\r\n\r\n", ) .await; for i in 0..3u8 { let chunk = format!("data: {i}\n\n"); let frame = format!("{:x}\r\n{}\r\n", chunk.len(), chunk); if sock.write_all(frame.as_bytes()).await.is_err() { return; } tokio::time::sleep(Duration::from_millis(250)).await; } let _ = sock.write_all(b"0\r\n\r\n").await; }); let token = write_token("t", 0o600); let transport = ReqwestTransport::new(&limits(2, 2, 4096)).unwrap(); let mut r = req("/journal/follow"); r.query.clear(); r.accept = Some("text/event-stream".into()); let resp = transport .get(&peer(port, &token, None), r, Duration::from_millis(150)) .await .unwrap(); assert_eq!(resp.status, 200); let PeerBody::Stream(stream) = resp.body else { panic!("expected a stream"); }; use futures::StreamExt; let chunks: Vec<_> = stream.collect().await; assert_eq!(chunks.len(), 3, "{chunks:?}"); assert!(chunks.into_iter().all(|c| c.is_ok())); let _ = std::fs::remove_file(&token); } /// A held stream must not consume the slot health probes need. #[tokio::test] async fn probes_bypass_the_concurrency_limits() { let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); let port = listener.local_addr().unwrap().port(); tokio::spawn(async move { loop { let Ok((mut sock, _)) = listener.accept().await else { return; }; tokio::spawn(async move { let head = read_req(&mut sock).await; if head.starts_with("GET /journal/follow") { let _ = sock .write_all( b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nTransfer-Encoding: chunked\r\n\r\n5\r\ndata:\r\n", ) .await; tokio::time::sleep(Duration::from_secs(3)).await; } else { let _ = sock .write_all( b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok", ) .await; } }); } }); let token = write_token("t", 0o600); let transport = ReqwestTransport::new(&limits(1, 4, 4096)).unwrap(); let p = peer(port, &token, None); let mut follow = req("/journal/follow"); follow.query.clear(); follow.accept = Some("text/event-stream".into()); let held = transport .get(&p, follow, Duration::from_secs(2)) .await .unwrap(); assert!(matches!(held.body, PeerBody::Stream(_))); let mut ping = req("/api/v1/ping"); ping.query.clear(); let resp = transport.get(&p, ping, Duration::from_secs(1)).await; assert!(resp.is_ok(), "a probe is not blocked by the held stream"); let err = transport .get(&p, req("/systemd/units"), Duration::from_secs(1)) .await .unwrap_err(); assert!(matches!(err, PeerError::Saturated), "{err:?}"); drop(held); let _ = std::fs::remove_file(&token); } #[tokio::test(start_paused = true)] async fn one_deadline_covers_every_phase() { let deadline = tokio::time::Instant::now() + Duration::from_millis(50); let err = within(deadline, std::future::pending::>()) .await .unwrap_err(); assert!(matches!(err, PeerError::Timeout)); let deadline = tokio::time::Instant::now() + Duration::from_millis(50); let ok = within(deadline, async { Ok::<_, PeerError>(7) }) .await .unwrap(); assert_eq!(ok, 7); let deadline = tokio::time::Instant::now() + Duration::from_millis(50); let err = within(deadline, async { Err::<(), _>(PeerError::Dns) }) .await .unwrap_err(); assert!(matches!(err, PeerError::Dns)); }