use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use crate::engine::{RpcEngine, dispatch_wire_entries};
static NEXT_WS_SUBSCRIBER_ID: AtomicU64 = AtomicU64::new(1);
pub async fn handle_ws_socket(
mut socket: axum::extract::ws::WebSocket,
engine: std::sync::Arc<crate::engine::RpcEngine>,
max_request_size: usize,
) {
use tokio::sync::broadcast;
let subscriber_id = format!(
"ws-conn-{}",
NEXT_WS_SUBSCRIBER_ID.fetch_add(1, Ordering::Relaxed)
);
let mut subscription = engine.event_publisher.subscribe_scoped(subscriber_id, None);
loop {
tokio::select! {
result = subscription.recv() => {
match result {
Ok((_event_type, event)) => {
if let Ok(json_str) = event.to_json()
&& socket
.send(axum::extract::ws::Message::Text(json_str))
.await
.is_err()
{
break; }
}
Err(broadcast::error::RecvError::Lagged(n)) => {
tracing::warn!("WebSocket client lagged by {} events", n);
continue;
}
Err(broadcast::error::RecvError::Closed) => {
break; }
}
}
msg = socket.recv() => {
match msg {
Some(Ok(axum::extract::ws::Message::Text(text))) => {
process_ws_jsonrpc(&mut socket, &engine, text.as_bytes(), max_request_size).await;
}
Some(Ok(axum::extract::ws::Message::Binary(data))) => {
process_ws_jsonrpc(&mut socket, &engine, data.as_ref(), max_request_size).await;
}
Some(Ok(axum::extract::ws::Message::Close(frame))) => {
tracing::debug!(?frame, "WebSocket close frame received");
let _ = socket
.send(axum::extract::ws::Message::Close(frame))
.await;
break;
}
None => {
tracing::debug!("WebSocket stream ended without a close frame");
break;
}
Some(Ok(axum::extract::ws::Message::Ping(data))) => {
let _ = socket
.send(axum::extract::ws::Message::Pong(data))
.await;
}
Some(Err(e)) => {
tracing::warn!("WebSocket error: {}", e);
break;
}
_ => {
continue;
}
}
}
}
}
tracing::debug!("WebSocket client disconnected");
}
async fn process_ws_jsonrpc(
socket: &mut axum::extract::ws::WebSocket,
engine: &Arc<RpcEngine>,
body: &[u8],
max_request_size: usize,
) {
use crate::json_rpc::{JsonRpcBatchResponse, JsonRpcWireEntry, parse_aria2_wire_document};
let body = if body.len() > max_request_size {
tracing::info!(
request_size = body.len(),
max_request_size,
"WebSocket JSON-RPC request exceeds parser limit"
);
&[]
} else {
body
};
let document = match parse_aria2_wire_document(body) {
Ok(document) => document,
Err(e) => {
tracing::warn!("WebSocket JSON-RPC parse error: {}", e);
let resp = e.into_response(None);
send_ws_response(socket, &resp).await;
return;
}
};
if !document.is_batch {
let entry = document
.entries
.into_iter()
.next()
.expect("single JSON-RPC document must contain one entry");
let resp = match entry {
JsonRpcWireEntry::Request(request) => engine.handle_request_owned(request).await,
JsonRpcWireEntry::Error(response) => response,
};
send_ws_response(socket, &resp).await;
} else {
let results = dispatch_wire_entries(engine, document.entries).await;
let batch = JsonRpcBatchResponse(results);
match batch.to_string() {
Ok(json_str) => {
if socket
.send(axum::extract::ws::Message::Text(json_str))
.await
.is_err()
{
tracing::debug!("Failed to send WS batch response (client disconnected)");
}
}
Err(e) => {
tracing::error!("Failed to serialize WS batch response: {}", e);
}
}
}
}
async fn send_ws_response(
socket: &mut axum::extract::ws::WebSocket,
resp: &crate::json_rpc::JsonRpcResponse,
) {
match resp.to_string() {
Ok(json_str) => {
if socket
.send(axum::extract::ws::Message::Text(json_str))
.await
.is_err()
{
tracing::debug!("Failed to send WS response (client disconnected)");
}
}
Err(e) => {
tracing::error!("Failed to serialize WS JSON-RPC response: {}", e);
}
}
}