llm_test_bench_core/monitoring/
websocket.rs1use anyhow::Result;
10use std::sync::Arc;
11use std::net::SocketAddr;
12use parking_lot::RwLock;
13use tokio::sync::broadcast;
14use tokio::task::JoinHandle;
15use serde::{Deserialize, Serialize};
16use axum::{
17 extract::{
18 ws::{Message, WebSocket, WebSocketUpgrade},
19 State,
20 },
21 response::IntoResponse,
22 routing::get,
23 Router,
24};
25use futures::{sink::SinkExt, stream::StreamExt};
26
27use crate::monitoring::events::{EventBus, MonitoringEvent};
28
29#[derive(Debug, Clone)]
31pub struct WebSocketConfig {
32 pub port: u16,
34 pub enabled: bool,
36}
37
38impl Default for WebSocketConfig {
39 fn default() -> Self {
40 Self {
41 port: 8080,
42 enabled: true,
43 }
44 }
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(tag = "type", content = "data")]
50pub enum WebSocketMessage {
51 Event(MonitoringEvent),
53 Ping,
55 Pong,
57 Subscribe { event_types: Vec<String> },
59 Unsubscribe { event_types: Vec<String> },
61 Connected { client_id: String },
63 Error { message: String },
65}
66
67#[derive(Clone)]
69struct ServerState {
70 event_bus: Arc<EventBus>,
71 active_connections: Arc<RwLock<usize>>,
72}
73
74pub struct WebSocketServer {
76 config: WebSocketConfig,
77 event_bus: Arc<EventBus>,
78 server_handle: Arc<RwLock<Option<JoinHandle<()>>>>,
79 active_connections: Arc<RwLock<usize>>,
80}
81
82impl WebSocketServer {
83 pub async fn new(config: WebSocketConfig, event_bus: Arc<EventBus>) -> Result<Self> {
85 Ok(Self {
86 config,
87 event_bus,
88 server_handle: Arc::new(RwLock::new(None)),
89 active_connections: Arc::new(RwLock::new(0)),
90 })
91 }
92
93 pub async fn start(&self) -> Result<()> {
95 if !self.config.enabled {
96 tracing::debug!("WebSocket server is disabled");
97 return Ok(());
98 }
99
100 let state = ServerState {
101 event_bus: self.event_bus.clone(),
102 active_connections: self.active_connections.clone(),
103 };
104
105 let app = Router::new()
106 .route("/ws", get(ws_handler))
107 .route("/health", get(health_handler))
108 .with_state(state);
109
110 let addr: SocketAddr = format!("0.0.0.0:{}", self.config.port).parse()?;
111 tracing::info!("Starting WebSocket server on {}", addr);
112
113 let server = tokio::spawn(async move {
114 let listener = tokio::net::TcpListener::bind(addr)
115 .await
116 .expect("Failed to bind WebSocket server");
117
118 axum::serve(listener, app)
119 .await
120 .expect("WebSocket server error");
121 });
122
123 let mut handle = self.server_handle.write();
124 *handle = Some(server);
125
126 Ok(())
127 }
128
129 pub async fn stop(&self) -> Result<()> {
131 let mut handle = self.server_handle.write();
132 if let Some(h) = handle.take() {
133 h.abort();
134 }
135 Ok(())
136 }
137
138 pub fn active_connections(&self) -> usize {
140 *self.active_connections.read()
141 }
142}
143
144async fn ws_handler(
146 ws: WebSocketUpgrade,
147 State(state): State<ServerState>,
148) -> impl IntoResponse {
149 ws.on_upgrade(|socket| handle_socket(socket, state))
150}
151
152async fn health_handler(State(state): State<ServerState>) -> impl IntoResponse {
154 let connections = *state.active_connections.read();
155 axum::Json(serde_json::json!({
156 "status": "healthy",
157 "active_connections": connections,
158 }))
159}
160
161async fn handle_socket(socket: WebSocket, state: ServerState) {
163 {
165 let mut count = state.active_connections.write();
166 *count += 1;
167 }
168
169 let client_id = generate_client_id();
170 tracing::info!("New WebSocket connection: {}", client_id);
171
172 let (mut sender, mut receiver) = socket.split();
173
174 let mut event_rx = state.event_bus.subscribe();
176
177 let connected_msg = WebSocketMessage::Connected {
179 client_id: client_id.clone(),
180 };
181 if let Ok(json) = serde_json::to_string(&connected_msg) {
182 let _ = sender.send(Message::Text(json)).await;
183 }
184
185 let mut send_task = tokio::spawn(async move {
187 loop {
188 tokio::select! {
189 Ok(event) = event_rx.recv() => {
191 let ws_msg = WebSocketMessage::Event(event);
192 if let Ok(json) = serde_json::to_string(&ws_msg) {
193 if sender.send(Message::Text(json)).await.is_err() {
194 break;
195 }
196 }
197 }
198 _ = tokio::time::sleep(tokio::time::Duration::from_secs(30)) => {
200 let ping_msg = WebSocketMessage::Ping;
201 if let Ok(json) = serde_json::to_string(&ping_msg) {
202 if sender.send(Message::Text(json)).await.is_err() {
203 break;
204 }
205 }
206 }
207 }
208 }
209 });
210
211 let client_id_clone = client_id.clone();
213 let mut recv_task = tokio::spawn(async move {
214 while let Some(Ok(msg)) = receiver.next().await {
215 match msg {
216 Message::Text(text) => {
217 if let Ok(ws_msg) = serde_json::from_str::<WebSocketMessage>(&text) {
218 match ws_msg {
219 WebSocketMessage::Ping => {
220 tracing::trace!("Received ping from {}", client_id_clone);
221 }
222 WebSocketMessage::Pong => {
223 tracing::trace!("Received pong from {}", client_id_clone);
224 }
225 WebSocketMessage::Subscribe { event_types } => {
226 tracing::debug!("Client {} subscribed to: {:?}", client_id_clone, event_types);
227 }
228 WebSocketMessage::Unsubscribe { event_types } => {
229 tracing::debug!("Client {} unsubscribed from: {:?}", client_id_clone, event_types);
230 }
231 _ => {}
232 }
233 }
234 }
235 Message::Close(_) => {
236 tracing::info!("Client {} disconnected", client_id_clone);
237 break;
238 }
239 _ => {}
240 }
241 }
242 });
243
244 tokio::select! {
246 _ = &mut send_task => {
247 recv_task.abort();
248 }
249 _ = &mut recv_task => {
250 send_task.abort();
251 }
252 }
253
254 {
256 let mut count = state.active_connections.write();
257 *count = count.saturating_sub(1);
258 }
259
260 tracing::info!("WebSocket connection closed: {}", client_id);
261}
262
263fn generate_client_id() -> String {
265 use std::sync::atomic::{AtomicU64, Ordering};
266 static COUNTER: AtomicU64 = AtomicU64::new(0);
267 let id = COUNTER.fetch_add(1, Ordering::SeqCst);
268 format!("client_{}", id)
269}
270
271#[cfg(test)]
272mod tests {
273 use super::*;
274 use crate::monitoring::events::EventBus;
275
276 #[test]
277 fn test_websocket_config() {
278 let config = WebSocketConfig {
279 port: 8081,
280 enabled: true,
281 };
282 assert_eq!(config.port, 8081);
283 assert!(config.enabled);
284 }
285
286 #[tokio::test]
287 async fn test_websocket_server_creation() {
288 let config = WebSocketConfig {
289 port: 8082,
290 enabled: false,
291 };
292 let event_bus = Arc::new(EventBus::new());
293 let server = WebSocketServer::new(config, event_bus).await;
294 assert!(server.is_ok());
295 }
296
297 #[tokio::test]
298 async fn test_active_connections() {
299 let config = WebSocketConfig {
300 port: 8083,
301 enabled: false,
302 };
303 let event_bus = Arc::new(EventBus::new());
304 let server = WebSocketServer::new(config, event_bus).await.unwrap();
305 assert_eq!(server.active_connections(), 0);
306 }
307
308 #[test]
309 fn test_websocket_message_serialization() {
310 let msg = WebSocketMessage::Connected {
311 client_id: "test123".to_string(),
312 };
313 let json = serde_json::to_string(&msg).unwrap();
314 assert!(json.contains("Connected"));
315 assert!(json.contains("test123"));
316 }
317
318 #[test]
319 fn test_client_id_generation() {
320 let id1 = generate_client_id();
321 let id2 = generate_client_id();
322 assert_ne!(id1, id2);
323 }
324}