use std::io::{Read, Write};
use std::net::{Ipv4Addr, SocketAddr, TcpStream};
use std::time::Duration;
pub const CONNECT_TIMEOUT: Duration = Duration::from_secs(2);
pub const IO_TIMEOUT: Duration = Duration::from_secs(2);
pub const DEFAULT_EXTERNAL_PORT: u16 = 8080;
pub const RESPONSE_CAP: usize = 8 * 1024;
pub fn parse_status_code(line: &str) -> Option<u16> {
let mut parts = line.split_whitespace();
let version = parts.next()?;
if !version.starts_with("HTTP/") {
return None;
}
parts.next()?.parse().ok()
}
pub fn is_healthy(code: u16) -> bool {
(200..300).contains(&code)
}
pub fn build_request(port: u16) -> String {
format!("GET /healthz HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n")
}
pub fn probe(port: u16) -> Result<u16, String> {
let addr = SocketAddr::from((Ipv4Addr::LOCALHOST, port));
let mut stream = TcpStream::connect_timeout(&addr, CONNECT_TIMEOUT)
.map_err(|e| format!("connect 127.0.0.1:{port} failed: {e}"))?;
stream
.set_read_timeout(Some(IO_TIMEOUT))
.map_err(|e| format!("set read timeout failed: {e}"))?;
stream
.set_write_timeout(Some(IO_TIMEOUT))
.map_err(|e| format!("set write timeout failed: {e}"))?;
stream
.write_all(build_request(port).as_bytes())
.map_err(|e| format!("send request failed: {e}"))?;
let mut buf: Vec<u8> = Vec::with_capacity(1024);
let mut chunk = [0u8; 512];
loop {
if buf.len() > RESPONSE_CAP {
return Err(format!(
"response exceeds {RESPONSE_CAP} bytes without a status line"
));
}
let n = stream
.read(&mut chunk)
.map_err(|e| format!("read response failed: {e}"))?;
if n == 0 {
return Err("connection closed before status line".to_string());
}
buf.extend_from_slice(&chunk[..n]);
if let Some(pos) = buf.windows(2).position(|w| w == b"\r\n") {
let line = String::from_utf8_lossy(&buf[..pos]);
return parse_status_code(&line)
.ok_or_else(|| format!("malformed status line: {line:?}"));
}
}
}
pub fn parse_port(value: Option<&str>) -> Result<u16, String> {
match value {
None => Ok(DEFAULT_EXTERNAL_PORT),
Some(v) if v.trim().is_empty() => Ok(DEFAULT_EXTERNAL_PORT),
Some(v) => v
.trim()
.parse::<u16>()
.map_err(|e| format!("invalid GARRISON_EXTERNAL_PORT={v:?}: {e}")),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::TcpListener;
use std::thread;
#[test]
fn parse_status_line_200() {
assert_eq!(parse_status_code("HTTP/1.1 200 OK"), Some(200));
}
#[test]
fn parse_status_line_503() {
assert_eq!(
parse_status_code("HTTP/1.1 503 Service Unavailable"),
Some(503)
);
}
#[test]
fn parse_status_line_malformed() {
assert_eq!(parse_status_code("garbage"), None);
assert_eq!(parse_status_code("HTTP/1.1 not-a-number"), None);
assert_eq!(parse_status_code(""), None);
assert_eq!(parse_status_code("HTTP/1.1"), None);
}
#[test]
fn healthy_boundary() {
assert!(is_healthy(200));
assert!(is_healthy(299));
assert!(!is_healthy(199));
assert!(!is_healthy(300));
assert!(!is_healthy(503));
}
#[test]
fn request_targets_healthz_with_close() {
let req = build_request(8080);
assert!(req.starts_with("GET /healthz HTTP/1.1\r\n"));
assert!(req.contains("Host: 127.0.0.1:8080\r\n"));
assert!(req.ends_with("Connection: close\r\n\r\n"));
}
fn serve_once(response: &'static str, close_without_reply: bool) -> u16 {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind ephemeral port");
let port = listener.local_addr().expect("local addr").port();
thread::spawn(move || {
let (mut conn, _) = listener.accept().expect("accept");
let mut buf = [0u8; 1024];
let _ = conn.read(&mut buf);
if !close_without_reply {
conn.write_all(response.as_bytes()).expect("write response");
}
});
port
}
#[test]
fn probe_ok_200_end_to_end() {
let port = serve_once(
"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
false,
);
assert_eq!(probe(port), Ok(200));
}
#[test]
fn probe_reports_503_status() {
let port = serve_once("HTTP/1.1 503 Service Unavailable\r\n\r\n", false);
assert_eq!(probe(port), Ok(503));
assert!(!is_healthy(503));
}
#[test]
fn probe_malformed_response_is_error() {
let port = serve_once("this is not http\r\n", false);
let err = probe(port).expect_err("malformed response must fail");
assert!(err.contains("malformed"), "unexpected reason: {err}");
}
#[test]
fn probe_closed_without_status_line_is_error() {
let port = serve_once("", true);
let err = probe(port).expect_err("connection closed early must fail");
assert!(err.contains("closed"), "unexpected reason: {err}");
}
#[test]
fn probe_connection_refused_is_error() {
let listener = TcpListener::bind("127.0.0.1:0").expect("bind ephemeral port");
let port = listener.local_addr().expect("local addr").port();
drop(listener);
assert!(probe(port).is_err());
}
#[test]
fn port_parsing() {
assert_eq!(parse_port(None), Ok(DEFAULT_EXTERNAL_PORT));
assert_eq!(parse_port(Some("")), Ok(DEFAULT_EXTERNAL_PORT));
assert_eq!(parse_port(Some(" ")), Ok(DEFAULT_EXTERNAL_PORT));
assert_eq!(parse_port(Some("9999")), Ok(9999));
assert_eq!(parse_port(Some(" 8080 ")), Ok(8080));
assert!(parse_port(Some("abc")).is_err());
assert!(parse_port(Some("70000")).is_err());
assert!(parse_port(Some("-1")).is_err());
}
}