use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
use axum::extract::FromRequestParts;
use axum::extract::Path;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use axum::routing::{get, post};
use axum::Extension;
use axum::Router;
use serde_json::json;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, OnceLock};
use std::time::Duration;
use tokio::sync::broadcast;
use crate::domain::id::Id;
use crate::domain::models::task_model::Task;
use crate::domain::repositories::task_repository::TaskRepository;
use crate::infrastructure::events::event_bus::{DomainEvent, EventBus};
use crate::infrastructure::repositories::task_repo_impl::TaskRepositoryImpl;
use crate::presentation::middleware::auth_middleware::AuthState;
pub fn task_routes() -> Router {
Router::new()
.route(
"/v1/tasks/_query",
post(task_handler::query_tasks::<TaskRepositoryImpl>),
)
.route(
"/v1/tasks/_cancel",
post(task_handler::cancel_tasks::<TaskRepositoryImpl>),
)
.route("/v1/tasks/{id}/ws", get(task_status_ws))
}
pub struct TaskWsGuard {
live: AtomicUsize,
pub max_connections: usize,
pub idle_timeout: Duration,
}
static GLOBAL_GUARD: OnceLock<Arc<TaskWsGuard>> = OnceLock::new();
impl TaskWsGuard {
pub fn new(max_connections: usize, idle_timeout: Duration) -> Self {
Self {
live: AtomicUsize::new(0),
max_connections,
idle_timeout,
}
}
fn try_acquire(self: &Arc<Self>) -> Option<WsSlot> {
self.live
.try_update(Ordering::AcqRel, Ordering::Acquire, |live| {
(live < self.max_connections).then_some(live + 1)
})
.ok()
.map(|_| WsSlot(Arc::clone(self)))
}
fn release(&self) {
let _ = self
.live
.try_update(Ordering::AcqRel, Ordering::Acquire, |live| {
live.checked_sub(1)
});
}
fn live(&self) -> usize {
self.live.load(Ordering::Acquire)
}
}
struct WsSlot(Arc<TaskWsGuard>);
impl Drop for WsSlot {
fn drop(&mut self) {
self.0.release();
}
}
async fn task_status_ws(
Extension(repo): Extension<Arc<TaskRepositoryImpl>>,
Extension(bus): Extension<Arc<dyn EventBus>>,
auth: Option<Extension<AuthState>>,
guard: Option<Extension<Arc<TaskWsGuard>>>,
Path(task_id): Path<String>,
mut parts: axum::http::request::Parts,
) -> Response {
let Some(Extension(auth)) = auth else {
return (StatusCode::UNAUTHORIZED, "authentication required").into_response();
};
let Ok(id) = task_id.parse::<Id>() else {
return (StatusCode::BAD_REQUEST, "invalid task id").into_response();
};
let task: Task = match repo.find_by_id(id).await {
Ok(Some(task)) if task.team_id == auth.team_id => task,
Ok(_) => {
return (StatusCode::NOT_FOUND, "task not found").into_response();
}
Err(e) => {
log::error!("ws task lookup failed: {e}");
return (StatusCode::INTERNAL_SERVER_ERROR, "task lookup failed").into_response();
}
};
let guard = guard
.map(|Extension(g)| g)
.unwrap_or_else(default_global_guard);
let Some(slot) = guard.try_acquire() else {
log::warn!(
"ws connection rejected: max_connections={} reached (live={})",
guard.max_connections,
guard.live()
);
return (StatusCode::TOO_MANY_REQUESTS, "too many ws connections").into_response();
};
let ws = match WebSocketUpgrade::from_request_parts(&mut parts, &()).await {
Ok(ws) => ws,
Err(_) => {
return (StatusCode::UPGRADE_REQUIRED, "websocket upgrade required").into_response();
}
};
let rx = bus.subscribe();
let idle_timeout = guard.idle_timeout;
ws.on_upgrade(move |socket| {
task_ws_session(socket, rx, task.id, auth.team_id, slot, idle_timeout)
})
}
fn default_global_guard() -> Arc<TaskWsGuard> {
GLOBAL_GUARD
.get_or_init(|| Arc::new(TaskWsGuard::new(100, Duration::from_secs(300))))
.clone()
}
async fn task_ws_session(
mut socket: WebSocket,
mut rx: broadcast::Receiver<DomainEvent>,
task_id: Id,
team_id: Id,
slot: WsSlot,
idle_timeout: Duration,
) {
let ack = json!({
"event": "subscribed",
"task_id": task_id.to_string(),
"team_id": team_id.to_string(),
});
if socket
.send(Message::Text(ack.to_string().into()))
.await
.is_err()
{
return;
}
loop {
match tokio::time::timeout(idle_timeout, rx.recv()).await {
Ok(Ok(event)) => {
if let Some(frame) = status_frame(&event, &task_id, &team_id) {
if socket
.send(Message::Text(frame.to_string().into()))
.await
.is_err()
{
break;
}
}
}
Ok(Err(broadcast::error::RecvError::Lagged(dropped))) => {
log::warn!("ws subscriber lagged, dropped {dropped} events for task {task_id}");
}
Ok(Err(broadcast::error::RecvError::Closed)) => break,
Err(_elapsed) => {
log::debug!("ws idle timeout, closing connection for task {task_id}");
break;
}
}
}
drop(slot);
let _ = socket.send(Message::Close(None)).await;
}
fn status_frame(event: &DomainEvent, task_id: &Id, team_id: &Id) -> Option<serde_json::Value> {
match event {
DomainEvent::TaskCompleted {
task_id: id,
team_id: tid,
} if id == task_id && tid == team_id => Some(json!({
"event": "task_completed",
"task_id": task_id.to_string(),
"team_id": team_id.to_string(),
})),
DomainEvent::TaskFailed {
task_id: id,
team_id: tid,
error,
} if id == task_id && tid == team_id => Some(json!({
"event": "task_failed",
"task_id": task_id.to_string(),
"team_id": team_id.to_string(),
"error": error,
})),
_ => None,
}
}
use crate::presentation::handlers::task_handler;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_task_routes_returns_router_without_panic() {
let router = task_routes();
let _clone = router.clone();
}
#[test]
fn test_task_routes_clone_is_independent() {
let router = task_routes();
let clone = router.clone();
drop(router);
drop(clone);
}
#[test]
fn ws_guard_rejects_over_limit_and_recovers() {
let guard = Arc::new(TaskWsGuard::new(2, Duration::from_secs(1)));
let first = guard.try_acquire().expect("first acquire");
let second = guard.try_acquire().expect("second acquire");
assert!(
guard.try_acquire().is_none(),
"third must be rejected at cap"
);
assert_eq!(guard.live(), 2);
drop(first);
assert_eq!(guard.live(), 1, "slot drop releases exactly one slot");
assert!(
guard.try_acquire().is_some(),
"acquire after slot drop succeeds"
);
drop(second);
}
#[test]
fn ws_guard_release_does_not_underflow() {
let guard = Arc::new(TaskWsGuard::new(4, Duration::from_secs(1)));
guard.release();
guard.release();
assert_eq!(guard.live(), 0, "release on empty counter saturates at 0");
let mut slots = Vec::new();
for _ in 0..4 {
slots.push(guard.try_acquire().expect("within cap"));
}
assert!(guard.try_acquire().is_none(), "cap still enforced");
assert_eq!(guard.live(), 4);
}
#[test]
fn status_frame_filters_by_task_and_team() {
let task_id = Id::generate();
let team_id = Id::generate();
let own = DomainEvent::TaskCompleted { task_id, team_id };
let frame = status_frame(&own, &task_id, &team_id).expect("own event matches");
assert_eq!(frame["event"], "task_completed");
assert_eq!(frame["task_id"], task_id.to_string());
let cross = DomainEvent::TaskCompleted {
task_id,
team_id: Id::generate(),
};
assert!(status_frame(&cross, &task_id, &team_id).is_none());
let other_task = DomainEvent::TaskFailed {
task_id: Id::generate(),
team_id,
error: "x".to_string(),
};
assert!(status_frame(&other_task, &task_id, &team_id).is_none());
let unrelated = DomainEvent::CrawlCompleted {
crawl_id: Id::generate(),
team_id,
};
assert!(status_frame(&unrelated, &task_id, &team_id).is_none());
}
}