WS-I: review fixes (connection cap, header timeout, SIGHUP on plain path, HTTP/1.1 only)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
c5972b762f
commit
9f2bbc7d14
6 files changed
+252
-18
No files matched your search
+166
@@ -497,3 +497,169 @@ async fn sigterm_with_open_tls_connections_exits_promptly() {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
}
|
||||
|
||||
/// In-process TLS listener with explicit limits.
|
||||
async fn inproc(
|
||||
pair: &Pair,
|
||||
limits: skyg_linux_tracker::tls::Limits,
|
||||
) -> (u16, tokio_util::sync::CancellationToken, tempdir::Dir) {
|
||||
use skyg_linux_tracker::{config::Config, server, sources::fake::fake_state, tls};
|
||||
let dir = tempdir::Dir::new("inproc");
|
||||
let (c, k) = write_pair(&dir.0, pair);
|
||||
let mut cfg = Config::default();
|
||||
cfg.auth.enabled = false;
|
||||
cfg.server.tls.enabled = true;
|
||||
cfg.server.tls.cert_file = c;
|
||||
cfg.server.tls.key_file = k;
|
||||
let cert = tls::ReloadableCert::load(&cfg.server.tls).unwrap();
|
||||
let acceptor = tls::acceptor(cert).unwrap();
|
||||
let state = fake_state(cfg);
|
||||
let shutdown = state.shutdown.clone();
|
||||
let app = server::build_router(state);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
tokio::spawn(tls::serve_tls(
|
||||
listener,
|
||||
acceptor,
|
||||
app,
|
||||
shutdown.clone(),
|
||||
limits,
|
||||
));
|
||||
(port, shutdown, dir)
|
||||
}
|
||||
|
||||
async fn handshake(
|
||||
port: u16,
|
||||
pair: &Pair,
|
||||
) -> std::io::Result<tokio_rustls::client::TlsStream<TcpStream>> {
|
||||
let tcp = TcpStream::connect(("127.0.0.1", port)).await?;
|
||||
connector(pair)
|
||||
.connect(ServerName::try_from("localhost").unwrap(), tcp)
|
||||
.await
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn silent_connection_closed_after_header_timeout() {
|
||||
let pair = gen_pair();
|
||||
let (port, shutdown, _d) = inproc(
|
||||
&pair,
|
||||
skyg_linux_tracker::tls::Limits {
|
||||
max_conns: 16,
|
||||
header_timeout: Duration::from_millis(500),
|
||||
},
|
||||
)
|
||||
.await;
|
||||
let mut c = handshake(port, &pair).await.unwrap();
|
||||
let start = Instant::now();
|
||||
let mut buf = [0u8; 256];
|
||||
let r = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
match c.read(&mut buf).await {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(_) => {}
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
assert!(r.is_ok(), "silent post-handshake connection was not closed");
|
||||
assert!(start.elapsed() < Duration::from_secs(4));
|
||||
shutdown.cancel();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connection_cap_is_enforced() {
|
||||
let pair = gen_pair();
|
||||
let (port, shutdown, _d) = inproc(
|
||||
&pair,
|
||||
skyg_linux_tracker::tls::Limits {
|
||||
max_conns: 2,
|
||||
header_timeout: Duration::from_secs(30),
|
||||
},
|
||||
)
|
||||
.await;
|
||||
let c1 = handshake(port, &pair).await.unwrap();
|
||||
let c2 = handshake(port, &pair).await.unwrap();
|
||||
let third = tokio::time::timeout(Duration::from_millis(800), handshake(port, &pair)).await;
|
||||
assert!(third.is_err(), "third connection was served beyond the cap");
|
||||
drop(c1);
|
||||
let c3 = tokio::time::timeout(Duration::from_secs(5), handshake(port, &pair)).await;
|
||||
assert!(c3.is_ok(), "slot was not released after a close");
|
||||
drop(c2);
|
||||
shutdown.cancel();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sighup_with_tls_disabled_keeps_serving() {
|
||||
use std::io::{Read, Write};
|
||||
let dir = tempdir::Dir::new("plainhup");
|
||||
let port = free_port();
|
||||
let f = dir.0.join("c.toml");
|
||||
std::fs::write(
|
||||
&f,
|
||||
format!(
|
||||
"[server]\nport = {port}\n[auth]\ndb_path = {:?}\n",
|
||||
dir.0.join("db.sqlite").display().to_string()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
let mut child = Command::new(BIN)
|
||||
.args(["serve", "--config"])
|
||||
.arg(&f)
|
||||
.env_clear()
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let get = || -> Option<String> {
|
||||
let mut c = std::net::TcpStream::connect(("127.0.0.1", port)).ok()?;
|
||||
c.write_all(b"GET /healthz HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
|
||||
.ok()?;
|
||||
let mut s = String::new();
|
||||
let _ = c.read_to_string(&mut s);
|
||||
Some(s)
|
||||
};
|
||||
for _ in 0..100 {
|
||||
if get().is_some_and(|s| s.contains("200 OK")) {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
signal(&child, "-HUP");
|
||||
std::thread::sleep(Duration::from_millis(500));
|
||||
assert!(
|
||||
child.try_wait().unwrap().is_none(),
|
||||
"SIGHUP killed the process"
|
||||
);
|
||||
assert!(get().is_some_and(|s| s.contains("200 OK")));
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mismatched_pair_on_sighup_keeps_old_cert() {
|
||||
let a = gen_pair();
|
||||
let b = gen_pair();
|
||||
let s = start(&a);
|
||||
let fp_a = https(s.port, &a, "GET", "/healthz", &[], None)
|
||||
.await
|
||||
.peer_fp;
|
||||
// New cert B with old key A: mismatch, old pair kept.
|
||||
std::fs::write(s.dir.0.join("cert.pem"), &b.cert_pem).unwrap();
|
||||
signal(&s.child, "-HUP");
|
||||
tokio::time::sleep(Duration::from_millis(500)).await;
|
||||
let r = https(s.port, &a, "GET", "/healthz", &[], None).await;
|
||||
assert_eq!(r.peer_fp, fp_a);
|
||||
// Completing the rotation (key B) and sending HUP again works.
|
||||
std::fs::write(s.dir.0.join("key.pem"), &b.key_pem).unwrap();
|
||||
signal(&s.child, "-HUP");
|
||||
let mut fp = String::new();
|
||||
for _ in 0..30 {
|
||||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||||
fp = https(s.port, &b, "GET", "/healthz", &[], None)
|
||||
.await
|
||||
.peer_fp;
|
||||
if fp != fp_a {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_ne!(fp, fp_a);
|
||||
}
|
||||
Reference in new issue
Block a user