//! GET /api/v1/docker/* handlers (WS-E) use axum::extract::rejection::QueryRejection; use axum::extract::{Path, Query, State}; use axum::response::sse::Event; use axum::response::{IntoResponse, Response}; use axum::routing::get; use axum::{Json, Router}; use jiff::Timestamp; use serde::Deserialize; use super::{query, sse_from}; use crate::error::AppError; use crate::sources::{ContainerStatus, ContainerSummary, LogLine, LogOptions, LogStream}; use crate::state::AppState; pub fn routes() -> Router { Router::new() .route("/docker/ps", get(ps)) .route("/docker/containers/{name}", get(container)) .route("/docker/containers/{name}/logs", get(logs)) } #[derive(Deserialize)] struct PsParams { all: Option, } /// Accepts `1|0|true|false`. fn parse_bool(name: &str, v: Option<&str>) -> Result { match v { None => Ok(false), Some("1" | "true") => Ok(true), Some("0" | "false") => Ok(false), Some(o) => Err(AppError::BadRequest(format!( "{name} must be 0, 1, true or false, got '{o}'" ))), } } async fn ps( State(st): State, q: Result, QueryRejection>, ) -> Result>, AppError> { let all = parse_bool("all", query(q)?.all.as_deref())?; Ok(Json(st.docker.ps(all).await?)) } async fn container( State(st): State, Path(name): Path, ) -> Result, AppError> { Ok(Json(st.docker.container_status(&name).await?)) } #[derive(Deserialize)] struct LogParams { tail: Option, since: Option, follow: Option, } async fn logs( State(st): State, Path(name): Path, q: Result, QueryRejection>, ) -> Result { let p = query(q)?; let follow = parse_bool("follow", p.follow.as_deref())?; if p.tail == Some(0) { return Err(AppError::BadRequest("tail must be at least 1".into())); } let opts = LogOptions { tail: p.tail.map(|n| n.min(st.config.limits.max_tail)), since: p.since, }; if !follow { return Ok(Json(st.docker.logs(&name, &opts).await?).into_response()); } let rx = st.docker.follow_logs(&name, &opts).await?; Ok(sse_from( rx, st.shutdown.clone(), st.config.limits.max_follow_secs, |l: &LogLine| { let ev = match l.stream { LogStream::Stdout => "stdout", LogStream::Stderr => "stderr", }; Event::default() .event(ev) .json_data(l) .unwrap_or_else(|_| Event::default().comment("serialize error")) }, ) .into_response()) } #[cfg(test)] mod tests { use std::sync::Arc; use async_trait::async_trait; use axum::http::StatusCode; use tokio::sync::mpsc; use crate::api::router; use crate::api::testutil::{get, json}; use crate::config::Config; use crate::error::AppError; use crate::sources::fake::fake_state; use crate::sources::{ContainerStatus, ContainerSummary, DockerSource, LogLine, LogOptions}; fn app() -> axum::Router { router(fake_state(Config::default())) } #[tokio::test] async fn ps_and_detail() { let (s, b) = get(&app(), "/docker/ps").await; assert_eq!(s, StatusCode::OK); assert_eq!(json(&b).as_array().unwrap().len(), 2); let (_, b) = get(&app(), "/docker/ps?all=1").await; assert_eq!(json(&b).as_array().unwrap().len(), 3); let (s, b) = get(&app(), "/docker/containers/web").await; assert_eq!(s, StatusCode::OK); assert_eq!(json(&b)["health"], "healthy"); } #[tokio::test] async fn errors_400_404() { let (s, _) = get(&app(), "/docker/containers/nope").await; assert_eq!(s, StatusCode::NOT_FOUND); let (s, _) = get(&app(), "/docker/containers/nope/logs").await; assert_eq!(s, StatusCode::NOT_FOUND); for u in [ "/docker/ps?all=maybe", "/docker/containers/web/logs?tail=abc", "/docker/containers/web/logs?tail=0", "/docker/containers/web/logs?follow=2", "/docker/containers/web/logs?since=nonsense", ] { let (s, b) = get(&app(), u).await; assert_eq!(s, StatusCode::BAD_REQUEST, "{u}"); assert_eq!(json(&b)["error"]["code"], "bad_request"); } } #[tokio::test] async fn logs_json() { let (s, b) = get(&app(), "/docker/containers/web/logs?follow=0").await; assert_eq!(s, StatusCode::OK); assert_eq!(json(&b).as_array().unwrap().len(), 2); let (_, b) = get(&app(), "/docker/containers/web/logs?tail=1").await; assert_eq!(json(&b)[0]["stream"], "stderr"); } #[tokio::test] async fn logs_sse_ends_on_shutdown() { let st = fake_state(Config::default()); let token = st.shutdown.clone(); let app = router(st); tokio::spawn(async move { tokio::time::sleep(std::time::Duration::from_millis(200)).await; token.cancel(); }); let (s, b) = get(&app, "/docker/containers/web/logs?follow=1").await; assert_eq!(s, StatusCode::OK); assert!(b.contains("event: stdout"), "{b}"); assert!(b.contains("event: stderr"), "{b}"); } struct Down; #[async_trait] impl DockerSource for Down { async fn ps(&self, _: bool) -> Result, AppError> { Err(AppError::Unavailable("docker socket".into())) } async fn container_status(&self, _: &str) -> Result { Err(AppError::Unavailable("docker socket".into())) } async fn logs(&self, _: &str, _: &LogOptions) -> Result, AppError> { Err(AppError::Unavailable("docker socket".into())) } async fn follow_logs( &self, _: &str, _: &LogOptions, ) -> Result, AppError> { Err(AppError::Unavailable("docker socket".into())) } } #[tokio::test] async fn docker_unavailable_isolated() { let mut st = fake_state(Config::default()); st.docker = Arc::new(Down); let app = router(st); for u in [ "/docker/ps", "/docker/containers/web", "/docker/containers/web/logs", "/docker/containers/web/logs?follow=1", ] { let (s, b) = get(&app, u).await; assert_eq!(s, StatusCode::SERVICE_UNAVAILABLE, "{u}"); assert_eq!(json(&b)["error"]["code"], "unavailable"); } for u in ["/systemd/units", "/systemd/timers", "/journal"] { let (s, _) = get(&app, u).await; assert_eq!(s, StatusCode::OK, "{u}"); } } }