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,36 @@
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
|
||||
struct Layer(Arc<Mutex<Vec<String>>>);
|
||||
|
||||
impl<S: tracing::Subscriber> tracing_subscriber::Layer<S> for Layer {
|
||||
fn on_event(
|
||||
&self,
|
||||
event: &tracing::Event<'_>,
|
||||
_ctx: tracing_subscriber::layer::Context<'_, S>,
|
||||
) {
|
||||
let mut msg = String::new();
|
||||
event.record(&mut FieldVisit(&mut msg));
|
||||
self.0.lock().expect("log lock").push(msg);
|
||||
}
|
||||
}
|
||||
|
||||
struct FieldVisit<'a>(&'a mut String);
|
||||
|
||||
impl tracing::field::Visit for FieldVisit<'_> {
|
||||
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
|
||||
use std::fmt::Write;
|
||||
let _ = write!(self.0, "{}={value:?} ", field.name());
|
||||
}
|
||||
}
|
||||
|
||||
/// Run `f` under a subscriber that records every event, and return the
|
||||
/// rendered fields joined by newlines.
|
||||
pub(crate) fn logged(f: impl FnOnce()) -> String {
|
||||
let buf = Arc::new(Mutex::new(Vec::new()));
|
||||
let sub = tracing_subscriber::registry().with(Layer(buf.clone()));
|
||||
tracing::subscriber::with_default(sub, f);
|
||||
let text = buf.lock().expect("log lock").join("\n");
|
||||
text
|
||||
}
|
||||
+2
-86
@@ -144,89 +144,5 @@ fn class(error: Option<&str>) -> &str {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::path::PathBuf;
|
||||
|
||||
use super::*;
|
||||
use crate::peers::error::PeerError;
|
||||
use crate::peers::testing::{fake_peers_config, FakeTransport};
|
||||
|
||||
const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK";
|
||||
|
||||
fn config(names: &[&str]) -> PeersConfig {
|
||||
fake_peers_config(names)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_is_sorted_and_shows_paths_not_contents() {
|
||||
// `list_report` takes a config and never opens the file: a path that
|
||||
// does not exist must still render, and no content can appear.
|
||||
let missing = PathBuf::from("/run/credentials/skyg-linux-tracker.service/peer-gamma");
|
||||
let mut cfg = config(&["gamma", "beta"]);
|
||||
cfg.peer[0].token_file = missing.clone();
|
||||
cfg.peer[1].enabled = false;
|
||||
assert!(!missing.exists(), "fixture must not exist");
|
||||
let report = list_report(&cfg);
|
||||
assert!(report.contains("NAME"));
|
||||
assert!(report.contains("http://beta:1984"));
|
||||
assert!(report.contains(&missing.display().to_string()));
|
||||
assert!(report.find("beta").unwrap() < report.find("gamma").unwrap());
|
||||
assert!(report.contains(" no "), "disabled peer is marked: {report}");
|
||||
assert!(!report.contains(SECRET));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_with_no_peers_says_so() {
|
||||
assert_eq!(
|
||||
list_report(&PeersConfig::default()),
|
||||
"no peers configured\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn check_reports_latency_and_auth() {
|
||||
let fake = FakeTransport::new();
|
||||
let report = check_report(fake.as_ref(), &config(&["beta"]), "beta")
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(report.contains("peer beta: http://beta:1984"));
|
||||
assert!(report.contains("server up (1 ms)"), "{report}");
|
||||
assert!(report.contains("api up, auth ok"), "{report}");
|
||||
assert!(!report.contains(SECRET));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn check_reports_rejected_credentials_as_api_up() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Rejected);
|
||||
let report = check_report(fake.as_ref(), &config(&["beta"]), "beta")
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(report.contains("api up, auth rejected"), "{report}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn check_reports_down_classes_without_token() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").tcp(Err(PeerError::Timeout));
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Tls);
|
||||
let report = check_report(fake.as_ref(), &config(&["beta"]), "beta")
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(report.contains("server down (timeout)"), "{report}");
|
||||
assert!(report.contains("api down (tls_error)"), "{report}");
|
||||
assert!(report.contains("auth unknown"), "{report}");
|
||||
assert!(!report.contains(SECRET));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unknown_peer_is_an_error_without_echoing_the_name_as_a_secret() {
|
||||
let fake = FakeTransport::new();
|
||||
let err = check_report(fake.as_ref(), &config(&["beta"]), "nope")
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.to_string(), "unknown peer \"nope\"");
|
||||
}
|
||||
}
|
||||
#[path = "cli_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,84 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use super::*;
|
||||
use crate::peers::error::PeerError;
|
||||
use crate::peers::testing::{fake_peers_config, FakeTransport};
|
||||
|
||||
const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK";
|
||||
|
||||
fn config(names: &[&str]) -> PeersConfig {
|
||||
fake_peers_config(names)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_is_sorted_and_shows_paths_not_contents() {
|
||||
// `list_report` takes a config and never opens the file: a path that
|
||||
// does not exist must still render, and no content can appear.
|
||||
let missing = PathBuf::from("/run/credentials/skyg-linux-tracker.service/peer-gamma");
|
||||
let mut cfg = config(&["gamma", "beta"]);
|
||||
cfg.peer[0].token_file = missing.clone();
|
||||
cfg.peer[1].enabled = false;
|
||||
assert!(!missing.exists(), "fixture must not exist");
|
||||
let report = list_report(&cfg);
|
||||
assert!(report.contains("NAME"));
|
||||
assert!(report.contains("http://beta:1984"));
|
||||
assert!(report.contains(&missing.display().to_string()));
|
||||
assert!(report.find("beta").unwrap() < report.find("gamma").unwrap());
|
||||
assert!(report.contains(" no "), "disabled peer is marked: {report}");
|
||||
assert!(!report.contains(SECRET));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_with_no_peers_says_so() {
|
||||
assert_eq!(
|
||||
list_report(&PeersConfig::default()),
|
||||
"no peers configured\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn check_reports_latency_and_auth() {
|
||||
let fake = FakeTransport::new();
|
||||
let report = check_report(fake.as_ref(), &config(&["beta"]), "beta")
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(report.contains("peer beta: http://beta:1984"));
|
||||
assert!(report.contains("server up (1 ms)"), "{report}");
|
||||
assert!(report.contains("api up, auth ok"), "{report}");
|
||||
assert!(!report.contains(SECRET));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn check_reports_rejected_credentials_as_api_up() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Rejected);
|
||||
let report = check_report(fake.as_ref(), &config(&["beta"]), "beta")
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(report.contains("api up, auth rejected"), "{report}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn check_reports_down_classes_without_token() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").tcp(Err(PeerError::Timeout));
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Tls);
|
||||
let report = check_report(fake.as_ref(), &config(&["beta"]), "beta")
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(report.contains("server down (timeout)"), "{report}");
|
||||
assert!(report.contains("api down (tls_error)"), "{report}");
|
||||
assert!(report.contains("auth unknown"), "{report}");
|
||||
assert!(!report.contains(SECRET));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unknown_peer_is_an_error_without_echoing_the_name_as_a_secret() {
|
||||
let fake = FakeTransport::new();
|
||||
let err = check_report(fake.as_ref(), &config(&["beta"]), "nope")
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.to_string(), "unknown peer \"nope\"");
|
||||
}
|
||||
+2
-763
@@ -566,766 +566,5 @@ fn load_ca_path(path: &Path) -> Result<Option<Vec<u8>>, PeerError> {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
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));
|
||||
}
|
||||
}
|
||||
#[path = "client_tests.rs"]
|
||||
mod tests;
|
||||
@@ -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));
|
||||
}
|
||||
+2
-316
@@ -234,319 +234,5 @@ fn host_ip(url: &Url) -> Option<IpAddr> {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::path::PathBuf;
|
||||
|
||||
use super::*;
|
||||
use crate::peers::testing::{capture::logged, TempDir};
|
||||
use crate::peers::types::PeerName;
|
||||
|
||||
fn peer(name: &str, url: &str) -> PeerConfig {
|
||||
PeerConfig {
|
||||
name: PeerName::parse(name).unwrap(),
|
||||
url: Url::parse(url).unwrap(),
|
||||
token_file: PathBuf::from(format!("/run/peers/{name}.token")),
|
||||
ca_file: None,
|
||||
allow_plain_http: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn disabled_section(peers: Vec<PeerConfig>) -> PeersConfig {
|
||||
PeersConfig {
|
||||
enabled: false,
|
||||
peer: peers,
|
||||
..PeersConfig::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn message(err: ConfigError) -> String {
|
||||
match err {
|
||||
ConfigError::Invalid(message) => message,
|
||||
other => panic!("expected Invalid, got {other}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaults_and_loopback_http_are_valid() {
|
||||
validate(&PeersConfig::default()).unwrap();
|
||||
let mut beta = peer("beta", "http://127.0.0.1:1984");
|
||||
beta.token_file = PathBuf::from("/tmp/does-not-need-to-exist");
|
||||
validate(&disabled_section(vec![beta])).unwrap();
|
||||
validate(&disabled_section(vec![peer(
|
||||
"beta",
|
||||
"http://localhost:1984",
|
||||
)]))
|
||||
.unwrap();
|
||||
validate(&disabled_section(vec![peer("beta", "http://[::1]:1984")])).unwrap();
|
||||
validate(&disabled_section(vec![peer(
|
||||
"beta",
|
||||
"https://minipc1:1984/base",
|
||||
)]))
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn timings(
|
||||
tcp_timeout: u64,
|
||||
tcp_interval: u64,
|
||||
api_timeout: u64,
|
||||
api_interval: u64,
|
||||
) -> PeersConfig {
|
||||
PeersConfig {
|
||||
tcp_timeout_secs: tcp_timeout,
|
||||
tcp_interval_secs: tcp_interval,
|
||||
api_timeout_secs: api_timeout,
|
||||
api_interval_secs: api_interval,
|
||||
..PeersConfig::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timeouts_must_be_below_their_interval() {
|
||||
let err = message(validate(&timings(10, 10, 5, 30)).unwrap_err());
|
||||
assert!(err.contains("tcp_timeout_secs"));
|
||||
assert!(err.contains("below"));
|
||||
assert!(
|
||||
message(validate(&timings(3, 10, 30, 30)).unwrap_err()).contains("api_timeout_secs")
|
||||
);
|
||||
assert!(
|
||||
message(validate(&timings(3, 10, 0, 30)).unwrap_err()).contains("greater than zero")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_are_unique_and_capped() {
|
||||
let err = message(
|
||||
validate(&disabled_section(vec![
|
||||
peer("beta", "https://beta:1984"),
|
||||
peer("beta", "https://beta:1985"),
|
||||
]))
|
||||
.unwrap_err(),
|
||||
);
|
||||
assert!(err.contains("duplicate"));
|
||||
assert!(err.contains("beta"));
|
||||
|
||||
let peers = (0..MAX_PEERS + 1)
|
||||
.map(|i| {
|
||||
let mut p = peer("beta", "https://beta:1984");
|
||||
p.name = PeerName::parse(&format!("p{i}")).unwrap();
|
||||
p
|
||||
})
|
||||
.collect();
|
||||
let err = message(validate(&disabled_section(peers)).unwrap_err());
|
||||
assert!(err.contains("64"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn url_rules_reject_scheme_userinfo_query_fragment_and_deny_list() {
|
||||
let cases = [
|
||||
("ftp://beta:1984", "scheme"),
|
||||
("http://user:s3cret@127.0.0.1:1984", "userinfo"),
|
||||
("https://beta:1984?token=s3cret", "query"),
|
||||
("https://beta:1984#s3cret", "fragment"),
|
||||
("http://169.254.169.254/latest", "deny_cidrs"),
|
||||
("https://0.1.2.3:1984", "deny_cidrs"),
|
||||
];
|
||||
for (url, needle) in cases {
|
||||
let err = message(validate(&disabled_section(vec![peer("beta", url)])).unwrap_err());
|
||||
assert!(err.contains(needle), "{url} -> {err}");
|
||||
assert!(err.contains("beta"), "{url} -> {err}");
|
||||
assert!(!err.contains("s3cret"), "{url} leaked into {err}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plain_http_off_loopback_requires_the_flag_and_warns_when_set() {
|
||||
let err = message(
|
||||
validate(&disabled_section(vec![peer("beta", "http://minipc1:1984")])).unwrap_err(),
|
||||
);
|
||||
assert!(err.contains("beta"));
|
||||
assert!(err.contains("allow_plain_http"));
|
||||
assert!(!err.contains("token"));
|
||||
|
||||
let dir = TempDir::new("peer-cfg");
|
||||
let mut allowed = peer("beta", "http://10.1.2.3:1984");
|
||||
allowed.allow_plain_http = true;
|
||||
allowed.token_file = dir.write_token("pending\n");
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![allowed],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let logs = logged(|| validate(&cfg).unwrap());
|
||||
assert!(logs.contains("cleartext"), "{logs}");
|
||||
assert!(logs.contains("beta"), "{logs}");
|
||||
assert!(!logs.contains("10.1.2.3"), "{logs}");
|
||||
// Once per accepted peer set; the transport does not warn again.
|
||||
assert_eq!(logs.matches("cleartext").count(), 1, "{logs}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deny_cidr_must_parse_and_ipv6_literals_match() {
|
||||
let cfg = PeersConfig {
|
||||
deny_cidrs: vec!["not-a-cidr".into()],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
assert!(message(validate(&cfg).unwrap_err()).contains("not-a-cidr"));
|
||||
|
||||
let mut beta = peer("beta", "http://[fe80::1]:1984");
|
||||
beta.allow_plain_http = true;
|
||||
let cfg = PeersConfig {
|
||||
deny_cidrs: vec!["fe80::/10".into()],
|
||||
peer: vec![beta],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate(&cfg).unwrap_err());
|
||||
assert!(err.contains("deny_cidrs"), "{err}");
|
||||
assert!(err.contains("fe80::1"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ipv4_mapped_ipv6_literals_match_the_v4_deny_list() {
|
||||
let mut beta = peer("beta", "http://[::ffff:169.254.169.254]:80");
|
||||
beta.allow_plain_http = true;
|
||||
let cfg = PeersConfig {
|
||||
peer: vec![beta],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate(&cfg).unwrap_err());
|
||||
assert!(err.contains("deny_cidrs"), "{err}");
|
||||
|
||||
// The address form the connector sees is matched the same way.
|
||||
let deny = deny_networks(&cfg.deny_cidrs).unwrap();
|
||||
assert!(denied("::ffff:169.254.169.254".parse().unwrap(), &deny));
|
||||
assert!(denied("169.254.169.254".parse().unwrap(), &deny));
|
||||
assert!(!denied("::ffff:10.0.0.1".parse().unwrap(), &deny));
|
||||
|
||||
// Same for loopback: a mapped literal is loopback, so plain http is
|
||||
// allowed without the flag.
|
||||
let cfg = disabled_section(vec![peer("beta", "http://[::ffff:127.0.0.1]:1984")]);
|
||||
validate(&cfg).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_file_must_be_absolute_but_is_not_opened_by_structural_checks() {
|
||||
let mut relative = peer("beta", "https://beta:1984");
|
||||
relative.token_file = PathBuf::from("peer-beta");
|
||||
let err = message(validate(&disabled_section(vec![relative])).unwrap_err());
|
||||
assert!(err.contains("beta"));
|
||||
assert!(err.contains("absolute"));
|
||||
|
||||
// A missing credential is not a config error: token management,
|
||||
// `peer list` and `--print-config` load this config successfully.
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![peer("beta", "https://beta:1984")],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
validate(&cfg).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_readiness_is_checked_only_for_peers_that_are_contacted() {
|
||||
let mut cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![peer("beta", "https://beta:1984")],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate_tokens(&cfg).unwrap_err());
|
||||
assert!(err.contains("peer beta"), "{err}");
|
||||
assert!(err.contains("not readable"), "{err}");
|
||||
|
||||
cfg.peer[0].enabled = false;
|
||||
validate_tokens(&cfg).unwrap();
|
||||
|
||||
cfg.enabled = false;
|
||||
cfg.peer[0].enabled = true;
|
||||
validate_tokens(&cfg).unwrap();
|
||||
|
||||
let dir = TempDir::new("peer-cfg");
|
||||
cfg.enabled = true;
|
||||
cfg.peer[0].token_file = dir.write_token("pending\n");
|
||||
validate_tokens(&cfg).unwrap();
|
||||
validate_peer_token(&cfg.peer[0]).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ca_file_must_be_absolute_when_set() {
|
||||
let mut beta = peer("beta", "https://beta:1984");
|
||||
beta.ca_file = Some(PathBuf::from("ca.pem"));
|
||||
let err = message(validate(&disabled_section(vec![beta])).unwrap_err());
|
||||
assert!(err.contains("ca_file"));
|
||||
assert!(err.contains("beta"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_readiness_rejects_an_empty_token_file() {
|
||||
let dir = TempDir::new("peer-cfg");
|
||||
let mut beta = peer("beta", "http://127.0.0.1:1984");
|
||||
beta.token_file = dir.write_token("");
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![beta],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate_tokens(&cfg).unwrap_err());
|
||||
assert!(err.contains("peer beta"), "{err}");
|
||||
assert!(err.contains("empty"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enabled_with_no_peers_warns_and_is_not_an_error() {
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let logs = logged(|| validate(&cfg).unwrap());
|
||||
assert!(logs.contains("no peers are configured"), "{logs}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loopback_detection_covers_localhost_and_both_families() {
|
||||
assert!(url_is_loopback(
|
||||
&Url::parse("http://LOCALHOST:1984").unwrap()
|
||||
));
|
||||
assert!(url_is_loopback(
|
||||
&Url::parse("http://127.0.0.2:1984").unwrap()
|
||||
));
|
||||
assert!(url_is_loopback(&Url::parse("http://[::1]:1984").unwrap()));
|
||||
assert!(url_is_loopback(
|
||||
&Url::parse("http://[::ffff:127.0.0.1]:1984").unwrap()
|
||||
));
|
||||
assert!(!url_is_loopback(
|
||||
&Url::parse("http://10.0.0.1:1984").unwrap()
|
||||
));
|
||||
assert!(!url_is_loopback(&Url::parse("http://beta:1984").unwrap()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_default_deny_list_covers_metadata_in_both_families_but_allows_lans() {
|
||||
let deny = deny_networks(&PeersConfig::default().deny_cidrs).unwrap();
|
||||
for refused in [
|
||||
"169.254.169.254",
|
||||
"0.0.0.0",
|
||||
"fe80::1",
|
||||
"::",
|
||||
"fd00:ec2::254",
|
||||
"::ffff:169.254.169.254",
|
||||
] {
|
||||
assert!(denied(refused.parse().unwrap(), &deny), "{refused}");
|
||||
}
|
||||
for allowed in [
|
||||
"10.1.2.3",
|
||||
"192.168.1.10",
|
||||
"::1",
|
||||
"fd00:1::5",
|
||||
"2001:db8::1",
|
||||
] {
|
||||
assert!(!denied(allowed.parse().unwrap(), &deny), "{allowed}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deny_networks_rejects_a_bad_cidr_once_for_every_caller() {
|
||||
assert!(deny_networks(&["10.0.0.0/8".into()]).is_ok());
|
||||
let err = deny_networks(&["nope".into()]).unwrap_err();
|
||||
assert!(message(err).contains("peers.deny_cidrs"));
|
||||
}
|
||||
}
|
||||
#[path = "config_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,310 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use super::*;
|
||||
use crate::peers::testing::{capture::logged, TempDir};
|
||||
use crate::peers::types::PeerName;
|
||||
|
||||
fn peer(name: &str, url: &str) -> PeerConfig {
|
||||
PeerConfig {
|
||||
name: PeerName::parse(name).unwrap(),
|
||||
url: Url::parse(url).unwrap(),
|
||||
token_file: PathBuf::from(format!("/run/peers/{name}.token")),
|
||||
ca_file: None,
|
||||
allow_plain_http: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn disabled_section(peers: Vec<PeerConfig>) -> PeersConfig {
|
||||
PeersConfig {
|
||||
enabled: false,
|
||||
peer: peers,
|
||||
..PeersConfig::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn message(err: ConfigError) -> String {
|
||||
match err {
|
||||
ConfigError::Invalid(message) => message,
|
||||
other => panic!("expected Invalid, got {other}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaults_and_loopback_http_are_valid() {
|
||||
validate(&PeersConfig::default()).unwrap();
|
||||
let mut beta = peer("beta", "http://127.0.0.1:1984");
|
||||
beta.token_file = PathBuf::from("/tmp/does-not-need-to-exist");
|
||||
validate(&disabled_section(vec![beta])).unwrap();
|
||||
validate(&disabled_section(vec![peer(
|
||||
"beta",
|
||||
"http://localhost:1984",
|
||||
)]))
|
||||
.unwrap();
|
||||
validate(&disabled_section(vec![peer("beta", "http://[::1]:1984")])).unwrap();
|
||||
validate(&disabled_section(vec![peer(
|
||||
"beta",
|
||||
"https://minipc1:1984/base",
|
||||
)]))
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn timings(
|
||||
tcp_timeout: u64,
|
||||
tcp_interval: u64,
|
||||
api_timeout: u64,
|
||||
api_interval: u64,
|
||||
) -> PeersConfig {
|
||||
PeersConfig {
|
||||
tcp_timeout_secs: tcp_timeout,
|
||||
tcp_interval_secs: tcp_interval,
|
||||
api_timeout_secs: api_timeout,
|
||||
api_interval_secs: api_interval,
|
||||
..PeersConfig::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timeouts_must_be_below_their_interval() {
|
||||
let err = message(validate(&timings(10, 10, 5, 30)).unwrap_err());
|
||||
assert!(err.contains("tcp_timeout_secs"));
|
||||
assert!(err.contains("below"));
|
||||
assert!(message(validate(&timings(3, 10, 30, 30)).unwrap_err()).contains("api_timeout_secs"));
|
||||
assert!(message(validate(&timings(3, 10, 0, 30)).unwrap_err()).contains("greater than zero"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn names_are_unique_and_capped() {
|
||||
let err = message(
|
||||
validate(&disabled_section(vec![
|
||||
peer("beta", "https://beta:1984"),
|
||||
peer("beta", "https://beta:1985"),
|
||||
]))
|
||||
.unwrap_err(),
|
||||
);
|
||||
assert!(err.contains("duplicate"));
|
||||
assert!(err.contains("beta"));
|
||||
|
||||
let peers = (0..MAX_PEERS + 1)
|
||||
.map(|i| {
|
||||
let mut p = peer("beta", "https://beta:1984");
|
||||
p.name = PeerName::parse(&format!("p{i}")).unwrap();
|
||||
p
|
||||
})
|
||||
.collect();
|
||||
let err = message(validate(&disabled_section(peers)).unwrap_err());
|
||||
assert!(err.contains("64"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn url_rules_reject_scheme_userinfo_query_fragment_and_deny_list() {
|
||||
let cases = [
|
||||
("ftp://beta:1984", "scheme"),
|
||||
("http://user:s3cret@127.0.0.1:1984", "userinfo"),
|
||||
("https://beta:1984?token=s3cret", "query"),
|
||||
("https://beta:1984#s3cret", "fragment"),
|
||||
("http://169.254.169.254/latest", "deny_cidrs"),
|
||||
("https://0.1.2.3:1984", "deny_cidrs"),
|
||||
];
|
||||
for (url, needle) in cases {
|
||||
let err = message(validate(&disabled_section(vec![peer("beta", url)])).unwrap_err());
|
||||
assert!(err.contains(needle), "{url} -> {err}");
|
||||
assert!(err.contains("beta"), "{url} -> {err}");
|
||||
assert!(!err.contains("s3cret"), "{url} leaked into {err}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plain_http_off_loopback_requires_the_flag_and_warns_when_set() {
|
||||
let err = message(
|
||||
validate(&disabled_section(vec![peer("beta", "http://minipc1:1984")])).unwrap_err(),
|
||||
);
|
||||
assert!(err.contains("beta"));
|
||||
assert!(err.contains("allow_plain_http"));
|
||||
assert!(!err.contains("token"));
|
||||
|
||||
let dir = TempDir::new("peer-cfg");
|
||||
let mut allowed = peer("beta", "http://10.1.2.3:1984");
|
||||
allowed.allow_plain_http = true;
|
||||
allowed.token_file = dir.write_token("pending\n");
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![allowed],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let logs = logged(|| validate(&cfg).unwrap());
|
||||
assert!(logs.contains("cleartext"), "{logs}");
|
||||
assert!(logs.contains("beta"), "{logs}");
|
||||
assert!(!logs.contains("10.1.2.3"), "{logs}");
|
||||
// Once per accepted peer set; the transport does not warn again.
|
||||
assert_eq!(logs.matches("cleartext").count(), 1, "{logs}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deny_cidr_must_parse_and_ipv6_literals_match() {
|
||||
let cfg = PeersConfig {
|
||||
deny_cidrs: vec!["not-a-cidr".into()],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
assert!(message(validate(&cfg).unwrap_err()).contains("not-a-cidr"));
|
||||
|
||||
let mut beta = peer("beta", "http://[fe80::1]:1984");
|
||||
beta.allow_plain_http = true;
|
||||
let cfg = PeersConfig {
|
||||
deny_cidrs: vec!["fe80::/10".into()],
|
||||
peer: vec![beta],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate(&cfg).unwrap_err());
|
||||
assert!(err.contains("deny_cidrs"), "{err}");
|
||||
assert!(err.contains("fe80::1"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ipv4_mapped_ipv6_literals_match_the_v4_deny_list() {
|
||||
let mut beta = peer("beta", "http://[::ffff:169.254.169.254]:80");
|
||||
beta.allow_plain_http = true;
|
||||
let cfg = PeersConfig {
|
||||
peer: vec![beta],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate(&cfg).unwrap_err());
|
||||
assert!(err.contains("deny_cidrs"), "{err}");
|
||||
|
||||
// The address form the connector sees is matched the same way.
|
||||
let deny = deny_networks(&cfg.deny_cidrs).unwrap();
|
||||
assert!(denied("::ffff:169.254.169.254".parse().unwrap(), &deny));
|
||||
assert!(denied("169.254.169.254".parse().unwrap(), &deny));
|
||||
assert!(!denied("::ffff:10.0.0.1".parse().unwrap(), &deny));
|
||||
|
||||
// Same for loopback: a mapped literal is loopback, so plain http is
|
||||
// allowed without the flag.
|
||||
let cfg = disabled_section(vec![peer("beta", "http://[::ffff:127.0.0.1]:1984")]);
|
||||
validate(&cfg).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_file_must_be_absolute_but_is_not_opened_by_structural_checks() {
|
||||
let mut relative = peer("beta", "https://beta:1984");
|
||||
relative.token_file = PathBuf::from("peer-beta");
|
||||
let err = message(validate(&disabled_section(vec![relative])).unwrap_err());
|
||||
assert!(err.contains("beta"));
|
||||
assert!(err.contains("absolute"));
|
||||
|
||||
// A missing credential is not a config error: token management,
|
||||
// `peer list` and `--print-config` load this config successfully.
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![peer("beta", "https://beta:1984")],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
validate(&cfg).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_readiness_is_checked_only_for_peers_that_are_contacted() {
|
||||
let mut cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![peer("beta", "https://beta:1984")],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate_tokens(&cfg).unwrap_err());
|
||||
assert!(err.contains("peer beta"), "{err}");
|
||||
assert!(err.contains("not readable"), "{err}");
|
||||
|
||||
cfg.peer[0].enabled = false;
|
||||
validate_tokens(&cfg).unwrap();
|
||||
|
||||
cfg.enabled = false;
|
||||
cfg.peer[0].enabled = true;
|
||||
validate_tokens(&cfg).unwrap();
|
||||
|
||||
let dir = TempDir::new("peer-cfg");
|
||||
cfg.enabled = true;
|
||||
cfg.peer[0].token_file = dir.write_token("pending\n");
|
||||
validate_tokens(&cfg).unwrap();
|
||||
validate_peer_token(&cfg.peer[0]).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ca_file_must_be_absolute_when_set() {
|
||||
let mut beta = peer("beta", "https://beta:1984");
|
||||
beta.ca_file = Some(PathBuf::from("ca.pem"));
|
||||
let err = message(validate(&disabled_section(vec![beta])).unwrap_err());
|
||||
assert!(err.contains("ca_file"));
|
||||
assert!(err.contains("beta"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_readiness_rejects_an_empty_token_file() {
|
||||
let dir = TempDir::new("peer-cfg");
|
||||
let mut beta = peer("beta", "http://127.0.0.1:1984");
|
||||
beta.token_file = dir.write_token("");
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
peer: vec![beta],
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let err = message(validate_tokens(&cfg).unwrap_err());
|
||||
assert!(err.contains("peer beta"), "{err}");
|
||||
assert!(err.contains("empty"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enabled_with_no_peers_warns_and_is_not_an_error() {
|
||||
let cfg = PeersConfig {
|
||||
enabled: true,
|
||||
..PeersConfig::default()
|
||||
};
|
||||
let logs = logged(|| validate(&cfg).unwrap());
|
||||
assert!(logs.contains("no peers are configured"), "{logs}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loopback_detection_covers_localhost_and_both_families() {
|
||||
assert!(url_is_loopback(
|
||||
&Url::parse("http://LOCALHOST:1984").unwrap()
|
||||
));
|
||||
assert!(url_is_loopback(
|
||||
&Url::parse("http://127.0.0.2:1984").unwrap()
|
||||
));
|
||||
assert!(url_is_loopback(&Url::parse("http://[::1]:1984").unwrap()));
|
||||
assert!(url_is_loopback(
|
||||
&Url::parse("http://[::ffff:127.0.0.1]:1984").unwrap()
|
||||
));
|
||||
assert!(!url_is_loopback(
|
||||
&Url::parse("http://10.0.0.1:1984").unwrap()
|
||||
));
|
||||
assert!(!url_is_loopback(&Url::parse("http://beta:1984").unwrap()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_default_deny_list_covers_metadata_in_both_families_but_allows_lans() {
|
||||
let deny = deny_networks(&PeersConfig::default().deny_cidrs).unwrap();
|
||||
for refused in [
|
||||
"169.254.169.254",
|
||||
"0.0.0.0",
|
||||
"fe80::1",
|
||||
"::",
|
||||
"fd00:ec2::254",
|
||||
"::ffff:169.254.169.254",
|
||||
] {
|
||||
assert!(denied(refused.parse().unwrap(), &deny), "{refused}");
|
||||
}
|
||||
for allowed in [
|
||||
"10.1.2.3",
|
||||
"192.168.1.10",
|
||||
"::1",
|
||||
"fd00:1::5",
|
||||
"2001:db8::1",
|
||||
] {
|
||||
assert!(!denied(allowed.parse().unwrap(), &deny), "{allowed}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deny_networks_rejects_a_bad_cidr_once_for_every_caller() {
|
||||
assert!(deny_networks(&["10.0.0.0/8".into()]).is_ok());
|
||||
let err = deny_networks(&["nope".into()]).unwrap_err();
|
||||
assert!(message(err).contains("peers.deny_cidrs"));
|
||||
}
|
||||
+2
-107
@@ -88,110 +88,5 @@ pub fn peer_error_to_app(peer: &PeerName, e: &PeerError) -> AppError {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn name() -> PeerName {
|
||||
PeerName::parse("beta").unwrap()
|
||||
}
|
||||
|
||||
/// Every peer failure reaches REST and MCP with the same class.
|
||||
#[test]
|
||||
fn mapping_table() {
|
||||
let rows = [
|
||||
(
|
||||
PeerError::NotFound,
|
||||
"not_found",
|
||||
"peer beta: not found on peer",
|
||||
),
|
||||
(
|
||||
PeerError::BadRequest("bad limit".into()),
|
||||
"bad_request",
|
||||
"peer beta: bad limit",
|
||||
),
|
||||
(
|
||||
PeerError::Rejected,
|
||||
"unavailable",
|
||||
"peer beta: peer rejected credentials",
|
||||
),
|
||||
(PeerError::Timeout, "unavailable", "peer beta: timeout"),
|
||||
(
|
||||
PeerError::Unreachable,
|
||||
"unavailable",
|
||||
"peer beta: unreachable",
|
||||
),
|
||||
(PeerError::Dns, "unavailable", "peer beta: dns"),
|
||||
(PeerError::Tls, "unavailable", "peer beta: tls_error"),
|
||||
(PeerError::Http(502), "unavailable", "peer beta: http_502"),
|
||||
(PeerError::Oversize, "unavailable", "peer beta: oversize"),
|
||||
(PeerError::Saturated, "unavailable", "peer beta: saturated"),
|
||||
(
|
||||
PeerError::TokenFile("missing".into()),
|
||||
"unavailable",
|
||||
"peer beta: token_file",
|
||||
),
|
||||
(
|
||||
PeerError::Malformed("not json".into()),
|
||||
"internal",
|
||||
"peer beta: malformed response",
|
||||
),
|
||||
];
|
||||
for (err, code, message) in rows {
|
||||
let app = peer_error_to_app(&name(), &err);
|
||||
assert_eq!(app.code(), code, "{err:?}");
|
||||
assert_eq!(app.message(), message, "{err:?}");
|
||||
assert_ne!(
|
||||
app.status(),
|
||||
axum::http::StatusCode::UNAUTHORIZED,
|
||||
"{err:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_is_never_unauthorized() {
|
||||
let app = peer_error_to_app(&name(), &PeerError::Rejected);
|
||||
assert_eq!(app.status(), axum::http::StatusCode::SERVICE_UNAVAILABLE);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_file_detail_never_leaks() {
|
||||
let app = peer_error_to_app(
|
||||
&name(),
|
||||
&PeerError::TokenFile("/run/credentials/secret".into()),
|
||||
);
|
||||
assert!(!format!("{app:?}").contains("/run/credentials"));
|
||||
assert!(!app.message().contains("/run/credentials"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_request_class_string_drops_the_peer_message() {
|
||||
let msg = "http://peer.example/path?token=abc";
|
||||
let err = PeerError::BadRequest(msg.into());
|
||||
assert_eq!(err.class_str(), "bad_request");
|
||||
assert!(!err.class_str().contains("http://"));
|
||||
assert!(!err.class_str().contains("token"));
|
||||
let app = peer_error_to_app(&name(), &err);
|
||||
assert_eq!(app.message(), format!("peer beta: {msg}"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_config_error_is_the_process_config_error() {
|
||||
let err: PeerConfigError = crate::config::ConfigError::Invalid("peers".into());
|
||||
assert!(matches!(err, crate::config::ConfigError::Invalid(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn coarse_class() {
|
||||
assert_eq!(PeerError::Rejected.class(), CheckClass::Unauthorized);
|
||||
assert_eq!(PeerError::Timeout.class(), CheckClass::Timeout);
|
||||
assert_eq!(PeerError::Dns.class(), CheckClass::Unreachable);
|
||||
assert_eq!(PeerError::Saturated.class(), CheckClass::Unreachable);
|
||||
assert_eq!(PeerError::Http(500).class(), CheckClass::HttpError);
|
||||
assert_eq!(
|
||||
PeerError::Malformed("x".into()).class(),
|
||||
CheckClass::HttpError
|
||||
);
|
||||
assert_eq!(PeerError::Tls.class(), CheckClass::TlsError);
|
||||
}
|
||||
}
|
||||
#[path = "error_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,105 @@
|
||||
use super::*;
|
||||
|
||||
fn name() -> PeerName {
|
||||
PeerName::parse("beta").unwrap()
|
||||
}
|
||||
|
||||
/// Every peer failure reaches REST and MCP with the same class.
|
||||
#[test]
|
||||
fn mapping_table() {
|
||||
let rows = [
|
||||
(
|
||||
PeerError::NotFound,
|
||||
"not_found",
|
||||
"peer beta: not found on peer",
|
||||
),
|
||||
(
|
||||
PeerError::BadRequest("bad limit".into()),
|
||||
"bad_request",
|
||||
"peer beta: bad limit",
|
||||
),
|
||||
(
|
||||
PeerError::Rejected,
|
||||
"unavailable",
|
||||
"peer beta: peer rejected credentials",
|
||||
),
|
||||
(PeerError::Timeout, "unavailable", "peer beta: timeout"),
|
||||
(
|
||||
PeerError::Unreachable,
|
||||
"unavailable",
|
||||
"peer beta: unreachable",
|
||||
),
|
||||
(PeerError::Dns, "unavailable", "peer beta: dns"),
|
||||
(PeerError::Tls, "unavailable", "peer beta: tls_error"),
|
||||
(PeerError::Http(502), "unavailable", "peer beta: http_502"),
|
||||
(PeerError::Oversize, "unavailable", "peer beta: oversize"),
|
||||
(PeerError::Saturated, "unavailable", "peer beta: saturated"),
|
||||
(
|
||||
PeerError::TokenFile("missing".into()),
|
||||
"unavailable",
|
||||
"peer beta: token_file",
|
||||
),
|
||||
(
|
||||
PeerError::Malformed("not json".into()),
|
||||
"internal",
|
||||
"peer beta: malformed response",
|
||||
),
|
||||
];
|
||||
for (err, code, message) in rows {
|
||||
let app = peer_error_to_app(&name(), &err);
|
||||
assert_eq!(app.code(), code, "{err:?}");
|
||||
assert_eq!(app.message(), message, "{err:?}");
|
||||
assert_ne!(
|
||||
app.status(),
|
||||
axum::http::StatusCode::UNAUTHORIZED,
|
||||
"{err:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejected_is_never_unauthorized() {
|
||||
let app = peer_error_to_app(&name(), &PeerError::Rejected);
|
||||
assert_eq!(app.status(), axum::http::StatusCode::SERVICE_UNAVAILABLE);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_file_detail_never_leaks() {
|
||||
let app = peer_error_to_app(
|
||||
&name(),
|
||||
&PeerError::TokenFile("/run/credentials/secret".into()),
|
||||
);
|
||||
assert!(!format!("{app:?}").contains("/run/credentials"));
|
||||
assert!(!app.message().contains("/run/credentials"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_request_class_string_drops_the_peer_message() {
|
||||
let msg = "http://peer.example/path?token=abc";
|
||||
let err = PeerError::BadRequest(msg.into());
|
||||
assert_eq!(err.class_str(), "bad_request");
|
||||
assert!(!err.class_str().contains("http://"));
|
||||
assert!(!err.class_str().contains("token"));
|
||||
let app = peer_error_to_app(&name(), &err);
|
||||
assert_eq!(app.message(), format!("peer beta: {msg}"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_config_error_is_the_process_config_error() {
|
||||
let err: PeerConfigError = crate::config::ConfigError::Invalid("peers".into());
|
||||
assert!(matches!(err, crate::config::ConfigError::Invalid(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn coarse_class() {
|
||||
assert_eq!(PeerError::Rejected.class(), CheckClass::Unauthorized);
|
||||
assert_eq!(PeerError::Timeout.class(), CheckClass::Timeout);
|
||||
assert_eq!(PeerError::Dns.class(), CheckClass::Unreachable);
|
||||
assert_eq!(PeerError::Saturated.class(), CheckClass::Unreachable);
|
||||
assert_eq!(PeerError::Http(500).class(), CheckClass::HttpError);
|
||||
assert_eq!(
|
||||
PeerError::Malformed("x".into()).class(),
|
||||
CheckClass::HttpError
|
||||
);
|
||||
assert_eq!(PeerError::Tls.class(), CheckClass::TlsError);
|
||||
}
|
||||
+2
-267
@@ -370,270 +370,5 @@ pub async fn run_peer(
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::peers::testing::{fake_peers_config, FakeTransport};
|
||||
|
||||
fn cfg() -> PeersConfig {
|
||||
fake_peers_config(&["beta"])
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn healthy_peer() {
|
||||
let fake = FakeTransport::new();
|
||||
let cfg = cfg();
|
||||
let (server, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(server.up);
|
||||
assert_eq!(server.latency_ms, Some(1));
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Ok);
|
||||
assert_eq!(api.peer_version.as_deref(), Some("0.0.0-fake"));
|
||||
assert_eq!(fake.calls().len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejected_credentials_still_mean_api_up() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Rejected);
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Rejected);
|
||||
assert_eq!(api.last_error.as_deref(), Some("unauthorized"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_401_status_is_rejected_not_down() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/ping", 401, "application/json", "{}");
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Rejected);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn older_peer_falls_back_to_healthz_with_unknown_auth() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/ping", 404, "application/json", "{}")
|
||||
.respond("/healthz", 200, "application/json", r#"{"status":"ok"}"#);
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Unknown);
|
||||
let paths: Vec<_> = fake.calls().into_iter().map(|(_, r)| r.path).collect();
|
||||
assert_eq!(paths, ["/api/v1/ping", "/healthz"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn down_peer_reports_class() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").tcp(Err(PeerError::Timeout));
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Timeout);
|
||||
let cfg = cfg();
|
||||
let (server, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(!server.up);
|
||||
assert_eq!(server.last_error.as_deref(), Some("timeout"));
|
||||
assert!(!api.up);
|
||||
assert_eq!(api.auth, AuthState::Unknown);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn bad_request_last_error_is_a_class_string() {
|
||||
let leaked = "http://10.1.2.3/path?token=abc";
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::BadRequest(leaked.into()));
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(api.last_error.as_deref(), Some("bad_request"));
|
||||
let stored = api.last_error.unwrap();
|
||||
assert!(!stored.contains("token"));
|
||||
assert!(!stored.contains("http://"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn threshold_needs_consecutive_failures_and_recovers_immediately() {
|
||||
let mut server = ServerTracker::seeded(&ServerStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let ok = Duration::from_millis(2);
|
||||
let first = server.record(Ok(ok), t0, 2);
|
||||
assert!(first.up);
|
||||
assert_eq!(first.since, Some(t0));
|
||||
let since_up = first.since;
|
||||
|
||||
let t1 = t0 + Duration::from_secs(1);
|
||||
let still_up = server.record(Err(PeerError::Timeout), t1, 2);
|
||||
assert!(still_up.up, "one failure below the threshold");
|
||||
assert_eq!(still_up.since, since_up);
|
||||
assert_eq!(still_up.last_error.as_deref(), Some("timeout"));
|
||||
|
||||
let t2 = t0 + Duration::from_secs(2);
|
||||
let down = server.record(Err(PeerError::Timeout), t2, 2);
|
||||
assert!(!down.up);
|
||||
assert_eq!(down.since, Some(t2));
|
||||
|
||||
let t3 = t0 + Duration::from_secs(3);
|
||||
let back = server.record(Ok(ok), t3, 2);
|
||||
assert!(back.up, "recovery does not wait for a threshold");
|
||||
assert_eq!(back.since, Some(t3));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_failed_check_still_records_a_since() {
|
||||
let mut server = ServerTracker::seeded(&ServerStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let st = server.record(Err(PeerError::Unreachable), t0, 2);
|
||||
assert!(!st.up);
|
||||
assert_eq!(st.since, Some(t0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn api_tracker_keeps_auth_when_up_and_clears_it_when_down() {
|
||||
let mut api = ApiTracker::seeded(&ApiStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let up = api.record(
|
||||
ApiObservation::running(AuthState::Rejected, Duration::from_millis(3), None),
|
||||
t0,
|
||||
2,
|
||||
);
|
||||
assert!(up.up);
|
||||
assert_eq!(up.auth, AuthState::Rejected);
|
||||
assert_eq!(up.last_error.as_deref(), Some("unauthorized"));
|
||||
|
||||
let t1 = t0 + Duration::from_secs(1);
|
||||
let down = api.record(ApiObservation::down(&PeerError::Unreachable), t1, 1);
|
||||
assert!(!down.up);
|
||||
assert_eq!(down.auth, AuthState::Unknown);
|
||||
assert_eq!(down.peer_version, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failure_below_the_threshold_keeps_the_known_peer_version() {
|
||||
let mut api = ApiTracker::seeded(&ApiStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let up = api.record(
|
||||
ApiObservation::running(
|
||||
AuthState::Ok,
|
||||
Duration::from_millis(1),
|
||||
Some("1.2.3".into()),
|
||||
),
|
||||
t0,
|
||||
2,
|
||||
);
|
||||
assert_eq!(up.peer_version.as_deref(), Some("1.2.3"));
|
||||
|
||||
let t1 = t0 + Duration::from_secs(1);
|
||||
let still_up = api.record(ApiObservation::down(&PeerError::Timeout), t1, 2);
|
||||
assert!(still_up.up);
|
||||
assert_eq!(still_up.peer_version.as_deref(), Some("1.2.3"));
|
||||
|
||||
let t2 = t0 + Duration::from_secs(2);
|
||||
let down = api.record(ApiObservation::down(&PeerError::Timeout), t2, 2);
|
||||
assert!(!down.up);
|
||||
assert_eq!(down.peer_version, None);
|
||||
}
|
||||
|
||||
struct SlowHealthz;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PeerTransport for SlowHealthz {
|
||||
async fn tcp_check(
|
||||
&self,
|
||||
_peer: &PeerConfig,
|
||||
_timeout: Duration,
|
||||
) -> Result<Duration, PeerError> {
|
||||
Ok(Duration::ZERO)
|
||||
}
|
||||
|
||||
async fn get(
|
||||
&self,
|
||||
_peer: &PeerConfig,
|
||||
req: PeerRequest,
|
||||
_timeout: Duration,
|
||||
) -> Result<PeerResponse, PeerError> {
|
||||
match req.path.as_str() {
|
||||
"/api/v1/ping" => Ok(PeerResponse {
|
||||
status: 404,
|
||||
content_type: None,
|
||||
body: PeerBody::Bytes(bytes::Bytes::new()),
|
||||
}),
|
||||
_ => {
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
Ok(PeerResponse {
|
||||
status: 200,
|
||||
content_type: None,
|
||||
body: PeerBody::Bytes(bytes::Bytes::from_static(br#"{"status":"ok"}"#)),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn healthz_fallback_reports_its_own_latency() {
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
&SlowHealthz,
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert!(
|
||||
api.latency_ms.unwrap() >= 25,
|
||||
"healthz call latency, not the ping's: {:?}",
|
||||
api.latency_ms
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn jitter_is_bounded_and_stable() {
|
||||
let interval = Duration::from_secs(10);
|
||||
let name = PeerName::parse("beta").unwrap();
|
||||
let j = start_jitter(&name, interval);
|
||||
assert!(j < interval / 3, "{j:?}");
|
||||
assert_eq!(j, start_jitter(&name, interval));
|
||||
}
|
||||
}
|
||||
#[path = "health_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,265 @@
|
||||
use super::*;
|
||||
use crate::peers::testing::{fake_peers_config, FakeTransport};
|
||||
|
||||
fn cfg() -> PeersConfig {
|
||||
fake_peers_config(&["beta"])
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn healthy_peer() {
|
||||
let fake = FakeTransport::new();
|
||||
let cfg = cfg();
|
||||
let (server, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(server.up);
|
||||
assert_eq!(server.latency_ms, Some(1));
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Ok);
|
||||
assert_eq!(api.peer_version.as_deref(), Some("0.0.0-fake"));
|
||||
assert_eq!(fake.calls().len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejected_credentials_still_mean_api_up() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Rejected);
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Rejected);
|
||||
assert_eq!(api.last_error.as_deref(), Some("unauthorized"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_401_status_is_rejected_not_down() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/ping", 401, "application/json", "{}");
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Rejected);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn older_peer_falls_back_to_healthz_with_unknown_auth() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/ping", 404, "application/json", "{}")
|
||||
.respond("/healthz", 200, "application/json", r#"{"status":"ok"}"#);
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert_eq!(api.auth, AuthState::Unknown);
|
||||
let paths: Vec<_> = fake.calls().into_iter().map(|(_, r)| r.path).collect();
|
||||
assert_eq!(paths, ["/api/v1/ping", "/healthz"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn down_peer_reports_class() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").tcp(Err(PeerError::Timeout));
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::Timeout);
|
||||
let cfg = cfg();
|
||||
let (server, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(!server.up);
|
||||
assert_eq!(server.last_error.as_deref(), Some("timeout"));
|
||||
assert!(!api.up);
|
||||
assert_eq!(api.auth, AuthState::Unknown);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn bad_request_last_error_is_a_class_string() {
|
||||
let leaked = "http://10.1.2.3/path?token=abc";
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", PeerError::BadRequest(leaked.into()));
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
fake.as_ref(),
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(api.last_error.as_deref(), Some("bad_request"));
|
||||
let stored = api.last_error.unwrap();
|
||||
assert!(!stored.contains("token"));
|
||||
assert!(!stored.contains("http://"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn threshold_needs_consecutive_failures_and_recovers_immediately() {
|
||||
let mut server = ServerTracker::seeded(&ServerStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let ok = Duration::from_millis(2);
|
||||
let first = server.record(Ok(ok), t0, 2);
|
||||
assert!(first.up);
|
||||
assert_eq!(first.since, Some(t0));
|
||||
let since_up = first.since;
|
||||
|
||||
let t1 = t0 + Duration::from_secs(1);
|
||||
let still_up = server.record(Err(PeerError::Timeout), t1, 2);
|
||||
assert!(still_up.up, "one failure below the threshold");
|
||||
assert_eq!(still_up.since, since_up);
|
||||
assert_eq!(still_up.last_error.as_deref(), Some("timeout"));
|
||||
|
||||
let t2 = t0 + Duration::from_secs(2);
|
||||
let down = server.record(Err(PeerError::Timeout), t2, 2);
|
||||
assert!(!down.up);
|
||||
assert_eq!(down.since, Some(t2));
|
||||
|
||||
let t3 = t0 + Duration::from_secs(3);
|
||||
let back = server.record(Ok(ok), t3, 2);
|
||||
assert!(back.up, "recovery does not wait for a threshold");
|
||||
assert_eq!(back.since, Some(t3));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_failed_check_still_records_a_since() {
|
||||
let mut server = ServerTracker::seeded(&ServerStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let st = server.record(Err(PeerError::Unreachable), t0, 2);
|
||||
assert!(!st.up);
|
||||
assert_eq!(st.since, Some(t0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn api_tracker_keeps_auth_when_up_and_clears_it_when_down() {
|
||||
let mut api = ApiTracker::seeded(&ApiStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let up = api.record(
|
||||
ApiObservation::running(AuthState::Rejected, Duration::from_millis(3), None),
|
||||
t0,
|
||||
2,
|
||||
);
|
||||
assert!(up.up);
|
||||
assert_eq!(up.auth, AuthState::Rejected);
|
||||
assert_eq!(up.last_error.as_deref(), Some("unauthorized"));
|
||||
|
||||
let t1 = t0 + Duration::from_secs(1);
|
||||
let down = api.record(ApiObservation::down(&PeerError::Unreachable), t1, 1);
|
||||
assert!(!down.up);
|
||||
assert_eq!(down.auth, AuthState::Unknown);
|
||||
assert_eq!(down.peer_version, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failure_below_the_threshold_keeps_the_known_peer_version() {
|
||||
let mut api = ApiTracker::seeded(&ApiStatus::default());
|
||||
let t0 = Timestamp::now();
|
||||
let up = api.record(
|
||||
ApiObservation::running(
|
||||
AuthState::Ok,
|
||||
Duration::from_millis(1),
|
||||
Some("1.2.3".into()),
|
||||
),
|
||||
t0,
|
||||
2,
|
||||
);
|
||||
assert_eq!(up.peer_version.as_deref(), Some("1.2.3"));
|
||||
|
||||
let t1 = t0 + Duration::from_secs(1);
|
||||
let still_up = api.record(ApiObservation::down(&PeerError::Timeout), t1, 2);
|
||||
assert!(still_up.up);
|
||||
assert_eq!(still_up.peer_version.as_deref(), Some("1.2.3"));
|
||||
|
||||
let t2 = t0 + Duration::from_secs(2);
|
||||
let down = api.record(ApiObservation::down(&PeerError::Timeout), t2, 2);
|
||||
assert!(!down.up);
|
||||
assert_eq!(down.peer_version, None);
|
||||
}
|
||||
|
||||
struct SlowHealthz;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl PeerTransport for SlowHealthz {
|
||||
async fn tcp_check(
|
||||
&self,
|
||||
_peer: &PeerConfig,
|
||||
_timeout: Duration,
|
||||
) -> Result<Duration, PeerError> {
|
||||
Ok(Duration::ZERO)
|
||||
}
|
||||
|
||||
async fn get(
|
||||
&self,
|
||||
_peer: &PeerConfig,
|
||||
req: PeerRequest,
|
||||
_timeout: Duration,
|
||||
) -> Result<PeerResponse, PeerError> {
|
||||
match req.path.as_str() {
|
||||
"/api/v1/ping" => Ok(PeerResponse {
|
||||
status: 404,
|
||||
content_type: None,
|
||||
body: PeerBody::Bytes(bytes::Bytes::new()),
|
||||
}),
|
||||
_ => {
|
||||
tokio::time::sleep(Duration::from_millis(30)).await;
|
||||
Ok(PeerResponse {
|
||||
status: 200,
|
||||
content_type: None,
|
||||
body: PeerBody::Bytes(bytes::Bytes::from_static(br#"{"status":"ok"}"#)),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn healthz_fallback_reports_its_own_latency() {
|
||||
let cfg = cfg();
|
||||
let (_, api) = check_once(
|
||||
&SlowHealthz,
|
||||
&cfg.peer[0],
|
||||
Duration::from_secs(1),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await;
|
||||
assert!(api.up);
|
||||
assert!(
|
||||
api.latency_ms.unwrap() >= 25,
|
||||
"healthz call latency, not the ping's: {:?}",
|
||||
api.latency_ms
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn jitter_is_bounded_and_stable() {
|
||||
let interval = Duration::from_secs(10);
|
||||
let name = PeerName::parse("beta").unwrap();
|
||||
let j = start_jitter(&name, interval);
|
||||
assert!(j < interval / 3, "{j:?}");
|
||||
assert_eq!(j, start_jitter(&name, interval));
|
||||
}
|
||||
+2
-513
@@ -421,516 +421,5 @@ fn route_is_follow(route: &str, query: &[(String, String)]) -> bool {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::peers::testing::{fake_peers_config, FakeTransport};
|
||||
use futures::StreamExt;
|
||||
|
||||
fn peer_cfg() -> PeerConfig {
|
||||
fake_peers_config(&["beta"]).peer.remove(0)
|
||||
}
|
||||
|
||||
fn header_of<'a>(req: &'a PeerRequest, name: &str) -> Option<&'a str> {
|
||||
req.headers
|
||||
.iter()
|
||||
.find(|(k, _)| k.as_str() == name)
|
||||
.map(|(_, v)| v.to_str().unwrap())
|
||||
}
|
||||
|
||||
async fn get_with(
|
||||
fake: &FakeTransport,
|
||||
peer: &PeerConfig,
|
||||
path: &str,
|
||||
query: &[(String, String)],
|
||||
) -> Result<PeerResponse, AppError> {
|
||||
get(
|
||||
fake,
|
||||
peer,
|
||||
path,
|
||||
query,
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
fn forwarded(fake: &FakeTransport) -> Vec<String> {
|
||||
fake.calls().into_iter().map(|(_, req)| req.path).collect()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn adds_hop_and_trace_context_but_no_credentials() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
let opts = ProxyOpts {
|
||||
traceparent: Some("00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01".into()),
|
||||
accept_sse: true,
|
||||
};
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/journal/follow",
|
||||
&[("lines".into(), "10".into())],
|
||||
opts,
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let calls = fake.calls();
|
||||
assert_eq!(calls.len(), 1);
|
||||
let req = &calls[0].1;
|
||||
assert_eq!(req.path, "/api/v1/journal/follow");
|
||||
assert_eq!(req.query, vec![("lines".to_owned(), "10".to_owned())]);
|
||||
assert_eq!(req.accept.as_deref(), Some("text/event-stream"));
|
||||
assert_eq!(header_of(req, "x-slinuxm-hop"), Some("1"));
|
||||
assert!(header_of(req, "traceparent").unwrap().starts_with("00-"));
|
||||
assert_eq!(header_of(req, "authorization"), None);
|
||||
assert_eq!(header_of(req, "cookie"), None);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn maps_rejected_with_peer_name() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/systemd/units", PeerError::Rejected);
|
||||
let err = get_with(fake.as_ref(), &peer_cfg(), "/systemd/units", &[])
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "unavailable");
|
||||
assert_eq!(err.message(), "peer beta: peer rejected credentials");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn allowlist_forwards_documented_routes_only() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
let ok = [
|
||||
"/systemd/units",
|
||||
"systemd/units/nginx.service",
|
||||
"/systemd/timers",
|
||||
"/journal",
|
||||
"/journal/follow",
|
||||
"/docker/ps",
|
||||
"/docker/containers/web",
|
||||
"/docker/containers/web/logs",
|
||||
"/api/v1/systemd/units",
|
||||
"systemd/units/user@100.service",
|
||||
// Names the local route accepts must pass here too: `-` roots and
|
||||
// escaped unit names, as text and percent-encoded.
|
||||
"systemd/units/-.mount",
|
||||
"/systemd/units/-.slice",
|
||||
"systemd/units/foo\\x2dbar.mount",
|
||||
"systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
"systemd/units/dev-disk-by%5cx2did.device",
|
||||
// A `..` inside a name is not traversal: segments cannot contain
|
||||
// a slash and the forwarded path is re-encoded from them.
|
||||
"systemd/units/foo..bar.mount",
|
||||
"/docker/containers/foo..bar",
|
||||
];
|
||||
for path in ok {
|
||||
get_with(fake.as_ref(), &peer, path, &[]).await.unwrap();
|
||||
}
|
||||
assert_eq!(
|
||||
forwarded(&fake),
|
||||
vec![
|
||||
"/api/v1/systemd/units",
|
||||
"/api/v1/systemd/units/nginx.service",
|
||||
"/api/v1/systemd/timers",
|
||||
"/api/v1/journal",
|
||||
"/api/v1/journal/follow",
|
||||
"/api/v1/docker/ps",
|
||||
"/api/v1/docker/containers/web",
|
||||
"/api/v1/docker/containers/web/logs",
|
||||
"/api/v1/systemd/units",
|
||||
"/api/v1/systemd/units/user@100.service",
|
||||
"/api/v1/systemd/units/-.mount",
|
||||
"/api/v1/systemd/units/-.slice",
|
||||
"/api/v1/systemd/units/foo%5Cx2dbar.mount",
|
||||
"/api/v1/systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
"/api/v1/systemd/units/dev-disk-by%5Cx2did.device",
|
||||
"/api/v1/systemd/units/foo..bar.mount",
|
||||
"/api/v1/docker/containers/foo..bar",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unit_names_are_forwarded_in_one_normalised_form() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
for path in [
|
||||
"systemd/units/-.mount",
|
||||
"systemd/units/foo\\x2dbar.mount",
|
||||
"systemd/units/foo%5cx2dbar.mount",
|
||||
"/api/v1/systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
] {
|
||||
get_with(fake.as_ref(), &peer, path, &[]).await.unwrap();
|
||||
}
|
||||
assert_eq!(
|
||||
forwarded(&fake),
|
||||
vec![
|
||||
"/api/v1/systemd/units/-.mount",
|
||||
"/api/v1/systemd/units/foo%5Cx2dbar.mount",
|
||||
"/api/v1/systemd/units/foo%5Cx2dbar.mount",
|
||||
"/api/v1/systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepared_response_maps_status_and_checks_the_body() {
|
||||
let name = PeerName::parse("beta").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
let prepare = |status: u16, content_type: Option<&str>, body: &'static [u8]| {
|
||||
prepare_response(
|
||||
&name,
|
||||
PeerResponse {
|
||||
status,
|
||||
content_type: content_type.map(str::to_owned),
|
||||
body: PeerBody::Bytes(Bytes::from_static(body)),
|
||||
},
|
||||
4,
|
||||
deadline,
|
||||
CancellationToken::new(),
|
||||
)
|
||||
};
|
||||
|
||||
let ok = prepare(200, Some("application/json"), b"{}").unwrap();
|
||||
assert_eq!(ok.status, StatusCode::OK);
|
||||
assert_eq!(ok.content_type.unwrap(), "application/json");
|
||||
|
||||
let rows = [
|
||||
(404, "not_found", "peer beta: not found on peer"),
|
||||
(401, "unavailable", "peer beta: peer rejected credentials"),
|
||||
(403, "unavailable", "peer beta: peer rejected credentials"),
|
||||
(500, "unavailable", "peer beta: http_500"),
|
||||
(302, "unavailable", "peer beta: http_302"),
|
||||
(999, "unavailable", "peer beta: http_999"),
|
||||
];
|
||||
for (status, code, message) in rows {
|
||||
let err = match prepare(status, None, b"") {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("status {status} must not pass through"),
|
||||
};
|
||||
assert_eq!(err.code(), code, "{status}");
|
||||
assert_eq!(err.message(), message, "{status}");
|
||||
}
|
||||
|
||||
let err = match prepare(200, None, b"0123456789") {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("oversize body must not pass through"),
|
||||
};
|
||||
assert_eq!(err.message(), "peer beta: oversize");
|
||||
|
||||
let err = match prepare(200, Some("application/json\r\nX-Injected: 1"), b"{}") {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("smuggled content type must not pass through"),
|
||||
};
|
||||
assert_eq!(err.message(), "peer beta: malformed response");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejects_traversal_excluded_routes_and_bad_query_without_calling() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/systemd/units", 200, "application/json", "{}")
|
||||
.respond("/api/v1/journal/follow", 200, "application/json", "{}");
|
||||
let peer = peer_cfg();
|
||||
let bad_paths = [
|
||||
"/ping",
|
||||
"/api/v1/ping",
|
||||
"/peers/gamma/systemd/units",
|
||||
"/healthz",
|
||||
"/systemd",
|
||||
"/systemd/units/../timers",
|
||||
"/systemd/../docker/ps",
|
||||
"systemd/units/%2e%2e",
|
||||
"journal%2ffollow",
|
||||
"systemd/units/foo%2Fbar",
|
||||
"/systemd/units//nginx.service",
|
||||
"/docker/containers/a/b",
|
||||
"/journal/follow/extra",
|
||||
"",
|
||||
"/",
|
||||
"/systemd/units/%2e.",
|
||||
"systemd\\units",
|
||||
// A second encoding layer and control characters.
|
||||
"systemd%252ffollow",
|
||||
"systemd/units/foo%255cbar.mount",
|
||||
"systemd/units/nginx.service%00",
|
||||
"systemd/units/nginx.service%0a",
|
||||
"systemd/units/nginx%0d.service",
|
||||
"systemd/units/foo%25.service",
|
||||
"systemd/units/foo%zz.service",
|
||||
// An encoded `..` anywhere is a second encoding layer, even when
|
||||
// it sits inside one segment rather than being the segment.
|
||||
"systemd/units/foo%2e%2ebar.mount",
|
||||
// A backslash is only a legal character inside a unit name.
|
||||
"systemd%5cunits",
|
||||
"journal%5cfollow",
|
||||
"docker/containers/web%5cx2d1",
|
||||
];
|
||||
for path in bad_paths {
|
||||
let err = get_with(fake.as_ref(), &peer, path, &[]).await.unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request", "{path}");
|
||||
assert_eq!(err.message(), "peer beta: path not allowed", "{path}");
|
||||
}
|
||||
let bad_queries = [
|
||||
vec![("token".into(), "abc".into())],
|
||||
vec![
|
||||
("state".into(), "failed".into()),
|
||||
("lines".into(), "1".into()),
|
||||
],
|
||||
vec![
|
||||
("state".into(), "failed".into()),
|
||||
("state".into(), "active".into()),
|
||||
],
|
||||
vec![("State".into(), "failed".into())],
|
||||
vec![("state".into(), "a/b".into())],
|
||||
vec![("state".into(), "a%2fb".into())],
|
||||
vec![("state".into(), "..".into())],
|
||||
vec![("state".into(), "a%252fb".into())],
|
||||
vec![("state".into(), "a%255cb".into())],
|
||||
vec![("state".into(), "a%00b".into())],
|
||||
vec![("state".into(), "a%0ab".into())],
|
||||
vec![("state".into(), "a%0db".into())],
|
||||
];
|
||||
for query in bad_queries {
|
||||
let err = get_with(fake.as_ref(), &peer, "/systemd/units", &query)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request", "{query:?}");
|
||||
assert_eq!(err.message(), "peer beta: unsupported query parameter");
|
||||
}
|
||||
assert!(fake.calls().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn forwards_only_allowlisted_query_and_follow_accept() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/systemd/units",
|
||||
&[("state".into(), "failed".into())],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/docker/containers/web/logs",
|
||||
&[("tail".into(), "10".into()), ("follow".into(), "1".into())],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/docker/containers/web/logs",
|
||||
&[("follow".into(), "0".into())],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let calls = fake.calls();
|
||||
assert_eq!(calls[0].1.query, vec![("state".into(), "failed".into())]);
|
||||
assert!(calls[0].1.accept.is_none());
|
||||
assert_eq!(calls[1].1.accept.as_deref(), Some("text/event-stream"));
|
||||
assert!(calls[2].1.accept.is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn journal_unit_values_are_forwarded_like_the_local_route() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
// Raw text as an MCP caller would pass it, and the same values in a
|
||||
// request target: `%5C` and a literal backslash both decode to one
|
||||
// backslash, which is what systemd uses to escape a unit name.
|
||||
let raw_queries = [
|
||||
"unit=mnt-data%5Cx2dbackup.mount",
|
||||
"unit=mnt-data%5cx2dbackup.mount",
|
||||
"unit=mnt-data\\x2dbackup.mount",
|
||||
"unit=dev-disk-by%5Cx2did.device&priority=err",
|
||||
"unit=-.mount",
|
||||
"unit=user@100.service",
|
||||
];
|
||||
for raw in raw_queries {
|
||||
let query = query_from_raw("beta", Some(raw)).unwrap();
|
||||
get_with(fake.as_ref(), &peer, "/journal", &query)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
get_with(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/journal/follow",
|
||||
&[("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
fake.calls()
|
||||
.into_iter()
|
||||
.map(|(_, req)| req.query)
|
||||
.collect::<Vec<_>>(),
|
||||
vec![
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
vec![
|
||||
("unit".into(), "dev-disk-by\\x2did.device".into()),
|
||||
("priority".into(), "err".into()),
|
||||
],
|
||||
vec![("unit".into(), "-.mount".into())],
|
||||
vec![("unit".into(), "user@100.service".into())],
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn journal_unit_values_still_reject_unsafe_text() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
let bad = [
|
||||
// Not a unit name, so the local unit rule rejects it.
|
||||
"unit=../x",
|
||||
"unit=a/b",
|
||||
"unit=nginx",
|
||||
"unit=nginx.service%2fx",
|
||||
"unit=mnt-data%5Cx2d.mount%2e",
|
||||
"unit=mnt-data%0ax2d.mount",
|
||||
"unit=a%255cb.mount",
|
||||
];
|
||||
for raw in bad {
|
||||
// Some values are stopped while the raw query is parsed and the
|
||||
// rest by the allowlist; both are the same 400.
|
||||
let err = match query_from_raw("beta", Some(raw)) {
|
||||
Ok(query) => get_with(fake.as_ref(), &peer, "/journal", &query)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
Err(err) => err,
|
||||
};
|
||||
assert_eq!(err.code(), "bad_request", "{raw}");
|
||||
assert_eq!(
|
||||
err.message(),
|
||||
"peer beta: unsupported query parameter",
|
||||
"{raw}"
|
||||
);
|
||||
}
|
||||
// Values that reach the check already decoded (the MCP path) are
|
||||
// rejected there rather than by the raw parser.
|
||||
for value in [
|
||||
"mnt-data\u{0}x2d.mount",
|
||||
"mnt-data\nx2d.mount",
|
||||
"mnt-data\rx2d.mount",
|
||||
"mnt-data\x2d.mount/../../etc/passwd",
|
||||
] {
|
||||
let err = get_with(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/journal",
|
||||
&[("unit".into(), value.into())],
|
||||
)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request", "{value:?}");
|
||||
}
|
||||
assert!(fake.calls().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_classification_is_one_table() {
|
||||
assert!(matches!(classify_status(404), PeerError::NotFound));
|
||||
assert!(matches!(classify_status(401), PeerError::Rejected));
|
||||
assert!(matches!(classify_status(403), PeerError::Rejected));
|
||||
assert!(matches!(classify_status(302), PeerError::Http(302)));
|
||||
assert!(matches!(classify_status(200), PeerError::Http(200)));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn slow_peer_is_a_timeout() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").delay(Duration::from_secs(30));
|
||||
let err = get(
|
||||
fake.as_ref(),
|
||||
&peer_cfg(),
|
||||
"/systemd/units",
|
||||
&[],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_millis(20),
|
||||
)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.message(), "peer beta: timeout");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn inbound_hop_is_rejected() {
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(HOP_HEADER, HeaderValue::from_static("1"));
|
||||
let err = reject_inbound_hop("beta", &headers).unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request");
|
||||
assert_eq!(err.message(), "peer beta: chained requests are not allowed");
|
||||
headers.insert(HOP_HEADER, HeaderValue::from_static("0"));
|
||||
assert!(reject_inbound_hop("beta", &headers).is_err());
|
||||
assert!(reject_inbound_hop("beta", &HeaderMap::new()).is_ok());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn query_raw_rejects_encoded_slash() {
|
||||
let err = query_from_raw("beta", Some("state=failed&unit=a%2Fb")).unwrap_err();
|
||||
assert_eq!(err.message(), "peer beta: unsupported query parameter");
|
||||
let pairs = query_from_raw("beta", Some("state=failed")).unwrap();
|
||||
assert_eq!(pairs, vec![("state".into(), "failed".into())]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn body_cap_and_stream_stop_on_shutdown() {
|
||||
let name = PeerName::parse("beta").unwrap();
|
||||
let err = match prepare_body(
|
||||
&name,
|
||||
PeerBody::Bytes(Bytes::from_static(b"0123456789")),
|
||||
4,
|
||||
Instant::now() + Duration::from_secs(5),
|
||||
CancellationToken::new(),
|
||||
) {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("expected an oversize error"),
|
||||
};
|
||||
assert_eq!(err.message(), "peer beta: oversize");
|
||||
|
||||
let shutdown = CancellationToken::new();
|
||||
let stream = futures::stream::unfold(0u32, |n| async move {
|
||||
if n > 0 {
|
||||
tokio::time::sleep(Duration::from_secs(30)).await;
|
||||
}
|
||||
Some((
|
||||
Ok::<Bytes, PeerError>(Bytes::from(format!("data: {n}\n\n"))),
|
||||
n + 1,
|
||||
))
|
||||
});
|
||||
let PreparedBody::Stream(mut body) = prepare_body(
|
||||
&name,
|
||||
PeerBody::Stream(Box::pin(stream)),
|
||||
1024,
|
||||
Instant::now() + Duration::from_secs(30),
|
||||
shutdown.clone(),
|
||||
)
|
||||
.unwrap() else {
|
||||
panic!("expected a stream");
|
||||
};
|
||||
let first = body.next().await.unwrap().unwrap();
|
||||
assert_eq!(&first[..], b"data: 0\n\n");
|
||||
shutdown.cancel();
|
||||
assert!(body.next().await.is_none());
|
||||
}
|
||||
}
|
||||
#[path = "proxy_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,511 @@
|
||||
use super::*;
|
||||
use crate::peers::testing::{fake_peers_config, FakeTransport};
|
||||
use futures::StreamExt;
|
||||
|
||||
fn peer_cfg() -> PeerConfig {
|
||||
fake_peers_config(&["beta"]).peer.remove(0)
|
||||
}
|
||||
|
||||
fn header_of<'a>(req: &'a PeerRequest, name: &str) -> Option<&'a str> {
|
||||
req.headers
|
||||
.iter()
|
||||
.find(|(k, _)| k.as_str() == name)
|
||||
.map(|(_, v)| v.to_str().unwrap())
|
||||
}
|
||||
|
||||
async fn get_with(
|
||||
fake: &FakeTransport,
|
||||
peer: &PeerConfig,
|
||||
path: &str,
|
||||
query: &[(String, String)],
|
||||
) -> Result<PeerResponse, AppError> {
|
||||
get(
|
||||
fake,
|
||||
peer,
|
||||
path,
|
||||
query,
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
fn forwarded(fake: &FakeTransport) -> Vec<String> {
|
||||
fake.calls().into_iter().map(|(_, req)| req.path).collect()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn adds_hop_and_trace_context_but_no_credentials() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
let opts = ProxyOpts {
|
||||
traceparent: Some("00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01".into()),
|
||||
accept_sse: true,
|
||||
};
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/journal/follow",
|
||||
&[("lines".into(), "10".into())],
|
||||
opts,
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let calls = fake.calls();
|
||||
assert_eq!(calls.len(), 1);
|
||||
let req = &calls[0].1;
|
||||
assert_eq!(req.path, "/api/v1/journal/follow");
|
||||
assert_eq!(req.query, vec![("lines".to_owned(), "10".to_owned())]);
|
||||
assert_eq!(req.accept.as_deref(), Some("text/event-stream"));
|
||||
assert_eq!(header_of(req, "x-slinuxm-hop"), Some("1"));
|
||||
assert!(header_of(req, "traceparent").unwrap().starts_with("00-"));
|
||||
assert_eq!(header_of(req, "authorization"), None);
|
||||
assert_eq!(header_of(req, "cookie"), None);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn maps_rejected_with_peer_name() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/systemd/units", PeerError::Rejected);
|
||||
let err = get_with(fake.as_ref(), &peer_cfg(), "/systemd/units", &[])
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "unavailable");
|
||||
assert_eq!(err.message(), "peer beta: peer rejected credentials");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn allowlist_forwards_documented_routes_only() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
let ok = [
|
||||
"/systemd/units",
|
||||
"systemd/units/nginx.service",
|
||||
"/systemd/timers",
|
||||
"/journal",
|
||||
"/journal/follow",
|
||||
"/docker/ps",
|
||||
"/docker/containers/web",
|
||||
"/docker/containers/web/logs",
|
||||
"/api/v1/systemd/units",
|
||||
"systemd/units/user@100.service",
|
||||
// Names the local route accepts must pass here too: `-` roots and
|
||||
// escaped unit names, as text and percent-encoded.
|
||||
"systemd/units/-.mount",
|
||||
"/systemd/units/-.slice",
|
||||
"systemd/units/foo\\x2dbar.mount",
|
||||
"systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
"systemd/units/dev-disk-by%5cx2did.device",
|
||||
// A `..` inside a name is not traversal: segments cannot contain
|
||||
// a slash and the forwarded path is re-encoded from them.
|
||||
"systemd/units/foo..bar.mount",
|
||||
"/docker/containers/foo..bar",
|
||||
];
|
||||
for path in ok {
|
||||
get_with(fake.as_ref(), &peer, path, &[]).await.unwrap();
|
||||
}
|
||||
assert_eq!(
|
||||
forwarded(&fake),
|
||||
vec![
|
||||
"/api/v1/systemd/units",
|
||||
"/api/v1/systemd/units/nginx.service",
|
||||
"/api/v1/systemd/timers",
|
||||
"/api/v1/journal",
|
||||
"/api/v1/journal/follow",
|
||||
"/api/v1/docker/ps",
|
||||
"/api/v1/docker/containers/web",
|
||||
"/api/v1/docker/containers/web/logs",
|
||||
"/api/v1/systemd/units",
|
||||
"/api/v1/systemd/units/user@100.service",
|
||||
"/api/v1/systemd/units/-.mount",
|
||||
"/api/v1/systemd/units/-.slice",
|
||||
"/api/v1/systemd/units/foo%5Cx2dbar.mount",
|
||||
"/api/v1/systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
"/api/v1/systemd/units/dev-disk-by%5Cx2did.device",
|
||||
"/api/v1/systemd/units/foo..bar.mount",
|
||||
"/api/v1/docker/containers/foo..bar",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unit_names_are_forwarded_in_one_normalised_form() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
for path in [
|
||||
"systemd/units/-.mount",
|
||||
"systemd/units/foo\\x2dbar.mount",
|
||||
"systemd/units/foo%5cx2dbar.mount",
|
||||
"/api/v1/systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
] {
|
||||
get_with(fake.as_ref(), &peer, path, &[]).await.unwrap();
|
||||
}
|
||||
assert_eq!(
|
||||
forwarded(&fake),
|
||||
vec![
|
||||
"/api/v1/systemd/units/-.mount",
|
||||
"/api/v1/systemd/units/foo%5Cx2dbar.mount",
|
||||
"/api/v1/systemd/units/foo%5Cx2dbar.mount",
|
||||
"/api/v1/systemd/units/mnt-data%5Cx2dbackup.mount",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepared_response_maps_status_and_checks_the_body() {
|
||||
let name = PeerName::parse("beta").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
let prepare = |status: u16, content_type: Option<&str>, body: &'static [u8]| {
|
||||
prepare_response(
|
||||
&name,
|
||||
PeerResponse {
|
||||
status,
|
||||
content_type: content_type.map(str::to_owned),
|
||||
body: PeerBody::Bytes(Bytes::from_static(body)),
|
||||
},
|
||||
4,
|
||||
deadline,
|
||||
CancellationToken::new(),
|
||||
)
|
||||
};
|
||||
|
||||
let ok = prepare(200, Some("application/json"), b"{}").unwrap();
|
||||
assert_eq!(ok.status, StatusCode::OK);
|
||||
assert_eq!(ok.content_type.unwrap(), "application/json");
|
||||
|
||||
let rows = [
|
||||
(404, "not_found", "peer beta: not found on peer"),
|
||||
(401, "unavailable", "peer beta: peer rejected credentials"),
|
||||
(403, "unavailable", "peer beta: peer rejected credentials"),
|
||||
(500, "unavailable", "peer beta: http_500"),
|
||||
(302, "unavailable", "peer beta: http_302"),
|
||||
(999, "unavailable", "peer beta: http_999"),
|
||||
];
|
||||
for (status, code, message) in rows {
|
||||
let err = match prepare(status, None, b"") {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("status {status} must not pass through"),
|
||||
};
|
||||
assert_eq!(err.code(), code, "{status}");
|
||||
assert_eq!(err.message(), message, "{status}");
|
||||
}
|
||||
|
||||
let err = match prepare(200, None, b"0123456789") {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("oversize body must not pass through"),
|
||||
};
|
||||
assert_eq!(err.message(), "peer beta: oversize");
|
||||
|
||||
let err = match prepare(200, Some("application/json\r\nX-Injected: 1"), b"{}") {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("smuggled content type must not pass through"),
|
||||
};
|
||||
assert_eq!(err.message(), "peer beta: malformed response");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejects_traversal_excluded_routes_and_bad_query_without_calling() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/systemd/units", 200, "application/json", "{}")
|
||||
.respond("/api/v1/journal/follow", 200, "application/json", "{}");
|
||||
let peer = peer_cfg();
|
||||
let bad_paths = [
|
||||
"/ping",
|
||||
"/api/v1/ping",
|
||||
"/peers/gamma/systemd/units",
|
||||
"/healthz",
|
||||
"/systemd",
|
||||
"/systemd/units/../timers",
|
||||
"/systemd/../docker/ps",
|
||||
"systemd/units/%2e%2e",
|
||||
"journal%2ffollow",
|
||||
"systemd/units/foo%2Fbar",
|
||||
"/systemd/units//nginx.service",
|
||||
"/docker/containers/a/b",
|
||||
"/journal/follow/extra",
|
||||
"",
|
||||
"/",
|
||||
"/systemd/units/%2e.",
|
||||
"systemd\\units",
|
||||
// A second encoding layer and control characters.
|
||||
"systemd%252ffollow",
|
||||
"systemd/units/foo%255cbar.mount",
|
||||
"systemd/units/nginx.service%00",
|
||||
"systemd/units/nginx.service%0a",
|
||||
"systemd/units/nginx%0d.service",
|
||||
"systemd/units/foo%25.service",
|
||||
"systemd/units/foo%zz.service",
|
||||
// An encoded `..` anywhere is a second encoding layer, even when
|
||||
// it sits inside one segment rather than being the segment.
|
||||
"systemd/units/foo%2e%2ebar.mount",
|
||||
// A backslash is only a legal character inside a unit name.
|
||||
"systemd%5cunits",
|
||||
"journal%5cfollow",
|
||||
"docker/containers/web%5cx2d1",
|
||||
];
|
||||
for path in bad_paths {
|
||||
let err = get_with(fake.as_ref(), &peer, path, &[]).await.unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request", "{path}");
|
||||
assert_eq!(err.message(), "peer beta: path not allowed", "{path}");
|
||||
}
|
||||
let bad_queries = [
|
||||
vec![("token".into(), "abc".into())],
|
||||
vec![
|
||||
("state".into(), "failed".into()),
|
||||
("lines".into(), "1".into()),
|
||||
],
|
||||
vec![
|
||||
("state".into(), "failed".into()),
|
||||
("state".into(), "active".into()),
|
||||
],
|
||||
vec![("State".into(), "failed".into())],
|
||||
vec![("state".into(), "a/b".into())],
|
||||
vec![("state".into(), "a%2fb".into())],
|
||||
vec![("state".into(), "..".into())],
|
||||
vec![("state".into(), "a%252fb".into())],
|
||||
vec![("state".into(), "a%255cb".into())],
|
||||
vec![("state".into(), "a%00b".into())],
|
||||
vec![("state".into(), "a%0ab".into())],
|
||||
vec![("state".into(), "a%0db".into())],
|
||||
];
|
||||
for query in bad_queries {
|
||||
let err = get_with(fake.as_ref(), &peer, "/systemd/units", &query)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request", "{query:?}");
|
||||
assert_eq!(err.message(), "peer beta: unsupported query parameter");
|
||||
}
|
||||
assert!(fake.calls().is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn forwards_only_allowlisted_query_and_follow_accept() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/systemd/units",
|
||||
&[("state".into(), "failed".into())],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/docker/containers/web/logs",
|
||||
&[("tail".into(), "10".into()), ("follow".into(), "1".into())],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
get(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/docker/containers/web/logs",
|
||||
&[("follow".into(), "0".into())],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let calls = fake.calls();
|
||||
assert_eq!(calls[0].1.query, vec![("state".into(), "failed".into())]);
|
||||
assert!(calls[0].1.accept.is_none());
|
||||
assert_eq!(calls[1].1.accept.as_deref(), Some("text/event-stream"));
|
||||
assert!(calls[2].1.accept.is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn journal_unit_values_are_forwarded_like_the_local_route() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
// Raw text as an MCP caller would pass it, and the same values in a
|
||||
// request target: `%5C` and a literal backslash both decode to one
|
||||
// backslash, which is what systemd uses to escape a unit name.
|
||||
let raw_queries = [
|
||||
"unit=mnt-data%5Cx2dbackup.mount",
|
||||
"unit=mnt-data%5cx2dbackup.mount",
|
||||
"unit=mnt-data\\x2dbackup.mount",
|
||||
"unit=dev-disk-by%5Cx2did.device&priority=err",
|
||||
"unit=-.mount",
|
||||
"unit=user@100.service",
|
||||
];
|
||||
for raw in raw_queries {
|
||||
let query = query_from_raw("beta", Some(raw)).unwrap();
|
||||
get_with(fake.as_ref(), &peer, "/journal", &query)
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
get_with(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/journal/follow",
|
||||
&[("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
fake.calls()
|
||||
.into_iter()
|
||||
.map(|(_, req)| req.query)
|
||||
.collect::<Vec<_>>(),
|
||||
vec![
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
vec![
|
||||
("unit".into(), "dev-disk-by\\x2did.device".into()),
|
||||
("priority".into(), "err".into()),
|
||||
],
|
||||
vec![("unit".into(), "-.mount".into())],
|
||||
vec![("unit".into(), "user@100.service".into())],
|
||||
vec![("unit".into(), "mnt-data\\x2dbackup.mount".into())],
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn journal_unit_values_still_reject_unsafe_text() {
|
||||
let fake = FakeTransport::new();
|
||||
let peer = peer_cfg();
|
||||
let bad = [
|
||||
// Not a unit name, so the local unit rule rejects it.
|
||||
"unit=../x",
|
||||
"unit=a/b",
|
||||
"unit=nginx",
|
||||
"unit=nginx.service%2fx",
|
||||
"unit=mnt-data%5Cx2d.mount%2e",
|
||||
"unit=mnt-data%0ax2d.mount",
|
||||
"unit=a%255cb.mount",
|
||||
];
|
||||
for raw in bad {
|
||||
// Some values are stopped while the raw query is parsed and the
|
||||
// rest by the allowlist; both are the same 400.
|
||||
let err = match query_from_raw("beta", Some(raw)) {
|
||||
Ok(query) => get_with(fake.as_ref(), &peer, "/journal", &query)
|
||||
.await
|
||||
.unwrap_err(),
|
||||
Err(err) => err,
|
||||
};
|
||||
assert_eq!(err.code(), "bad_request", "{raw}");
|
||||
assert_eq!(
|
||||
err.message(),
|
||||
"peer beta: unsupported query parameter",
|
||||
"{raw}"
|
||||
);
|
||||
}
|
||||
// Values that reach the check already decoded (the MCP path) are
|
||||
// rejected there rather than by the raw parser.
|
||||
for value in [
|
||||
"mnt-data\u{0}x2d.mount",
|
||||
"mnt-data\nx2d.mount",
|
||||
"mnt-data\rx2d.mount",
|
||||
"mnt-data\x2d.mount/../../etc/passwd",
|
||||
] {
|
||||
let err = get_with(
|
||||
fake.as_ref(),
|
||||
&peer,
|
||||
"/journal",
|
||||
&[("unit".into(), value.into())],
|
||||
)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request", "{value:?}");
|
||||
}
|
||||
assert!(fake.calls().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_classification_is_one_table() {
|
||||
assert!(matches!(classify_status(404), PeerError::NotFound));
|
||||
assert!(matches!(classify_status(401), PeerError::Rejected));
|
||||
assert!(matches!(classify_status(403), PeerError::Rejected));
|
||||
assert!(matches!(classify_status(302), PeerError::Http(302)));
|
||||
assert!(matches!(classify_status(200), PeerError::Http(200)));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn slow_peer_is_a_timeout() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").delay(Duration::from_secs(30));
|
||||
let err = get(
|
||||
fake.as_ref(),
|
||||
&peer_cfg(),
|
||||
"/systemd/units",
|
||||
&[],
|
||||
ProxyOpts::default(),
|
||||
Duration::from_millis(20),
|
||||
)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.message(), "peer beta: timeout");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn inbound_hop_is_rejected() {
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(HOP_HEADER, HeaderValue::from_static("1"));
|
||||
let err = reject_inbound_hop("beta", &headers).unwrap_err();
|
||||
assert_eq!(err.code(), "bad_request");
|
||||
assert_eq!(err.message(), "peer beta: chained requests are not allowed");
|
||||
headers.insert(HOP_HEADER, HeaderValue::from_static("0"));
|
||||
assert!(reject_inbound_hop("beta", &headers).is_err());
|
||||
assert!(reject_inbound_hop("beta", &HeaderMap::new()).is_ok());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn query_raw_rejects_encoded_slash() {
|
||||
let err = query_from_raw("beta", Some("state=failed&unit=a%2Fb")).unwrap_err();
|
||||
assert_eq!(err.message(), "peer beta: unsupported query parameter");
|
||||
let pairs = query_from_raw("beta", Some("state=failed")).unwrap();
|
||||
assert_eq!(pairs, vec![("state".into(), "failed".into())]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn body_cap_and_stream_stop_on_shutdown() {
|
||||
let name = PeerName::parse("beta").unwrap();
|
||||
let err = match prepare_body(
|
||||
&name,
|
||||
PeerBody::Bytes(Bytes::from_static(b"0123456789")),
|
||||
4,
|
||||
Instant::now() + Duration::from_secs(5),
|
||||
CancellationToken::new(),
|
||||
) {
|
||||
Err(err) => err,
|
||||
Ok(_) => panic!("expected an oversize error"),
|
||||
};
|
||||
assert_eq!(err.message(), "peer beta: oversize");
|
||||
|
||||
let shutdown = CancellationToken::new();
|
||||
let stream = futures::stream::unfold(0u32, |n| async move {
|
||||
if n > 0 {
|
||||
tokio::time::sleep(Duration::from_secs(30)).await;
|
||||
}
|
||||
Some((
|
||||
Ok::<Bytes, PeerError>(Bytes::from(format!("data: {n}\n\n"))),
|
||||
n + 1,
|
||||
))
|
||||
});
|
||||
let PreparedBody::Stream(mut body) = prepare_body(
|
||||
&name,
|
||||
PeerBody::Stream(Box::pin(stream)),
|
||||
1024,
|
||||
Instant::now() + Duration::from_secs(30),
|
||||
shutdown.clone(),
|
||||
)
|
||||
.unwrap() else {
|
||||
panic!("expected a stream");
|
||||
};
|
||||
let first = body.next().await.unwrap().unwrap();
|
||||
assert_eq!(&first[..], b"data: 0\n\n");
|
||||
shutdown.cancel();
|
||||
assert!(body.next().await.is_none());
|
||||
}
|
||||
+2
-447
@@ -429,450 +429,5 @@ impl PeersReloader {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::peers::testing::{fake_peers_config, registry_with, static_registry, FakeTransport};
|
||||
use crate::peers::transport::PeerBody;
|
||||
use crate::peers::types::AuthState;
|
||||
|
||||
fn status(name: &str, up: bool) -> PeerStatus {
|
||||
PeerStatus {
|
||||
name: PeerName::parse(name).unwrap(),
|
||||
enabled: true,
|
||||
url: format!("http://{name}:1984"),
|
||||
server: ServerStatus {
|
||||
up,
|
||||
..ServerStatus::default()
|
||||
},
|
||||
api: ApiStatus::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snapshot_is_sorted_and_includes_initial_state() {
|
||||
let reg = static_registry(vec![status("gamma", false), status("beta", true)]);
|
||||
let names: Vec<_> = reg
|
||||
.snapshot()
|
||||
.into_iter()
|
||||
.map(|s| s.name.as_str().to_owned())
|
||||
.collect();
|
||||
assert_eq!(names, ["beta", "gamma"]);
|
||||
let b = reg.status("beta").unwrap();
|
||||
assert!(b.server.up);
|
||||
assert_eq!(b.api.auth, AuthState::Unknown);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_peer_status_is_not_found() {
|
||||
let reg = static_registry(vec![status("beta", true)]);
|
||||
let err = reg.status("nope").unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(err.message(), "peer nope: unknown peer");
|
||||
assert!(reg.contains("beta"));
|
||||
assert!(!reg.contains("nope"));
|
||||
assert!(!reg.contains("Beta"));
|
||||
assert!(!reg.contains("-beta"));
|
||||
let err = reg.status("Beta").unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(err.message(), "peer Beta: unknown peer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_is_shared() {
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let reg = registry_with(FakeTransport::new(), cfg);
|
||||
let got = reg.config();
|
||||
assert!(got.enabled);
|
||||
assert_eq!(got.peer[0].name.as_str(), "beta");
|
||||
assert_eq!(got.request_timeout_secs, 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn get_forwards_and_maps_errors() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").respond(
|
||||
"/api/v1/systemd/units",
|
||||
200,
|
||||
"application/json",
|
||||
"{\"ok\":true}",
|
||||
);
|
||||
let reg = registry_with(fake, fake_peers_config(&["beta"]));
|
||||
|
||||
let resp = reg
|
||||
.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(resp.status, 200);
|
||||
match resp.body {
|
||||
PeerBody::Bytes(b) => assert_eq!(&b[..], b"{\"ok\":true}"),
|
||||
PeerBody::Stream(_) => panic!("expected buffered body"),
|
||||
}
|
||||
|
||||
let err = reg
|
||||
.get("nope", "/x", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(err.message(), "peer nope: unknown peer");
|
||||
|
||||
let err = reg
|
||||
.get("Beta", "/x", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.message(), "peer Beta: unknown peer");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reload_keeps_surviving_status_and_prunes_removed() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta", "gamma"]));
|
||||
{
|
||||
let mut st = lock_write(®.shared.state);
|
||||
let beta = st
|
||||
.statuses
|
||||
.get_mut(&PeerName::parse("beta").unwrap())
|
||||
.unwrap();
|
||||
beta.server.up = true;
|
||||
}
|
||||
let mut new = fake_peers_config(&["beta", "delta"]);
|
||||
new.peer[0].enabled = false;
|
||||
reg.reload(new).await.unwrap();
|
||||
|
||||
let snap = reg.snapshot();
|
||||
assert_eq!(snap.len(), 2);
|
||||
assert_eq!(snap[0].name.as_str(), "beta");
|
||||
assert!(snap[0].server.up, "health survives a reload");
|
||||
assert!(!snap[0].enabled);
|
||||
assert_eq!(snap[1].name.as_str(), "delta");
|
||||
assert!(!snap[1].server.up);
|
||||
}
|
||||
|
||||
async fn wait_for<F: Fn(&PeerRegistry) -> bool>(reg: &PeerRegistry, f: F) {
|
||||
let deadline = tokio::time::Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
if f(reg) {
|
||||
return;
|
||||
}
|
||||
assert!(
|
||||
tokio::time::Instant::now() < deadline,
|
||||
"condition not met: {:?}",
|
||||
reg.snapshot()
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn loops_mark_up_and_honour_the_failure_threshold() {
|
||||
let fake = FakeTransport::new();
|
||||
let mut cfg = fake_peers_config(&["beta"]);
|
||||
cfg.fail_threshold = 2;
|
||||
let reg = PeerRegistry::start_with_transport(cfg, fake.clone(), CancellationToken::new());
|
||||
wait_for(®, |r| {
|
||||
let s = r.status("beta").unwrap();
|
||||
s.server.up && s.api.up && s.api.auth == AuthState::Ok
|
||||
})
|
||||
.await;
|
||||
let up = reg.status("beta").unwrap();
|
||||
assert!(up.server.since.is_some());
|
||||
assert_eq!(up.api.peer_version.as_deref(), Some("0.0.0-fake"));
|
||||
|
||||
fake.peer("beta").tcp(Err(crate::peers::PeerError::Timeout));
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", crate::peers::PeerError::Timeout);
|
||||
// One failure each: still up with the error visible.
|
||||
wait_for(®, |r| {
|
||||
let s = r.status("beta").unwrap();
|
||||
s.server.last_error.as_deref() == Some("timeout")
|
||||
&& s.api.last_error.as_deref() == Some("timeout")
|
||||
})
|
||||
.await;
|
||||
let below = reg.status("beta").unwrap();
|
||||
assert!(below.server.up);
|
||||
assert_eq!(
|
||||
below.api.peer_version.as_deref(),
|
||||
Some("0.0.0-fake"),
|
||||
"the version stays known while the API is still up"
|
||||
);
|
||||
|
||||
// The next failure reaches the threshold and flips both checks down.
|
||||
wait_for(®, |r| {
|
||||
let s = r.status("beta").unwrap();
|
||||
!s.server.up && !s.api.up
|
||||
})
|
||||
.await;
|
||||
let down = reg.status("beta").unwrap();
|
||||
assert_eq!(down.server.last_error.as_deref(), Some("timeout"));
|
||||
assert_eq!(down.api.auth, AuthState::Unknown);
|
||||
assert!(down.server.since.is_some());
|
||||
reg.shutdown().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_hung_peer_does_not_delay_another_peers_checks() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").delay(Duration::from_secs(2));
|
||||
fake.peer("gamma")
|
||||
.respond("/api/v1/ping", 200, "application/json", "{}");
|
||||
let reg = PeerRegistry::start_with_transport(
|
||||
fake_peers_config(&["beta", "gamma"]),
|
||||
fake.clone(),
|
||||
CancellationToken::new(),
|
||||
);
|
||||
wait_for(®, |r| {
|
||||
r.status("gamma").unwrap().api.last_checked.is_some()
|
||||
})
|
||||
.await;
|
||||
let gamma_checked = reg.status("gamma").unwrap().api.last_checked;
|
||||
assert!(reg.status("beta").unwrap().api.last_checked.is_none());
|
||||
assert!(gamma_checked.is_some());
|
||||
reg.shutdown().await;
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error
|
||||
fn reloader_rereads_the_peers_block_and_keeps_the_old_set_on_error() {
|
||||
use figment::Jail;
|
||||
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
Jail::expect_with(|jail| {
|
||||
jail.create_file(
|
||||
"config.toml",
|
||||
r#"
|
||||
[peers]
|
||||
enabled = true
|
||||
api_interval_secs = 2
|
||||
api_timeout_secs = 1
|
||||
[[peers.peer]]
|
||||
name = "gamma"
|
||||
url = "http://gamma:1984"
|
||||
token_file = "/run/credentials/skyg-linux-tracker.service/peer-gamma"
|
||||
allow_plain_http = true
|
||||
"#,
|
||||
)?;
|
||||
let reloader = PeersReloader::new(
|
||||
reg.clone(),
|
||||
Some(std::path::PathBuf::from("config.toml")),
|
||||
CliOverrides::default(),
|
||||
);
|
||||
tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.unwrap()
|
||||
.block_on(reloader.reload())
|
||||
.unwrap();
|
||||
let snap = reg.snapshot();
|
||||
assert_eq!(snap.len(), 1);
|
||||
assert_eq!(snap[0].name.as_str(), "gamma");
|
||||
assert_eq!(reg.config().api_interval_secs, 2);
|
||||
|
||||
let broken = PeersReloader::new(
|
||||
reg.clone(),
|
||||
Some(std::path::PathBuf::from("missing.toml")),
|
||||
CliOverrides::default(),
|
||||
);
|
||||
assert!(tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.unwrap()
|
||||
.block_on(broken.reload())
|
||||
.is_err());
|
||||
assert!(reg.contains("gamma"), "a bad reload keeps the old peers");
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_disabled_peer_is_never_proxied() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/systemd/units", 200, "application/json", "{}");
|
||||
let reg = registry_with(fake.clone(), fake_peers_config(&["beta"]));
|
||||
reg.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap();
|
||||
let calls = fake.calls().len();
|
||||
|
||||
let mut peer_off = fake_peers_config(&["beta"]);
|
||||
peer_off.peer[0].enabled = false;
|
||||
reg.reload(peer_off).await.unwrap();
|
||||
let err = reg
|
||||
.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert!(err.message().contains("disabled"), "{}", err.message());
|
||||
|
||||
let mut feature_off = fake_peers_config(&["beta"]);
|
||||
feature_off.enabled = false;
|
||||
reg.reload(feature_off).await.unwrap();
|
||||
let err = reg
|
||||
.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(
|
||||
fake.calls().len(),
|
||||
calls,
|
||||
"no request (and so no token) leaves while the peer is off"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reload_rejects_changes_the_transport_cannot_apply() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
let old = reg.config();
|
||||
|
||||
let mut moved = fake_peers_config(&["beta"]);
|
||||
moved.deny_cidrs = vec!["10.0.0.0/8".into()];
|
||||
let err = reg.reload(moved).await.unwrap_err();
|
||||
assert!(err.to_string().contains("restart"), "{err}");
|
||||
|
||||
let mut resized = fake_peers_config(&["beta"]);
|
||||
resized.max_response_bytes = 4096;
|
||||
assert!(reg.reload(resized).await.is_err());
|
||||
|
||||
let mut capped = fake_peers_config(&["beta"]);
|
||||
capped.max_concurrent_per_peer = 1;
|
||||
assert!(reg.reload(capped).await.is_err());
|
||||
assert_eq!(reg.config().deny_cidrs, old.deny_cidrs);
|
||||
assert_eq!(reg.config().max_response_bytes, old.max_response_bytes);
|
||||
|
||||
let mut invalid = fake_peers_config(&["beta"]);
|
||||
invalid.deny_cidrs = vec!["not-a-cidr".into()];
|
||||
let broken = registry_with(FakeTransport::new(), invalid.clone());
|
||||
let err = broken.reload(invalid).await.unwrap_err();
|
||||
assert!(err.to_string().contains("CIDR"), "{err}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_changed_peer_url_starts_with_a_clean_status() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
{
|
||||
let mut st = lock_write(®.shared.state);
|
||||
let beta = st
|
||||
.statuses
|
||||
.get_mut(&PeerName::parse("beta").unwrap())
|
||||
.unwrap();
|
||||
beta.server.up = true;
|
||||
beta.server.since = Some(jiff::Timestamp::now());
|
||||
beta.api.up = true;
|
||||
beta.api.peer_version = Some("1.0.0".into());
|
||||
}
|
||||
let mut moved = fake_peers_config(&["beta"]);
|
||||
moved.peer[0].url = url::Url::parse("http://beta-2:1984").unwrap();
|
||||
reg.reload(moved).await.unwrap();
|
||||
let status = reg.status("beta").unwrap();
|
||||
assert_eq!(status.url, "http://beta-2:1984");
|
||||
assert!(!status.server.up);
|
||||
assert!(status.server.since.is_none());
|
||||
assert!(status.api.since.is_none());
|
||||
assert_eq!(status.api.peer_version, None);
|
||||
}
|
||||
|
||||
/// The SIGHUP handler fans out to peers even with TLS off, and the
|
||||
/// peer-less default (both off) still consumes the signal.
|
||||
#[tokio::test]
|
||||
async fn sighup_reloads_peers_when_tls_is_off() {
|
||||
use tokio::signal::unix::{signal, SignalKind};
|
||||
|
||||
let dir = std::env::temp_dir().join(format!("slinuxm-sighup-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let path = dir.join("config.toml");
|
||||
std::fs::write(
|
||||
&path,
|
||||
r#"
|
||||
[peers]
|
||||
enabled = true
|
||||
[[peers.peer]]
|
||||
name = "gamma"
|
||||
url = "http://gamma:1984"
|
||||
token_file = "/run/peers/gamma.token"
|
||||
allow_plain_http = true
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
let hup = signal(SignalKind::hangup()).unwrap();
|
||||
let shutdown = CancellationToken::new();
|
||||
crate::tls::spawn_sighup_reload(
|
||||
None,
|
||||
hup,
|
||||
shutdown.clone(),
|
||||
Some(PeersReloader::new(
|
||||
reg.clone(),
|
||||
Some(path.clone()),
|
||||
CliOverrides::default(),
|
||||
)),
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
let sent = unsafe { libc::kill(std::process::id() as libc::pid_t, libc::SIGHUP) };
|
||||
assert_eq!(sent, 0, "sending SIGHUP failed");
|
||||
|
||||
let deadline = tokio::time::Instant::now() + Duration::from_secs(5);
|
||||
while !reg.contains("gamma") {
|
||||
assert!(
|
||||
tokio::time::Instant::now() < deadline,
|
||||
"SIGHUP did not reach the peer reloader: {:?}",
|
||||
reg.snapshot()
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
shutdown.cancel();
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn shutdown_waits_for_loops_retired_by_a_reload() {
|
||||
let fake = FakeTransport::new();
|
||||
let reg = PeerRegistry::start_with_transport(
|
||||
fake_peers_config(&["beta", "gamma"]),
|
||||
fake.clone(),
|
||||
CancellationToken::new(),
|
||||
);
|
||||
wait_for(®, |r| r.status("beta").unwrap().server.up).await;
|
||||
reg.reload(fake_peers_config(&["gamma"])).await.unwrap();
|
||||
assert!(
|
||||
!lock_mutex(®.retired).is_empty(),
|
||||
"the removed peer's loop is retained, not detached"
|
||||
);
|
||||
reg.shutdown().await;
|
||||
assert!(lock_mutex(®.retired).is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reload_disabling_the_feature_empties_the_snapshot() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
let mut new = fake_peers_config(&["beta"]);
|
||||
new.enabled = false;
|
||||
reg.reload(new).await.unwrap();
|
||||
assert!(reg.snapshot().is_empty());
|
||||
assert!(reg.status("beta").is_err());
|
||||
assert!(!reg.config().enabled);
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn reload_moves_loops_to_the_new_peer_set() {
|
||||
let fake = FakeTransport::new();
|
||||
let reg = PeerRegistry::start_with_transport(
|
||||
fake_peers_config(&["beta"]),
|
||||
fake.clone(),
|
||||
CancellationToken::new(),
|
||||
);
|
||||
wait_for(®, |r| r.status("beta").unwrap().server.up).await;
|
||||
|
||||
reg.reload(fake_peers_config(&["beta", "gamma"]))
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(®, |r| r.status("gamma").unwrap().server.up).await;
|
||||
assert!(
|
||||
reg.status("beta").unwrap().server.up,
|
||||
"kept peer keeps state"
|
||||
);
|
||||
|
||||
reg.reload(fake_peers_config(&["gamma"])).await.unwrap();
|
||||
assert!(reg.status("beta").is_err());
|
||||
assert!(reg.contains("gamma"));
|
||||
reg.shutdown().await;
|
||||
}
|
||||
}
|
||||
#[path = "registry_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,445 @@
|
||||
use super::*;
|
||||
use crate::peers::testing::{fake_peers_config, registry_with, static_registry, FakeTransport};
|
||||
use crate::peers::transport::PeerBody;
|
||||
use crate::peers::types::AuthState;
|
||||
|
||||
fn status(name: &str, up: bool) -> PeerStatus {
|
||||
PeerStatus {
|
||||
name: PeerName::parse(name).unwrap(),
|
||||
enabled: true,
|
||||
url: format!("http://{name}:1984"),
|
||||
server: ServerStatus {
|
||||
up,
|
||||
..ServerStatus::default()
|
||||
},
|
||||
api: ApiStatus::default(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn snapshot_is_sorted_and_includes_initial_state() {
|
||||
let reg = static_registry(vec![status("gamma", false), status("beta", true)]);
|
||||
let names: Vec<_> = reg
|
||||
.snapshot()
|
||||
.into_iter()
|
||||
.map(|s| s.name.as_str().to_owned())
|
||||
.collect();
|
||||
assert_eq!(names, ["beta", "gamma"]);
|
||||
let b = reg.status("beta").unwrap();
|
||||
assert!(b.server.up);
|
||||
assert_eq!(b.api.auth, AuthState::Unknown);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_peer_status_is_not_found() {
|
||||
let reg = static_registry(vec![status("beta", true)]);
|
||||
let err = reg.status("nope").unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(err.message(), "peer nope: unknown peer");
|
||||
assert!(reg.contains("beta"));
|
||||
assert!(!reg.contains("nope"));
|
||||
assert!(!reg.contains("Beta"));
|
||||
assert!(!reg.contains("-beta"));
|
||||
let err = reg.status("Beta").unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(err.message(), "peer Beta: unknown peer");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_is_shared() {
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let reg = registry_with(FakeTransport::new(), cfg);
|
||||
let got = reg.config();
|
||||
assert!(got.enabled);
|
||||
assert_eq!(got.peer[0].name.as_str(), "beta");
|
||||
assert_eq!(got.request_timeout_secs, 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn get_forwards_and_maps_errors() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").respond(
|
||||
"/api/v1/systemd/units",
|
||||
200,
|
||||
"application/json",
|
||||
"{\"ok\":true}",
|
||||
);
|
||||
let reg = registry_with(fake, fake_peers_config(&["beta"]));
|
||||
|
||||
let resp = reg
|
||||
.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(resp.status, 200);
|
||||
match resp.body {
|
||||
PeerBody::Bytes(b) => assert_eq!(&b[..], b"{\"ok\":true}"),
|
||||
PeerBody::Stream(_) => panic!("expected buffered body"),
|
||||
}
|
||||
|
||||
let err = reg
|
||||
.get("nope", "/x", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(err.message(), "peer nope: unknown peer");
|
||||
|
||||
let err = reg
|
||||
.get("Beta", "/x", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.message(), "peer Beta: unknown peer");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reload_keeps_surviving_status_and_prunes_removed() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta", "gamma"]));
|
||||
{
|
||||
let mut st = lock_write(®.shared.state);
|
||||
let beta = st
|
||||
.statuses
|
||||
.get_mut(&PeerName::parse("beta").unwrap())
|
||||
.unwrap();
|
||||
beta.server.up = true;
|
||||
}
|
||||
let mut new = fake_peers_config(&["beta", "delta"]);
|
||||
new.peer[0].enabled = false;
|
||||
reg.reload(new).await.unwrap();
|
||||
|
||||
let snap = reg.snapshot();
|
||||
assert_eq!(snap.len(), 2);
|
||||
assert_eq!(snap[0].name.as_str(), "beta");
|
||||
assert!(snap[0].server.up, "health survives a reload");
|
||||
assert!(!snap[0].enabled);
|
||||
assert_eq!(snap[1].name.as_str(), "delta");
|
||||
assert!(!snap[1].server.up);
|
||||
}
|
||||
|
||||
async fn wait_for<F: Fn(&PeerRegistry) -> bool>(reg: &PeerRegistry, f: F) {
|
||||
let deadline = tokio::time::Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
if f(reg) {
|
||||
return;
|
||||
}
|
||||
assert!(
|
||||
tokio::time::Instant::now() < deadline,
|
||||
"condition not met: {:?}",
|
||||
reg.snapshot()
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn loops_mark_up_and_honour_the_failure_threshold() {
|
||||
let fake = FakeTransport::new();
|
||||
let mut cfg = fake_peers_config(&["beta"]);
|
||||
cfg.fail_threshold = 2;
|
||||
let reg = PeerRegistry::start_with_transport(cfg, fake.clone(), CancellationToken::new());
|
||||
wait_for(®, |r| {
|
||||
let s = r.status("beta").unwrap();
|
||||
s.server.up && s.api.up && s.api.auth == AuthState::Ok
|
||||
})
|
||||
.await;
|
||||
let up = reg.status("beta").unwrap();
|
||||
assert!(up.server.since.is_some());
|
||||
assert_eq!(up.api.peer_version.as_deref(), Some("0.0.0-fake"));
|
||||
|
||||
fake.peer("beta").tcp(Err(crate::peers::PeerError::Timeout));
|
||||
fake.peer("beta")
|
||||
.respond_err("/api/v1/ping", crate::peers::PeerError::Timeout);
|
||||
// One failure each: still up with the error visible.
|
||||
wait_for(®, |r| {
|
||||
let s = r.status("beta").unwrap();
|
||||
s.server.last_error.as_deref() == Some("timeout")
|
||||
&& s.api.last_error.as_deref() == Some("timeout")
|
||||
})
|
||||
.await;
|
||||
let below = reg.status("beta").unwrap();
|
||||
assert!(below.server.up);
|
||||
assert_eq!(
|
||||
below.api.peer_version.as_deref(),
|
||||
Some("0.0.0-fake"),
|
||||
"the version stays known while the API is still up"
|
||||
);
|
||||
|
||||
// The next failure reaches the threshold and flips both checks down.
|
||||
wait_for(®, |r| {
|
||||
let s = r.status("beta").unwrap();
|
||||
!s.server.up && !s.api.up
|
||||
})
|
||||
.await;
|
||||
let down = reg.status("beta").unwrap();
|
||||
assert_eq!(down.server.last_error.as_deref(), Some("timeout"));
|
||||
assert_eq!(down.api.auth, AuthState::Unknown);
|
||||
assert!(down.server.since.is_some());
|
||||
reg.shutdown().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_hung_peer_does_not_delay_another_peers_checks() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").delay(Duration::from_secs(2));
|
||||
fake.peer("gamma")
|
||||
.respond("/api/v1/ping", 200, "application/json", "{}");
|
||||
let reg = PeerRegistry::start_with_transport(
|
||||
fake_peers_config(&["beta", "gamma"]),
|
||||
fake.clone(),
|
||||
CancellationToken::new(),
|
||||
);
|
||||
wait_for(®, |r| {
|
||||
r.status("gamma").unwrap().api.last_checked.is_some()
|
||||
})
|
||||
.await;
|
||||
let gamma_checked = reg.status("gamma").unwrap().api.last_checked;
|
||||
assert!(reg.status("beta").unwrap().api.last_checked.is_none());
|
||||
assert!(gamma_checked.is_some());
|
||||
reg.shutdown().await;
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[allow(clippy::result_large_err)] // figment::Jail closures return figment::Error
|
||||
fn reloader_rereads_the_peers_block_and_keeps_the_old_set_on_error() {
|
||||
use figment::Jail;
|
||||
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
Jail::expect_with(|jail| {
|
||||
jail.create_file(
|
||||
"config.toml",
|
||||
r#"
|
||||
[peers]
|
||||
enabled = true
|
||||
api_interval_secs = 2
|
||||
api_timeout_secs = 1
|
||||
[[peers.peer]]
|
||||
name = "gamma"
|
||||
url = "http://gamma:1984"
|
||||
token_file = "/run/credentials/skyg-linux-tracker.service/peer-gamma"
|
||||
allow_plain_http = true
|
||||
"#,
|
||||
)?;
|
||||
let reloader = PeersReloader::new(
|
||||
reg.clone(),
|
||||
Some(std::path::PathBuf::from("config.toml")),
|
||||
CliOverrides::default(),
|
||||
);
|
||||
tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.unwrap()
|
||||
.block_on(reloader.reload())
|
||||
.unwrap();
|
||||
let snap = reg.snapshot();
|
||||
assert_eq!(snap.len(), 1);
|
||||
assert_eq!(snap[0].name.as_str(), "gamma");
|
||||
assert_eq!(reg.config().api_interval_secs, 2);
|
||||
|
||||
let broken = PeersReloader::new(
|
||||
reg.clone(),
|
||||
Some(std::path::PathBuf::from("missing.toml")),
|
||||
CliOverrides::default(),
|
||||
);
|
||||
assert!(tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.unwrap()
|
||||
.block_on(broken.reload())
|
||||
.is_err());
|
||||
assert!(reg.contains("gamma"), "a bad reload keeps the old peers");
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_disabled_peer_is_never_proxied() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/api/v1/systemd/units", 200, "application/json", "{}");
|
||||
let reg = registry_with(fake.clone(), fake_peers_config(&["beta"]));
|
||||
reg.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap();
|
||||
let calls = fake.calls().len();
|
||||
|
||||
let mut peer_off = fake_peers_config(&["beta"]);
|
||||
peer_off.peer[0].enabled = false;
|
||||
reg.reload(peer_off).await.unwrap();
|
||||
let err = reg
|
||||
.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert!(err.message().contains("disabled"), "{}", err.message());
|
||||
|
||||
let mut feature_off = fake_peers_config(&["beta"]);
|
||||
feature_off.enabled = false;
|
||||
reg.reload(feature_off).await.unwrap();
|
||||
let err = reg
|
||||
.get("beta", "/systemd/units", &[], ProxyOpts::default())
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "not_found");
|
||||
assert_eq!(
|
||||
fake.calls().len(),
|
||||
calls,
|
||||
"no request (and so no token) leaves while the peer is off"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reload_rejects_changes_the_transport_cannot_apply() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
let old = reg.config();
|
||||
|
||||
let mut moved = fake_peers_config(&["beta"]);
|
||||
moved.deny_cidrs = vec!["10.0.0.0/8".into()];
|
||||
let err = reg.reload(moved).await.unwrap_err();
|
||||
assert!(err.to_string().contains("restart"), "{err}");
|
||||
|
||||
let mut resized = fake_peers_config(&["beta"]);
|
||||
resized.max_response_bytes = 4096;
|
||||
assert!(reg.reload(resized).await.is_err());
|
||||
|
||||
let mut capped = fake_peers_config(&["beta"]);
|
||||
capped.max_concurrent_per_peer = 1;
|
||||
assert!(reg.reload(capped).await.is_err());
|
||||
assert_eq!(reg.config().deny_cidrs, old.deny_cidrs);
|
||||
assert_eq!(reg.config().max_response_bytes, old.max_response_bytes);
|
||||
|
||||
let mut invalid = fake_peers_config(&["beta"]);
|
||||
invalid.deny_cidrs = vec!["not-a-cidr".into()];
|
||||
let broken = registry_with(FakeTransport::new(), invalid.clone());
|
||||
let err = broken.reload(invalid).await.unwrap_err();
|
||||
assert!(err.to_string().contains("CIDR"), "{err}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_changed_peer_url_starts_with_a_clean_status() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
{
|
||||
let mut st = lock_write(®.shared.state);
|
||||
let beta = st
|
||||
.statuses
|
||||
.get_mut(&PeerName::parse("beta").unwrap())
|
||||
.unwrap();
|
||||
beta.server.up = true;
|
||||
beta.server.since = Some(jiff::Timestamp::now());
|
||||
beta.api.up = true;
|
||||
beta.api.peer_version = Some("1.0.0".into());
|
||||
}
|
||||
let mut moved = fake_peers_config(&["beta"]);
|
||||
moved.peer[0].url = url::Url::parse("http://beta-2:1984").unwrap();
|
||||
reg.reload(moved).await.unwrap();
|
||||
let status = reg.status("beta").unwrap();
|
||||
assert_eq!(status.url, "http://beta-2:1984");
|
||||
assert!(!status.server.up);
|
||||
assert!(status.server.since.is_none());
|
||||
assert!(status.api.since.is_none());
|
||||
assert_eq!(status.api.peer_version, None);
|
||||
}
|
||||
|
||||
/// The SIGHUP handler fans out to peers even with TLS off, and the
|
||||
/// peer-less default (both off) still consumes the signal.
|
||||
#[tokio::test]
|
||||
async fn sighup_reloads_peers_when_tls_is_off() {
|
||||
use tokio::signal::unix::{signal, SignalKind};
|
||||
|
||||
let dir = std::env::temp_dir().join(format!("slinuxm-sighup-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let path = dir.join("config.toml");
|
||||
std::fs::write(
|
||||
&path,
|
||||
r#"
|
||||
[peers]
|
||||
enabled = true
|
||||
[[peers.peer]]
|
||||
name = "gamma"
|
||||
url = "http://gamma:1984"
|
||||
token_file = "/run/peers/gamma.token"
|
||||
allow_plain_http = true
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
let hup = signal(SignalKind::hangup()).unwrap();
|
||||
let shutdown = CancellationToken::new();
|
||||
crate::tls::spawn_sighup_reload(
|
||||
None,
|
||||
hup,
|
||||
shutdown.clone(),
|
||||
Some(PeersReloader::new(
|
||||
reg.clone(),
|
||||
Some(path.clone()),
|
||||
CliOverrides::default(),
|
||||
)),
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
let sent = unsafe { libc::kill(std::process::id() as libc::pid_t, libc::SIGHUP) };
|
||||
assert_eq!(sent, 0, "sending SIGHUP failed");
|
||||
|
||||
let deadline = tokio::time::Instant::now() + Duration::from_secs(5);
|
||||
while !reg.contains("gamma") {
|
||||
assert!(
|
||||
tokio::time::Instant::now() < deadline,
|
||||
"SIGHUP did not reach the peer reloader: {:?}",
|
||||
reg.snapshot()
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
shutdown.cancel();
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn shutdown_waits_for_loops_retired_by_a_reload() {
|
||||
let fake = FakeTransport::new();
|
||||
let reg = PeerRegistry::start_with_transport(
|
||||
fake_peers_config(&["beta", "gamma"]),
|
||||
fake.clone(),
|
||||
CancellationToken::new(),
|
||||
);
|
||||
wait_for(®, |r| r.status("beta").unwrap().server.up).await;
|
||||
reg.reload(fake_peers_config(&["gamma"])).await.unwrap();
|
||||
assert!(
|
||||
!lock_mutex(®.retired).is_empty(),
|
||||
"the removed peer's loop is retained, not detached"
|
||||
);
|
||||
reg.shutdown().await;
|
||||
assert!(lock_mutex(®.retired).is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reload_disabling_the_feature_empties_the_snapshot() {
|
||||
let reg = registry_with(FakeTransport::new(), fake_peers_config(&["beta"]));
|
||||
let mut new = fake_peers_config(&["beta"]);
|
||||
new.enabled = false;
|
||||
reg.reload(new).await.unwrap();
|
||||
assert!(reg.snapshot().is_empty());
|
||||
assert!(reg.status("beta").is_err());
|
||||
assert!(!reg.config().enabled);
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn reload_moves_loops_to_the_new_peer_set() {
|
||||
let fake = FakeTransport::new();
|
||||
let reg = PeerRegistry::start_with_transport(
|
||||
fake_peers_config(&["beta"]),
|
||||
fake.clone(),
|
||||
CancellationToken::new(),
|
||||
);
|
||||
wait_for(®, |r| r.status("beta").unwrap().server.up).await;
|
||||
|
||||
reg.reload(fake_peers_config(&["beta", "gamma"]))
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(®, |r| r.status("gamma").unwrap().server.up).await;
|
||||
assert!(
|
||||
reg.status("beta").unwrap().server.up,
|
||||
"kept peer keeps state"
|
||||
);
|
||||
|
||||
reg.reload(fake_peers_config(&["gamma"])).await.unwrap();
|
||||
assert!(reg.status("beta").is_err());
|
||||
assert!(reg.contains("gamma"));
|
||||
reg.shutdown().await;
|
||||
}
|
||||
+2
-214
@@ -122,217 +122,5 @@ fn trim_one_newline(buf: &mut Vec<u8>) {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use super::*;
|
||||
use crate::peers::testing::{capture::logged, TempDir};
|
||||
use crate::peers::types::PeerName;
|
||||
|
||||
const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK";
|
||||
|
||||
fn peer(path: PathBuf) -> PeerConfig {
|
||||
PeerConfig {
|
||||
name: PeerName::parse("beta").unwrap(),
|
||||
url: url::Url::parse("http://127.0.0.1:1984").unwrap(),
|
||||
token_file: path,
|
||||
ca_file: None,
|
||||
allow_plain_http: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn token_err(err: PeerError) -> String {
|
||||
match err {
|
||||
PeerError::TokenFile(reason) => reason,
|
||||
other => panic!("expected TokenFile, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trims_one_newline_and_rereads_a_replaced_file() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let path = dir.write("token", b"pending\n", 0o600);
|
||||
let loaded = load_token_at(&peer(path.clone()), None).unwrap();
|
||||
assert_eq!(loaded.expose(), "pending");
|
||||
assert!(!format!("{loaded:?}").contains("pending"));
|
||||
assert!(!format!("{loaded}").contains("pending"));
|
||||
|
||||
// Only one newline is trimmed; a second one would end the header line
|
||||
// early, so the file is refused rather than forwarded.
|
||||
std::fs::write(&path, b"pending\n\n").unwrap();
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(path.clone()), None).unwrap_err()),
|
||||
"invalid"
|
||||
);
|
||||
std::fs::write(&path, b"next\r\n").unwrap();
|
||||
assert_eq!(load_token(&peer(path)).unwrap().expose(), "next");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_empty_oversize_and_non_utf8_without_echoing_bytes() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let empty = dir.write("empty", b"", 0o600);
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(empty), None).unwrap_err()),
|
||||
"empty"
|
||||
);
|
||||
let newline = dir.write("nl", b"\n", 0o600);
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(newline), None).unwrap_err()),
|
||||
"empty"
|
||||
);
|
||||
|
||||
let exact = dir.write("exact", &vec![b'a'; MAX_TOKEN_BYTES], 0o600);
|
||||
let loaded = load_token_at(&peer(exact), None).unwrap();
|
||||
assert_eq!(loaded.expose().len(), MAX_TOKEN_BYTES);
|
||||
assert!(!format!("{loaded:?}").contains("aaa"));
|
||||
|
||||
let big = dir.write("big", &vec![b'Z'; MAX_TOKEN_BYTES + 1], 0o600);
|
||||
let err = load_token_at(&peer(big), None).unwrap_err();
|
||||
let text = format!("{err:?}");
|
||||
assert!(text.contains("larger than"));
|
||||
assert!(!text.contains(&"Z".repeat(20)));
|
||||
|
||||
let binary = dir.write("bin", &[0xff, 0xfe], 0o600);
|
||||
let err = token_err(load_token_at(&peer(binary), None).unwrap_err());
|
||||
assert_eq!(err, "not utf-8");
|
||||
assert!(!err.contains('\u{ff}'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tokens_that_cannot_be_a_header_value_are_refused() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
for (name, body) in [
|
||||
("crlf", b"a\r\nb\n".to_vec()),
|
||||
("mid-newline", b"a\nb".to_vec()),
|
||||
("mid-cr", b"a\rb".to_vec()),
|
||||
("nul", b"a\0b".to_vec()),
|
||||
("del", b"a\x7fb".to_vec()),
|
||||
] {
|
||||
let path = dir.write(name, &body, 0o600);
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(path), None).unwrap_err()),
|
||||
"invalid",
|
||||
"{name}"
|
||||
);
|
||||
}
|
||||
// A visible token with no control characters still loads.
|
||||
let ok = dir.write("ok", b"slinuxm_abc-123\n", 0o600);
|
||||
assert_eq!(
|
||||
load_token_at(&peer(ok), None).unwrap().expose(),
|
||||
"slinuxm_abc-123"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn group_readable_files_are_rejected_unless_under_the_credentials_dir() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let creds = dir.path().join("creds");
|
||||
let evil = dir.path().join("creds-evil");
|
||||
std::fs::create_dir_all(&creds).unwrap();
|
||||
std::fs::create_dir_all(&evil).unwrap();
|
||||
let inside = dir.write("creds/token", format!("{SECRET}\n").as_bytes(), 0o644);
|
||||
let outside = dir.write("creds-evil/token", format!("{SECRET}\n").as_bytes(), 0o640);
|
||||
|
||||
let err = token_err(load_token_at(&peer(outside.clone()), Some(&creds)).unwrap_err());
|
||||
assert!(err.contains("group or world accessible"), "{err}");
|
||||
assert!(!err.contains("SHOULD_NOT_LEAK"), "{err}");
|
||||
|
||||
let loaded = load_token_at(&peer(inside), Some(creds.as_path())).unwrap();
|
||||
assert_eq!(loaded.expose(), SECRET);
|
||||
assert!(!format!("{loaded:?}").contains("SHOULD_NOT_LEAK"));
|
||||
|
||||
let private = dir.write("private", format!("{SECRET}\n").as_bytes(), 0o600);
|
||||
assert_eq!(
|
||||
load_token_at(&peer(private), None).unwrap().expose(),
|
||||
SECRET
|
||||
);
|
||||
|
||||
let private = dir.write("logged", format!("{SECRET}\n").as_bytes(), 0o600);
|
||||
let logs = logged(|| {
|
||||
load_token_at(&peer(private), None).unwrap();
|
||||
});
|
||||
assert!(!logs.contains("SHOULD_NOT_LEAK"), "{logs}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn group_or_world_write_and_execute_bits_are_rejected_too() {
|
||||
// Any group or world access lets another user read the token (r, x on
|
||||
// a readable file) or swap it (w). Each mode below sets a different
|
||||
// bit, so a mask that misses one bit still passes the others.
|
||||
let dir = TempDir::new("peer-secret");
|
||||
for mode in [0o620, 0o602, 0o610, 0o601] {
|
||||
let path = dir.write(&format!("token-{mode:o}"), b"pending\n", mode);
|
||||
let err = token_err(load_token_at(&peer(path), None).unwrap_err());
|
||||
assert_eq!(err, "group or world accessible", "{mode:o}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fifo_is_refused_without_waiting_for_a_writer() {
|
||||
use std::os::unix::ffi::OsStrExt;
|
||||
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let fifo = dir.path().join("fifo");
|
||||
let c_path = std::ffi::CString::new(fifo.as_os_str().as_bytes()).unwrap();
|
||||
// SAFETY: mkfifo only reads the path string; the mode is a literal.
|
||||
assert_eq!(unsafe { libc::mkfifo(c_path.as_ptr(), 0o600) }, 0);
|
||||
|
||||
// Opening a FIFO for reading blocks until a writer appears, which
|
||||
// would park a blocking-pool thread on every check and proxy call.
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let peer = peer(fifo);
|
||||
std::thread::spawn(move || {
|
||||
let _ = tx.send(token_err(load_token_at(&peer, None).unwrap_err()));
|
||||
});
|
||||
let err = rx
|
||||
.recv_timeout(std::time::Duration::from_secs(5))
|
||||
.expect("the token loader must not wait on a fifo");
|
||||
assert_eq!(err, "not a file");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_symlink_cannot_borrow_the_credentials_directory_exemption() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let creds = dir.path().join("creds");
|
||||
std::fs::create_dir_all(&creds).unwrap();
|
||||
let outside = dir.write("outside/token", format!("{SECRET}\n").as_bytes(), 0o644);
|
||||
let link = creds.join("peer-beta");
|
||||
std::os::unix::fs::symlink(&outside, &link).unwrap();
|
||||
|
||||
// The link lives under the credential directory, its target does not:
|
||||
// the target's mode decides, so the loose file is refused.
|
||||
let err = token_err(load_token_at(&peer(link), Some(&creds)).unwrap_err());
|
||||
assert!(err.contains("group or world accessible"), "{err}");
|
||||
|
||||
// A private target behind the same link is fine.
|
||||
std::fs::set_permissions(
|
||||
&outside,
|
||||
std::os::unix::fs::PermissionsExt::from_mode(0o600),
|
||||
)
|
||||
.unwrap();
|
||||
let loaded = load_token_at(&peer(creds.join("peer-beta")), Some(&creds)).unwrap();
|
||||
assert_eq!(loaded.expose(), SECRET);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_directory_is_not_a_token_file() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let nested = dir.path().join("as-a-dir");
|
||||
std::fs::create_dir_all(&nested).unwrap();
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(nested), None).unwrap_err()),
|
||||
"not a file"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_file_names_no_secret() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let missing = dir.path().join("not-there");
|
||||
let err = token_err(load_token_at(&peer(missing), Some(Path::new(""))).unwrap_err());
|
||||
assert!(err.contains("not readable"), "{err}");
|
||||
assert!(!err.contains(SECRET));
|
||||
}
|
||||
}
|
||||
#[path = "secrets_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,212 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use super::*;
|
||||
use crate::peers::testing::{capture::logged, TempDir};
|
||||
use crate::peers::types::PeerName;
|
||||
|
||||
const SECRET: &str = "slinuxm_PEER_TOKEN_SHOULD_NOT_LEAK";
|
||||
|
||||
fn peer(path: PathBuf) -> PeerConfig {
|
||||
PeerConfig {
|
||||
name: PeerName::parse("beta").unwrap(),
|
||||
url: url::Url::parse("http://127.0.0.1:1984").unwrap(),
|
||||
token_file: path,
|
||||
ca_file: None,
|
||||
allow_plain_http: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn token_err(err: PeerError) -> String {
|
||||
match err {
|
||||
PeerError::TokenFile(reason) => reason,
|
||||
other => panic!("expected TokenFile, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trims_one_newline_and_rereads_a_replaced_file() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let path = dir.write("token", b"pending\n", 0o600);
|
||||
let loaded = load_token_at(&peer(path.clone()), None).unwrap();
|
||||
assert_eq!(loaded.expose(), "pending");
|
||||
assert!(!format!("{loaded:?}").contains("pending"));
|
||||
assert!(!format!("{loaded}").contains("pending"));
|
||||
|
||||
// Only one newline is trimmed; a second one would end the header line
|
||||
// early, so the file is refused rather than forwarded.
|
||||
std::fs::write(&path, b"pending\n\n").unwrap();
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(path.clone()), None).unwrap_err()),
|
||||
"invalid"
|
||||
);
|
||||
std::fs::write(&path, b"next\r\n").unwrap();
|
||||
assert_eq!(load_token(&peer(path)).unwrap().expose(), "next");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_empty_oversize_and_non_utf8_without_echoing_bytes() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let empty = dir.write("empty", b"", 0o600);
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(empty), None).unwrap_err()),
|
||||
"empty"
|
||||
);
|
||||
let newline = dir.write("nl", b"\n", 0o600);
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(newline), None).unwrap_err()),
|
||||
"empty"
|
||||
);
|
||||
|
||||
let exact = dir.write("exact", &vec![b'a'; MAX_TOKEN_BYTES], 0o600);
|
||||
let loaded = load_token_at(&peer(exact), None).unwrap();
|
||||
assert_eq!(loaded.expose().len(), MAX_TOKEN_BYTES);
|
||||
assert!(!format!("{loaded:?}").contains("aaa"));
|
||||
|
||||
let big = dir.write("big", &vec![b'Z'; MAX_TOKEN_BYTES + 1], 0o600);
|
||||
let err = load_token_at(&peer(big), None).unwrap_err();
|
||||
let text = format!("{err:?}");
|
||||
assert!(text.contains("larger than"));
|
||||
assert!(!text.contains(&"Z".repeat(20)));
|
||||
|
||||
let binary = dir.write("bin", &[0xff, 0xfe], 0o600);
|
||||
let err = token_err(load_token_at(&peer(binary), None).unwrap_err());
|
||||
assert_eq!(err, "not utf-8");
|
||||
assert!(!err.contains('\u{ff}'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tokens_that_cannot_be_a_header_value_are_refused() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
for (name, body) in [
|
||||
("crlf", b"a\r\nb\n".to_vec()),
|
||||
("mid-newline", b"a\nb".to_vec()),
|
||||
("mid-cr", b"a\rb".to_vec()),
|
||||
("nul", b"a\0b".to_vec()),
|
||||
("del", b"a\x7fb".to_vec()),
|
||||
] {
|
||||
let path = dir.write(name, &body, 0o600);
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(path), None).unwrap_err()),
|
||||
"invalid",
|
||||
"{name}"
|
||||
);
|
||||
}
|
||||
// A visible token with no control characters still loads.
|
||||
let ok = dir.write("ok", b"slinuxm_abc-123\n", 0o600);
|
||||
assert_eq!(
|
||||
load_token_at(&peer(ok), None).unwrap().expose(),
|
||||
"slinuxm_abc-123"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn group_readable_files_are_rejected_unless_under_the_credentials_dir() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let creds = dir.path().join("creds");
|
||||
let evil = dir.path().join("creds-evil");
|
||||
std::fs::create_dir_all(&creds).unwrap();
|
||||
std::fs::create_dir_all(&evil).unwrap();
|
||||
let inside = dir.write("creds/token", format!("{SECRET}\n").as_bytes(), 0o644);
|
||||
let outside = dir.write("creds-evil/token", format!("{SECRET}\n").as_bytes(), 0o640);
|
||||
|
||||
let err = token_err(load_token_at(&peer(outside.clone()), Some(&creds)).unwrap_err());
|
||||
assert!(err.contains("group or world accessible"), "{err}");
|
||||
assert!(!err.contains("SHOULD_NOT_LEAK"), "{err}");
|
||||
|
||||
let loaded = load_token_at(&peer(inside), Some(creds.as_path())).unwrap();
|
||||
assert_eq!(loaded.expose(), SECRET);
|
||||
assert!(!format!("{loaded:?}").contains("SHOULD_NOT_LEAK"));
|
||||
|
||||
let private = dir.write("private", format!("{SECRET}\n").as_bytes(), 0o600);
|
||||
assert_eq!(
|
||||
load_token_at(&peer(private), None).unwrap().expose(),
|
||||
SECRET
|
||||
);
|
||||
|
||||
let private = dir.write("logged", format!("{SECRET}\n").as_bytes(), 0o600);
|
||||
let logs = logged(|| {
|
||||
load_token_at(&peer(private), None).unwrap();
|
||||
});
|
||||
assert!(!logs.contains("SHOULD_NOT_LEAK"), "{logs}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn group_or_world_write_and_execute_bits_are_rejected_too() {
|
||||
// Any group or world access lets another user read the token (r, x on
|
||||
// a readable file) or swap it (w). Each mode below sets a different
|
||||
// bit, so a mask that misses one bit still passes the others.
|
||||
let dir = TempDir::new("peer-secret");
|
||||
for mode in [0o620, 0o602, 0o610, 0o601] {
|
||||
let path = dir.write(&format!("token-{mode:o}"), b"pending\n", mode);
|
||||
let err = token_err(load_token_at(&peer(path), None).unwrap_err());
|
||||
assert_eq!(err, "group or world accessible", "{mode:o}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_fifo_is_refused_without_waiting_for_a_writer() {
|
||||
use std::os::unix::ffi::OsStrExt;
|
||||
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let fifo = dir.path().join("fifo");
|
||||
let c_path = std::ffi::CString::new(fifo.as_os_str().as_bytes()).unwrap();
|
||||
// SAFETY: mkfifo only reads the path string; the mode is a literal.
|
||||
assert_eq!(unsafe { libc::mkfifo(c_path.as_ptr(), 0o600) }, 0);
|
||||
|
||||
// Opening a FIFO for reading blocks until a writer appears, which
|
||||
// would park a blocking-pool thread on every check and proxy call.
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let peer = peer(fifo);
|
||||
std::thread::spawn(move || {
|
||||
let _ = tx.send(token_err(load_token_at(&peer, None).unwrap_err()));
|
||||
});
|
||||
let err = rx
|
||||
.recv_timeout(std::time::Duration::from_secs(5))
|
||||
.expect("the token loader must not wait on a fifo");
|
||||
assert_eq!(err, "not a file");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_symlink_cannot_borrow_the_credentials_directory_exemption() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let creds = dir.path().join("creds");
|
||||
std::fs::create_dir_all(&creds).unwrap();
|
||||
let outside = dir.write("outside/token", format!("{SECRET}\n").as_bytes(), 0o644);
|
||||
let link = creds.join("peer-beta");
|
||||
std::os::unix::fs::symlink(&outside, &link).unwrap();
|
||||
|
||||
// The link lives under the credential directory, its target does not:
|
||||
// the target's mode decides, so the loose file is refused.
|
||||
let err = token_err(load_token_at(&peer(link), Some(&creds)).unwrap_err());
|
||||
assert!(err.contains("group or world accessible"), "{err}");
|
||||
|
||||
// A private target behind the same link is fine.
|
||||
std::fs::set_permissions(
|
||||
&outside,
|
||||
std::os::unix::fs::PermissionsExt::from_mode(0o600),
|
||||
)
|
||||
.unwrap();
|
||||
let loaded = load_token_at(&peer(creds.join("peer-beta")), Some(&creds)).unwrap();
|
||||
assert_eq!(loaded.expose(), SECRET);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_directory_is_not_a_token_file() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let nested = dir.path().join("as-a-dir");
|
||||
std::fs::create_dir_all(&nested).unwrap();
|
||||
assert_eq!(
|
||||
token_err(load_token_at(&peer(nested), None).unwrap_err()),
|
||||
"not a file"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_file_names_no_secret() {
|
||||
let dir = TempDir::new("peer-secret");
|
||||
let missing = dir.path().join("not-there");
|
||||
let err = token_err(load_token_at(&peer(missing), Some(Path::new(""))).unwrap_err());
|
||||
assert!(err.contains("not readable"), "{err}");
|
||||
assert!(!err.contains(SECRET));
|
||||
}
|
||||
+4
-187
@@ -23,44 +23,8 @@ const DEFAULT_PING_BODY: &str = r#"{"status":"ok","version":"0.0.0-fake"}"#;
|
||||
|
||||
/// Capture of `tracing` events for tests that assert nothing leaks into logs.
|
||||
#[cfg(test)]
|
||||
pub(crate) mod capture {
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
|
||||
struct Layer(Arc<Mutex<Vec<String>>>);
|
||||
|
||||
impl<S: tracing::Subscriber> tracing_subscriber::Layer<S> for Layer {
|
||||
fn on_event(
|
||||
&self,
|
||||
event: &tracing::Event<'_>,
|
||||
_ctx: tracing_subscriber::layer::Context<'_, S>,
|
||||
) {
|
||||
let mut msg = String::new();
|
||||
event.record(&mut FieldVisit(&mut msg));
|
||||
self.0.lock().expect("log lock").push(msg);
|
||||
}
|
||||
}
|
||||
|
||||
struct FieldVisit<'a>(&'a mut String);
|
||||
|
||||
impl tracing::field::Visit for FieldVisit<'_> {
|
||||
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
|
||||
use std::fmt::Write;
|
||||
let _ = write!(self.0, "{}={value:?} ", field.name());
|
||||
}
|
||||
}
|
||||
|
||||
/// Run `f` under a subscriber that records every event, and return the
|
||||
/// rendered fields joined by newlines.
|
||||
pub(crate) fn logged(f: impl FnOnce()) -> String {
|
||||
let buf = Arc::new(Mutex::new(Vec::new()));
|
||||
let sub = tracing_subscriber::registry().with(Layer(buf.clone()));
|
||||
tracing::subscriber::with_default(sub, f);
|
||||
let text = buf.lock().expect("log lock").join("\n");
|
||||
text
|
||||
}
|
||||
}
|
||||
#[path = "capture.rs"]
|
||||
pub(crate) mod capture;
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Scripted {
|
||||
@@ -390,152 +354,5 @@ impl Drop for TempDir {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn defaults_are_healthy_for_ping_and_404_elsewhere() {
|
||||
let fake = FakeTransport::new();
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let peer = &cfg.peer[0];
|
||||
|
||||
let latency = fake.tcp_check(peer, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(latency, Duration::from_millis(1));
|
||||
|
||||
let req = PeerRequest {
|
||||
path: "/api/v1/ping".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
let resp = fake.get(peer, req, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(resp.status, 200);
|
||||
match resp.body {
|
||||
PeerBody::Bytes(b) => {
|
||||
assert!(b.windows(10).any(|w| w == b"0.0.0-fake"))
|
||||
}
|
||||
PeerBody::Stream(_) => panic!("expected buffered body"),
|
||||
}
|
||||
|
||||
let req = PeerRequest {
|
||||
path: "/systemd/units".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
let resp = fake.get(peer, req, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(resp.status, 404);
|
||||
assert_eq!(fake.calls().len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn scripts_first_match_wins_and_record_calls() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/systemd/units", 200, "application/json", "{\"a\":1}")
|
||||
.respond("/systemd", 500, "application/json", "{}")
|
||||
.respond_err("/docker", PeerError::Timeout);
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let peer = &cfg.peer[0];
|
||||
let get = |path: &str| PeerRequest {
|
||||
path: path.into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
|
||||
let r = fake
|
||||
.get(
|
||||
peer,
|
||||
get("/systemd/units?state=failed"),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(r.status, 200);
|
||||
let r = fake
|
||||
.get(peer, get("/systemd/timers"), Duration::from_secs(1))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(r.status, 500);
|
||||
assert!(matches!(
|
||||
fake.get(peer, get("/docker/containers"), Duration::from_secs(1))
|
||||
.await,
|
||||
Err(PeerError::Timeout)
|
||||
));
|
||||
let calls = fake.calls();
|
||||
assert_eq!(calls.len(), 3);
|
||||
assert_eq!(calls[0].0.as_str(), "beta");
|
||||
assert_eq!(calls[0].1.path, "/systemd/units?state=failed");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn streams_chunks() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").stream(
|
||||
"/journal/follow",
|
||||
vec![Bytes::from_static(b"a"), Bytes::from_static(b"b")],
|
||||
);
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let req = PeerRequest {
|
||||
path: "/journal/follow".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: Some("text/event-stream".into()),
|
||||
};
|
||||
let resp = fake
|
||||
.get(&cfg.peer[0], req, Duration::from_secs(1))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(resp.content_type.as_deref(), Some("text/event-stream"));
|
||||
match resp.body {
|
||||
PeerBody::Stream(mut s) => {
|
||||
use futures::StreamExt;
|
||||
let first = s.next().await.unwrap().unwrap();
|
||||
assert_eq!(first, Bytes::from_static(b"a"));
|
||||
}
|
||||
PeerBody::Bytes(_) => panic!("expected stream"),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn per_peer_isolation_and_delay() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/systemd/units", PeerError::Rejected)
|
||||
.delay(Duration::from_millis(5));
|
||||
let cfg = fake_peers_config(&["beta", "gamma"]);
|
||||
let beta = cfg.peer.iter().find(|p| p.name.as_str() == "beta").unwrap();
|
||||
let gamma = cfg
|
||||
.peer
|
||||
.iter()
|
||||
.find(|p| p.name.as_str() == "gamma")
|
||||
.unwrap();
|
||||
let get = || PeerRequest {
|
||||
path: "/systemd/units".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
let started = tokio::time::Instant::now();
|
||||
assert!(matches!(
|
||||
fake.get(beta, get(), Duration::from_secs(1)).await,
|
||||
Err(PeerError::Rejected)
|
||||
));
|
||||
assert!(started.elapsed() >= Duration::from_millis(5));
|
||||
|
||||
let started = tokio::time::Instant::now();
|
||||
let latency = fake.tcp_check(beta, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(latency, Duration::from_millis(1));
|
||||
assert!(started.elapsed() >= Duration::from_millis(5));
|
||||
|
||||
// gamma keeps the default 404 and is not delayed.
|
||||
let started = tokio::time::Instant::now();
|
||||
let r = fake
|
||||
.get(gamma, get(), Duration::from_secs(1))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(r.status, 404);
|
||||
assert_eq!(started.elapsed(), Duration::ZERO);
|
||||
}
|
||||
}
|
||||
#[path = "testing_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,147 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn defaults_are_healthy_for_ping_and_404_elsewhere() {
|
||||
let fake = FakeTransport::new();
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let peer = &cfg.peer[0];
|
||||
|
||||
let latency = fake.tcp_check(peer, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(latency, Duration::from_millis(1));
|
||||
|
||||
let req = PeerRequest {
|
||||
path: "/api/v1/ping".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
let resp = fake.get(peer, req, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(resp.status, 200);
|
||||
match resp.body {
|
||||
PeerBody::Bytes(b) => {
|
||||
assert!(b.windows(10).any(|w| w == b"0.0.0-fake"))
|
||||
}
|
||||
PeerBody::Stream(_) => panic!("expected buffered body"),
|
||||
}
|
||||
|
||||
let req = PeerRequest {
|
||||
path: "/systemd/units".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
let resp = fake.get(peer, req, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(resp.status, 404);
|
||||
assert_eq!(fake.calls().len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn scripts_first_match_wins_and_record_calls() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond("/systemd/units", 200, "application/json", "{\"a\":1}")
|
||||
.respond("/systemd", 500, "application/json", "{}")
|
||||
.respond_err("/docker", PeerError::Timeout);
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let peer = &cfg.peer[0];
|
||||
let get = |path: &str| PeerRequest {
|
||||
path: path.into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
|
||||
let r = fake
|
||||
.get(
|
||||
peer,
|
||||
get("/systemd/units?state=failed"),
|
||||
Duration::from_secs(1),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(r.status, 200);
|
||||
let r = fake
|
||||
.get(peer, get("/systemd/timers"), Duration::from_secs(1))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(r.status, 500);
|
||||
assert!(matches!(
|
||||
fake.get(peer, get("/docker/containers"), Duration::from_secs(1))
|
||||
.await,
|
||||
Err(PeerError::Timeout)
|
||||
));
|
||||
let calls = fake.calls();
|
||||
assert_eq!(calls.len(), 3);
|
||||
assert_eq!(calls[0].0.as_str(), "beta");
|
||||
assert_eq!(calls[0].1.path, "/systemd/units?state=failed");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn streams_chunks() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta").stream(
|
||||
"/journal/follow",
|
||||
vec![Bytes::from_static(b"a"), Bytes::from_static(b"b")],
|
||||
);
|
||||
let cfg = fake_peers_config(&["beta"]);
|
||||
let req = PeerRequest {
|
||||
path: "/journal/follow".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: Some("text/event-stream".into()),
|
||||
};
|
||||
let resp = fake
|
||||
.get(&cfg.peer[0], req, Duration::from_secs(1))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(resp.content_type.as_deref(), Some("text/event-stream"));
|
||||
match resp.body {
|
||||
PeerBody::Stream(mut s) => {
|
||||
use futures::StreamExt;
|
||||
let first = s.next().await.unwrap().unwrap();
|
||||
assert_eq!(first, Bytes::from_static(b"a"));
|
||||
}
|
||||
PeerBody::Bytes(_) => panic!("expected stream"),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn per_peer_isolation_and_delay() {
|
||||
let fake = FakeTransport::new();
|
||||
fake.peer("beta")
|
||||
.respond_err("/systemd/units", PeerError::Rejected)
|
||||
.delay(Duration::from_millis(5));
|
||||
let cfg = fake_peers_config(&["beta", "gamma"]);
|
||||
let beta = cfg.peer.iter().find(|p| p.name.as_str() == "beta").unwrap();
|
||||
let gamma = cfg
|
||||
.peer
|
||||
.iter()
|
||||
.find(|p| p.name.as_str() == "gamma")
|
||||
.unwrap();
|
||||
let get = || PeerRequest {
|
||||
path: "/systemd/units".into(),
|
||||
query: vec![],
|
||||
headers: vec![],
|
||||
accept: None,
|
||||
};
|
||||
let started = tokio::time::Instant::now();
|
||||
assert!(matches!(
|
||||
fake.get(beta, get(), Duration::from_secs(1)).await,
|
||||
Err(PeerError::Rejected)
|
||||
));
|
||||
assert!(started.elapsed() >= Duration::from_millis(5));
|
||||
|
||||
let started = tokio::time::Instant::now();
|
||||
let latency = fake.tcp_check(beta, Duration::from_secs(1)).await.unwrap();
|
||||
assert_eq!(latency, Duration::from_millis(1));
|
||||
assert!(started.elapsed() >= Duration::from_millis(5));
|
||||
|
||||
// gamma keeps the default 404 and is not delayed.
|
||||
let started = tokio::time::Instant::now();
|
||||
let r = fake
|
||||
.get(gamma, get(), Duration::from_secs(1))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(r.status, 404);
|
||||
assert_eq!(started.elapsed(), Duration::ZERO);
|
||||
}
|
||||
+2
-135
@@ -249,138 +249,5 @@ impl CheckClass {
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn peer(name: &str, url: &str) -> PeerConfig {
|
||||
PeerConfig {
|
||||
name: PeerName::parse(name).unwrap(),
|
||||
url: Url::parse(url).unwrap(),
|
||||
token_file: PathBuf::from(format!("/run/peers/{name}.token")),
|
||||
ca_file: None,
|
||||
allow_plain_http: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_name_accepts_and_rejects() {
|
||||
assert!(PeerName::parse("a").is_ok());
|
||||
assert!(PeerName::parse("minipc1").is_ok());
|
||||
assert!(PeerName::parse("a_b-c9").is_ok());
|
||||
assert!(PeerName::parse(&"a".repeat(32)).is_ok());
|
||||
for bad in ["", "-a", "_a", "Beta", "beta!", "a b", &"a".repeat(33)] {
|
||||
assert!(PeerName::parse(bad).is_err(), "{bad:?} should be rejected");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_name_serde_roundtrip_and_validation() {
|
||||
let n = PeerName::parse("beta").unwrap();
|
||||
let json = serde_json::to_string(&n).unwrap();
|
||||
assert_eq!(json, "\"beta\"");
|
||||
assert_eq!(serde_json::from_str::<PeerName>(&json).unwrap(), n);
|
||||
assert!(serde_json::from_str::<PeerName>("\"Beta\"").is_err());
|
||||
assert_eq!(n.to_string(), "beta");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secret_redacts_debug_and_display() {
|
||||
let s = Secret::new("slinuxm_super_secret");
|
||||
assert_eq!(s.expose(), "slinuxm_super_secret");
|
||||
assert!(!format!("{s:?}").contains("super"));
|
||||
assert!(!format!("{s}").contains("super"));
|
||||
assert_eq!(format!("{s:?}"), "Secret(***)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_defaults_are_off() {
|
||||
let c = PeersConfig::default();
|
||||
assert!(!c.enabled);
|
||||
assert!(c.peer.is_empty());
|
||||
assert_eq!(c.tcp_interval_secs, 10);
|
||||
assert_eq!(c.request_timeout_secs, 10);
|
||||
assert_eq!(c.max_response_bytes, 8 * 1024 * 1024);
|
||||
assert_eq!(
|
||||
c.deny_cidrs,
|
||||
vec![
|
||||
"169.254.0.0/16",
|
||||
"0.0.0.0/8",
|
||||
"fe80::/10",
|
||||
"::/128",
|
||||
"fd00:ec2::254/128",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_toml_keeps_defaults() {
|
||||
let c: PeersConfig = toml::from_str("enabled = true\napi_interval_secs = 7\n").unwrap();
|
||||
assert!(c.enabled);
|
||||
assert_eq!(c.api_interval_secs, 7);
|
||||
assert_eq!(c.tcp_interval_secs, 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_entry_omits_optional_keys() {
|
||||
let c: PeersConfig = toml::from_str(
|
||||
r#"
|
||||
[[peer]]
|
||||
name = "beta"
|
||||
url = "http://beta:1984"
|
||||
token_file = "/run/credentials/skyg-linux-tracker.service/peer-beta"
|
||||
allow_plain_http = true
|
||||
|
||||
[[peer]]
|
||||
name = "delta"
|
||||
url = "https://delta:1984"
|
||||
token_file = "/run/credentials/skyg-linux-tracker.service/peer-delta"
|
||||
enabled = false
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert!(c.peer[0].enabled);
|
||||
assert!(c.peer[0].allow_plain_http);
|
||||
assert!(c.peer[0].ca_file.is_none());
|
||||
assert!(!c.peer[1].enabled);
|
||||
assert!(!c.peer[1].allow_plain_http);
|
||||
assert!(c.peer[1].ca_file.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn display_url_drops_normalized_root_path() {
|
||||
assert_eq!(
|
||||
peer("beta", "http://beta:1984").display_url(),
|
||||
"http://beta:1984"
|
||||
);
|
||||
assert_eq!(
|
||||
peer("beta", "https://beta:1984/").display_url(),
|
||||
"https://beta:1984"
|
||||
);
|
||||
assert_eq!(
|
||||
peer("beta", "https://beta:1984/base").display_url(),
|
||||
"https://beta:1984/base"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_json_shape() {
|
||||
let st = PeerStatus {
|
||||
name: PeerName::parse("beta").unwrap(),
|
||||
enabled: true,
|
||||
url: "http://beta:1984".into(),
|
||||
server: ServerStatus::default(),
|
||||
api: ApiStatus::default(),
|
||||
};
|
||||
let v = serde_json::to_value(&st).unwrap();
|
||||
assert_eq!(v["name"], "beta");
|
||||
assert_eq!(v["server"]["up"], serde_json::json!(false));
|
||||
assert_eq!(v["server"]["since"], serde_json::Value::Null);
|
||||
assert_eq!(v["api"]["auth"], "unknown");
|
||||
assert_eq!(
|
||||
serde_json::to_value(CheckClass::TlsError).unwrap(),
|
||||
"tls_error"
|
||||
);
|
||||
assert_eq!(serde_json::to_value(AuthState::Ok).unwrap(), "ok");
|
||||
}
|
||||
}
|
||||
#[path = "types_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,133 @@
|
||||
use super::*;
|
||||
|
||||
fn peer(name: &str, url: &str) -> PeerConfig {
|
||||
PeerConfig {
|
||||
name: PeerName::parse(name).unwrap(),
|
||||
url: Url::parse(url).unwrap(),
|
||||
token_file: PathBuf::from(format!("/run/peers/{name}.token")),
|
||||
ca_file: None,
|
||||
allow_plain_http: false,
|
||||
enabled: true,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_name_accepts_and_rejects() {
|
||||
assert!(PeerName::parse("a").is_ok());
|
||||
assert!(PeerName::parse("minipc1").is_ok());
|
||||
assert!(PeerName::parse("a_b-c9").is_ok());
|
||||
assert!(PeerName::parse(&"a".repeat(32)).is_ok());
|
||||
for bad in ["", "-a", "_a", "Beta", "beta!", "a b", &"a".repeat(33)] {
|
||||
assert!(PeerName::parse(bad).is_err(), "{bad:?} should be rejected");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_name_serde_roundtrip_and_validation() {
|
||||
let n = PeerName::parse("beta").unwrap();
|
||||
let json = serde_json::to_string(&n).unwrap();
|
||||
assert_eq!(json, "\"beta\"");
|
||||
assert_eq!(serde_json::from_str::<PeerName>(&json).unwrap(), n);
|
||||
assert!(serde_json::from_str::<PeerName>("\"Beta\"").is_err());
|
||||
assert_eq!(n.to_string(), "beta");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn secret_redacts_debug_and_display() {
|
||||
let s = Secret::new("slinuxm_super_secret");
|
||||
assert_eq!(s.expose(), "slinuxm_super_secret");
|
||||
assert!(!format!("{s:?}").contains("super"));
|
||||
assert!(!format!("{s}").contains("super"));
|
||||
assert_eq!(format!("{s:?}"), "Secret(***)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_defaults_are_off() {
|
||||
let c = PeersConfig::default();
|
||||
assert!(!c.enabled);
|
||||
assert!(c.peer.is_empty());
|
||||
assert_eq!(c.tcp_interval_secs, 10);
|
||||
assert_eq!(c.request_timeout_secs, 10);
|
||||
assert_eq!(c.max_response_bytes, 8 * 1024 * 1024);
|
||||
assert_eq!(
|
||||
c.deny_cidrs,
|
||||
vec![
|
||||
"169.254.0.0/16",
|
||||
"0.0.0.0/8",
|
||||
"fe80::/10",
|
||||
"::/128",
|
||||
"fd00:ec2::254/128",
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_toml_keeps_defaults() {
|
||||
let c: PeersConfig = toml::from_str("enabled = true\napi_interval_secs = 7\n").unwrap();
|
||||
assert!(c.enabled);
|
||||
assert_eq!(c.api_interval_secs, 7);
|
||||
assert_eq!(c.tcp_interval_secs, 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peer_entry_omits_optional_keys() {
|
||||
let c: PeersConfig = toml::from_str(
|
||||
r#"
|
||||
[[peer]]
|
||||
name = "beta"
|
||||
url = "http://beta:1984"
|
||||
token_file = "/run/credentials/skyg-linux-tracker.service/peer-beta"
|
||||
allow_plain_http = true
|
||||
|
||||
[[peer]]
|
||||
name = "delta"
|
||||
url = "https://delta:1984"
|
||||
token_file = "/run/credentials/skyg-linux-tracker.service/peer-delta"
|
||||
enabled = false
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert!(c.peer[0].enabled);
|
||||
assert!(c.peer[0].allow_plain_http);
|
||||
assert!(c.peer[0].ca_file.is_none());
|
||||
assert!(!c.peer[1].enabled);
|
||||
assert!(!c.peer[1].allow_plain_http);
|
||||
assert!(c.peer[1].ca_file.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn display_url_drops_normalized_root_path() {
|
||||
assert_eq!(
|
||||
peer("beta", "http://beta:1984").display_url(),
|
||||
"http://beta:1984"
|
||||
);
|
||||
assert_eq!(
|
||||
peer("beta", "https://beta:1984/").display_url(),
|
||||
"https://beta:1984"
|
||||
);
|
||||
assert_eq!(
|
||||
peer("beta", "https://beta:1984/base").display_url(),
|
||||
"https://beta:1984/base"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_json_shape() {
|
||||
let st = PeerStatus {
|
||||
name: PeerName::parse("beta").unwrap(),
|
||||
enabled: true,
|
||||
url: "http://beta:1984".into(),
|
||||
server: ServerStatus::default(),
|
||||
api: ApiStatus::default(),
|
||||
};
|
||||
let v = serde_json::to_value(&st).unwrap();
|
||||
assert_eq!(v["name"], "beta");
|
||||
assert_eq!(v["server"]["up"], serde_json::json!(false));
|
||||
assert_eq!(v["server"]["since"], serde_json::Value::Null);
|
||||
assert_eq!(v["api"]["auth"], "unknown");
|
||||
assert_eq!(
|
||||
serde_json::to_value(CheckClass::TlsError).unwrap(),
|
||||
"tls_error"
|
||||
);
|
||||
assert_eq!(serde_json::to_value(AuthState::Ok).unwrap(), "ok");
|
||||
}
|
||||
Reference in new issue
Block a user