Watch
0
0
Fork
You've already forked hyperhive
0

swarm-logs-auth, swarm-metrics-auth, swarm-authelia-bridge, swarm-controller: drain http on sigterm

This commit is contained in:
atlas 2026-11-18 03:28:12 +01:00 • committed by mara
commit a089da25a5
2 changed files with 198 additions and 19 deletions

View file

@ -21,3 +21,7 @@ tracing-subscriber.workspace = true
[lints]
workspace = true
[dev-dependencies]
# `Shared`, so the injected stop future can be cloned like `shutdown_signal`'s.
futures-util.workspace = true

View file

@ -195,6 +195,7 @@ async fn handle(
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let stop = swarm_secret_client::shutdown_signal();
swarm_secret_client::install_crypto_provider();
tracing_subscriber::fmt()
.with_env_filter(
@ -235,14 +236,31 @@ async fn main() -> anyhow::Result<()> {
tracing::info!(socket = %args.socket.display(), "swarm-logs-auth listening");
let app = axum::Router::new().fallback(handle).with_state(responder);
axum::serve(listener, app).await.context("serving")
serve(listener, app, stop).await
}
/// Answers on `listener` until `stop` resolves, then lets the requests in hand
/// finish, for at most the drain, and returns.
async fn serve(
listener: tokio::net::UnixListener,
app: axum::Router,
stop: impl Future<Output = ()> + Clone + Send + 'static,
) -> anyhow::Result<()> {
let serving = axum::serve(listener, app).with_graceful_shutdown(stop.clone());
swarm_secret_client::serve_bounded(stop, serving.into_future())
.await
.transpose()
.context("serving")?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use futures_util::FutureExt as _;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use swarm_secret_client::queue::AgentCredential;
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
/// What the mirrored grant leaf answers.
#[derive(Clone, Copy)]
@ -474,4 +492,59 @@ mod tests {
}
assert_eq!(store.lookups(), 3);
}
/// A request that is being answered when the stop arrives is still
/// answered, and `serve` returns only afterwards.
#[tokio::test]
async fn a_request_in_flight_at_the_stop_is_answered_before_serve_returns() {
let started = Arc::new(tokio::sync::Notify::new());
let release = Arc::new(tokio::sync::Notify::new());
let app = {
let (started, release) = (Arc::clone(&started), Arc::clone(&release));
axum::Router::new().fallback(move || {
let (started, release) = (Arc::clone(&started), Arc::clone(&release));
async move {
started.notify_one();
release.notified().await;
"answered"
}
})
};
let socket =
std::env::temp_dir().join(format!("swarm-logs-auth-stop-{}.sock", std::process::id()));
let _ = std::fs::remove_file(&socket);
let listener = tokio::net::UnixListener::bind(&socket).expect("bind");
let (stop_tx, stop_rx) = tokio::sync::oneshot::channel::<()>();
let stop = async move {
let _ = stop_rx.await;
}
.shared();
let mut serving = tokio::spawn(serve(listener, app, stop));
let mut conn = tokio::net::UnixStream::connect(&socket)
.await
.expect("connect");
conn.write_all(b"GET / HTTP/1.1\r\nhost: x\r\nconnection: close\r\n\r\n")
.await
.expect("send");
started.notified().await;
stop_tx.send(()).expect("stop");
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(
!serving.is_finished(),
"serve returned with a request in flight"
);
release.notify_one();
let mut reply = String::new();
conn.read_to_string(&mut reply).await.expect("reply");
assert!(reply.starts_with("HTTP/1.1 200"), "{reply}");
assert!(reply.ends_with("answered"), "{reply}");
let finished = tokio::time::timeout(Duration::from_secs(5), &mut serving)
.await
.expect("serve returns once the request is answered");
finished.expect("task").expect("serve is Ok");
let _ = std::fs::remove_file(&socket);
}
}