mod error;
mod handlers;
mod progress;
mod types;
pub use error::StatusServerLifecycleError;
pub use types::{AtomicPhase, ScanPhase, StatusState, ThroughputWindow};
use axum::routing::get;
use axum::Router;
use tokio_util::sync::CancellationToken;
use handlers::{health_handler, metrics_handler, status_handler};
#[derive(Debug)]
pub struct StatusServerHandle {
shutdown: CancellationToken,
task: tokio::task::JoinHandle<Result<(), StatusServerLifecycleError>>,
}
impl StatusServerHandle {
pub async fn shutdown(self) -> Result<(), StatusServerLifecycleError> {
self.shutdown.cancel();
match self.task.await {
Ok(result) => result,
Err(join_error) => Err(StatusServerLifecycleError::from(join_error)),
}
}
}
pub fn build_router(state: StatusState) -> Router {
Router::new()
.route("/health", get(health_handler))
.route("/metrics", get(metrics_handler))
.route("/status", get(status_handler))
.with_state(state)
}
pub async fn spawn_status_server(
port: u16,
state: StatusState,
) -> Result<StatusServerHandle, StatusServerLifecycleError> {
let app = build_router(state);
let listener = tokio::net::TcpListener::bind(format!("127.0.0.1:{port}"))
.await
.map_err(|source| StatusServerLifecycleError::Bind { port, source })?;
log::info!("Status server listening on http://127.0.0.1:{port}/");
log::info!(" - Health: http://127.0.0.1:{port}/health");
log::info!(" - Metrics: http://127.0.0.1:{port}/metrics");
log::info!(" - Status: http://127.0.0.1:{port}/status");
let shutdown = CancellationToken::new();
let shutdown_signal = shutdown.clone();
let task = tokio::spawn(async move {
axum::serve(listener, app)
.with_graceful_shutdown(async move {
shutdown_signal.cancelled().await;
})
.await
.map_err(StatusServerLifecycleError::Serve)
});
Ok(StatusServerHandle { shutdown, task })
}
#[cfg(test)]
mod tests {
use super::*;
use axum::body::Body;
use axum::http::Request;
use tower::ServiceExt;
fn create_test_state() -> StatusState {
crate::status_server::types::test_status_state(100, 100, 50, 10, 0)
}
#[tokio::test]
async fn test_build_router_serves_health_endpoint() {
let app = build_router(create_test_state());
let response = app
.oneshot(
Request::builder()
.uri("/health")
.body(Body::empty())
.expect("request"),
)
.await
.expect("health response");
assert_eq!(response.status(), axum::http::StatusCode::OK);
}
#[tokio::test]
async fn test_build_router_serves_status_endpoint() {
let app = build_router(create_test_state());
let response = app
.oneshot(
Request::builder()
.uri("/status")
.body(Body::empty())
.expect("request"),
)
.await
.expect("status response");
assert_eq!(response.status(), axum::http::StatusCode::OK);
}
#[tokio::test]
async fn test_build_router_serves_metrics_endpoint() {
let app = build_router(create_test_state());
let response = app
.oneshot(
Request::builder()
.uri("/metrics")
.body(Body::empty())
.expect("request"),
)
.await
.expect("metrics response");
assert_eq!(response.status(), axum::http::StatusCode::OK);
}
#[tokio::test]
async fn test_spawn_status_server_returns_bind_error_for_in_use_port() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind listener");
let port = listener.local_addr().expect("local addr").port();
let error = spawn_status_server(port, create_test_state())
.await
.expect_err("port already bound should fail");
match &error {
StatusServerLifecycleError::Bind {
port: returned_port,
source,
} => {
assert_eq!(*returned_port, port);
let _ = source.kind();
}
other => panic!("expected StatusServerLifecycleError::Bind, got {other:?}"),
}
assert!(error.to_string().contains(&port.to_string()));
}
#[tokio::test]
async fn test_spawned_status_server_shuts_down_cleanly() {
let handle = spawn_status_server(0, create_test_state())
.await
.expect("status server should bind");
handle.shutdown().await.expect("shutdown should succeed");
}
}