Skip to main content

llm_test_bench_core/monitoring/
websocket.rs

1// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
4// option. This file may not be copied, modified, or distributed
5// except according to those terms.
6
7//! WebSocket server for real-time monitoring dashboards.
8
9use 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/// WebSocket server configuration
30#[derive(Debug, Clone)]
31pub struct WebSocketConfig {
32    /// Port to listen on
33    pub port: u16,
34    /// Enable the server
35    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/// WebSocket message types
48#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(tag = "type", content = "data")]
50pub enum WebSocketMessage {
51    /// Monitoring event
52    Event(MonitoringEvent),
53    /// Ping/pong for keep-alive
54    Ping,
55    /// Pong response
56    Pong,
57    /// Subscription request
58    Subscribe { event_types: Vec<String> },
59    /// Unsubscribe request
60    Unsubscribe { event_types: Vec<String> },
61    /// Connection established
62    Connected { client_id: String },
63    /// Error message
64    Error { message: String },
65}
66
67/// WebSocket server state
68#[derive(Clone)]
69struct ServerState {
70    event_bus: Arc<EventBus>,
71    active_connections: Arc<RwLock<usize>>,
72}
73
74/// WebSocket server for real-time event streaming
75pub 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    /// Create a new WebSocket server
84    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    /// Start the WebSocket server
94    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    /// Stop the WebSocket server
130    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    /// Get active connection count
139    pub fn active_connections(&self) -> usize {
140        *self.active_connections.read()
141    }
142}
143
144/// WebSocket upgrade handler
145async 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
152/// Health check endpoint
153async 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
161/// Handle WebSocket connection
162async fn handle_socket(socket: WebSocket, state: ServerState) {
163    // Increment connection count
164    {
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    // Subscribe to events
175    let mut event_rx = state.event_bus.subscribe();
176
177    // Send connection message
178    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    // Spawn task to forward events to client
186    let mut send_task = tokio::spawn(async move {
187        loop {
188            tokio::select! {
189                // Receive event from event bus
190                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                // Send periodic ping
199                _ = 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    // Receive messages from client
212    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    // Wait for either task to finish
245    tokio::select! {
246        _ = &mut send_task => {
247            recv_task.abort();
248        }
249        _ = &mut recv_task => {
250            send_task.abort();
251        }
252    }
253
254    // Decrement connection count
255    {
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
263/// Generate a unique client ID
264fn 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}