pulled out tests and validated them
This commit is contained in:
1 parent
dc8d62da30
commit
435a54a02d
67 files changed
+6927
-6957
No files matched your search
@@ -0,0 +1,750 @@
|
||||
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<PathBuf>) -> 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<u8>) -> 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<SocketAddr> = ["127.0.0.1", "[::1]"]
|
||||
.iter()
|
||||
.filter(|other| **other != bind)
|
||||
.filter_map(|other| format!("{other}:{port}").parse().ok())
|
||||
.collect();
|
||||
let addrs: Vec<SocketAddr> = 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::<Result<(), PeerError>>())
|
||||
.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));
|
||||
}
|
||||
Reference in new issue
Block a user