use std::convert::Infallible;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use http_body_util::combinators::BoxBody;
use hyper::body::Bytes;
use hyper::{Method, Response, StatusCode};
use crate::config::HealthConfig;
pub(crate) struct HealthState {
pub(crate) cfg: HealthConfig,
pub(crate) ready: Arc<AtomicBool>,
}
fn plain(status: StatusCode, body: &'static str) -> Response<BoxBody<Bytes, Infallible>> {
use http_body_util::BodyExt as _;
let mut resp =
Response::new(http_body_util::Full::new(Bytes::from_static(body.as_bytes())).boxed());
*resp.status_mut() = status;
resp.headers_mut().insert(
hyper::header::CONTENT_TYPE,
hyper::header::HeaderValue::from_static("text/plain; charset=utf-8"),
);
resp.headers_mut().insert(
hyper::header::CACHE_CONTROL,
hyper::header::HeaderValue::from_static("no-store"),
);
resp
}
impl HealthState {
pub(crate) fn answer(
&self,
method: &Method,
path: &str,
) -> Option<Response<BoxBody<Bytes, Infallible>>> {
if !matches!(*method, Method::GET | Method::HEAD) {
return None;
}
if path == self.cfg.liveness {
return Some(plain(StatusCode::OK, "ok"));
}
if path == self.cfg.readiness {
return Some(if self.ready.load(Ordering::Relaxed) {
plain(StatusCode::OK, "ok")
} else {
plain(StatusCode::SERVICE_UNAVAILABLE, "draining")
});
}
None
}
}
#[derive(Clone, Copy)]
pub(crate) struct ProbeGuards {
pub(crate) max_connections: usize,
pub(crate) header_read: Option<std::time::Duration>,
pub(crate) max_buf_size: usize,
}
pub(crate) async fn serve_probes(
listener: tokio::net::TcpListener,
state: Arc<HealthState>,
guards: ProbeGuards,
mut stop: tokio::sync::oneshot::Receiver<()>,
) {
use hyper_util::rt::{TokioIo, TokioTimer};
use hyper_util::server::graceful::GracefulShutdown;
use tokio::sync::Semaphore;
let slots = Arc::new(Semaphore::new(guards.max_connections.max(1)));
let http = {
let mut builder = hyper::server::conn::http1::Builder::new();
builder
.timer(TokioTimer::new())
.header_read_timeout(guards.header_read)
.max_buf_size(guards.max_buf_size);
builder
};
let graceful = GracefulShutdown::new();
loop {
let accepted = tokio::select! {
accepted = async {
#[allow(clippy::expect_used)]
let permit = slots
.clone()
.acquire_owned()
.await
.expect("probe connection semaphore is never closed");
(permit, listener.accept().await)
} => accepted,
_ = &mut stop => break,
};
let (permit, accepted) = accepted;
let stream = match accepted {
Ok((stream, _peer)) => stream,
Err(err) => {
crate::server::accept_error_backoff("probe listener", &err).await;
continue;
}
};
let state = state.clone();
let http = http.clone();
let watcher = graceful.watcher();
tokio::spawn(async move {
let _permit = permit;
let svc =
hyper::service::service_fn(move |req: hyper::Request<hyper::body::Incoming>| {
let state = state.clone();
async move {
Ok::<_, Infallible>(
state
.answer(req.method(), req.uri().path())
.unwrap_or_else(|| plain(StatusCode::NOT_FOUND, "not found")),
)
}
});
let conn = http.serve_connection(TokioIo::new(stream), svc);
let _ = watcher.watch(conn).await;
});
}
drop(listener);
graceful.shutdown().await;
}
#[cfg(test)]
mod tests {
use super::*;
fn state(ready: bool) -> HealthState {
HealthState {
cfg: HealthConfig::default(),
ready: Arc::new(AtomicBool::new(ready)),
}
}
#[test]
fn probes_answer_and_everything_else_passes_through() {
let s = state(true);
let resp = s.answer(&Method::GET, "/healthz").expect("liveness");
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers()["cache-control"], "no-store");
let resp = s.answer(&Method::HEAD, "/readyz").expect("readiness");
assert_eq!(resp.status(), StatusCode::OK);
assert!(s.answer(&Method::GET, "/health").is_none());
assert!(s.answer(&Method::GET, "/").is_none());
assert!(s.answer(&Method::POST, "/healthz").is_none());
}
#[test]
fn readiness_flips_with_the_drain_while_liveness_stays_up() {
let s = state(false);
let resp = s.answer(&Method::GET, "/readyz").expect("readiness");
assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
let resp = s.answer(&Method::GET, "/healthz").expect("liveness");
assert_eq!(resp.status(), StatusCode::OK);
}
}