tramex_tools/interface/websocket/
ws_connection.rs

1//! WsConnection struct
2use core::fmt::{Debug, Formatter};
3use ewebsock::{WsEvent, WsMessage, WsReceiver, WsSender};
4use std::vec;
5
6use crate::interface::interface_types::InterfaceTrait;
7use crate::interface::types::BaseMessage;
8use crate::tramex_error;
9use crate::{data::Data, errors::TramexError};
10
11use crate::interface::{layer::Layer, layer::Layers, log_get::LogGet, parse_config::FileMetadata, types::WebSocketLog};
12
13/// Default maximum number of events requested per `log_get` request
14pub const DEFAULT_ASKING_SIZE_MAX: u64 = 1024;
15
16/// Default number of hours back the server is asked for logs
17pub const DEFAULT_HISTORY_HOURS: i64 = 12;
18
19/// WsConnection struct
20pub struct WsConnection {
21    /// WebSocket sender
22    pub ws_sender: WsSender,
23
24    /// WebSocket receiver
25    pub ws_receiver: WsReceiver,
26
27    /// Message ID
28    pub msg_id: u64,
29
30    /// Connecting flag
31    pub connecting: bool,
32
33    /// Asking size max
34    pub asking_size_max: u64,
35
36    /// How many hours back the server is asked for logs
37    pub history_hours: i64,
38
39    /// Available flag
40    pub available: bool,
41
42    /// Name of the receiver
43    pub name: String,
44
45    /// Auto-loading flag - when true, automatically requests more data
46    pub auto_loading: bool,
47
48    /// Waiting for response flag - true when a request has been sent and we're waiting for the response
49    pub waiting_for_response: bool,
50
51    /// Whether we have already requested and received headers (only need them once)
52    pub headers_received: bool,
53}
54
55impl WsConnection {
56    /// Create a new WsConnection
57    pub fn new(ws_sender: WsSender, ws_receiver: WsReceiver) -> Self {
58        log::info!("🔌 WsConnection::new() - creating connection (connecting=true, available=false)");
59        Self {
60            ws_sender,
61            ws_receiver,
62            msg_id: 1,
63            connecting: true,
64            asking_size_max: DEFAULT_ASKING_SIZE_MAX,
65            history_hours: DEFAULT_HISTORY_HOURS,
66            available: false, // Start as unavailable until WsEvent::Opened is received
67            name: "".to_string(),
68            auto_loading: true, // Auto-loading enabled by default
69            waiting_for_response: false,
70            headers_received: false,
71        }
72    }
73
74    /// Connect to a WebSocket
75    /// # Errors
76    /// Return an error as String if the connection failed - see [`ewebsock::connect_with_wakeup`] for more details
77    pub fn connect(url: &str, wakeup: impl Fn() + Send + Sync + 'static) -> Result<(WsSender, WsReceiver), String> {
78        let options = ewebsock::Options {
79            #[cfg(not(target_arch = "wasm32"))]
80            additional_headers: vec![("Origin".to_string(), "tramex".to_string())],
81            ..Default::default()
82        };
83        ewebsock::connect_with_wakeup(url, options, wakeup)
84    }
85
86    /// Try to close the ws
87    /// # Errors
88    /// Return an error if its fail see [`ewebsock::WsSender::close`] for more details
89    pub fn close_impl(&mut self) -> Result<(), TramexError> {
90        self.ws_sender.close();
91        Ok(())
92    }
93}
94
95impl InterfaceTrait for WsConnection {
96    fn get_more_data(&mut self, layer_list: Layers, _data: &mut Data) -> Result<(), Vec<TramexError>> {
97        // Don't send request if already waiting for a response
98        if self.waiting_for_response {
99            return Ok(());
100        }
101
102        let msg = LogGet::new(self.msg_id, layer_list, self.asking_size_max, self.history_hours);
103        // Request headers on the first request to get FileMetadata (technology, pci, etc.)
104        let msg = if !self.headers_received { msg.with_headers() } else { msg };
105        log::debug!("📤 Sending log_get request #{}", self.msg_id);
106        match serde_json::to_string(&msg) {
107            Ok(msg_stringed) => {
108                log::debug!("📤 JSON payload: {}", msg_stringed);
109                self.ws_sender.send(WsMessage::Text(msg_stringed));
110                self.msg_id += 1;
111                self.waiting_for_response = true;
112                log::debug!("⏳ Waiting for response...");
113            }
114            Err(err) => {
115                log::error!("Error encoding message: {err:?}");
116                return Err(vec![tramex_error!(
117                    err.to_string(),
118                    crate::errors::ErrorCode::WebSocketErrorEncodingMessage
119                )]);
120            }
121        }
122        Ok(())
123    }
124
125    fn close(&mut self) -> Result<(), TramexError> {
126        self.close_impl()
127    }
128
129    fn supports_preloading(&self) -> bool {
130        false // WebSocket cannot preload - server controls data
131    }
132
133    fn get_total_event_count(&self) -> Option<usize> {
134        None // Unknown for WebSocket
135    }
136
137    fn is_fully_read(&self) -> bool {
138        !self.available // If connection is closed, we're done
139    }
140}
141
142impl WsConnection {
143    /// Check if we should send a new request
144    /// Returns true if auto-loading is enabled and not currently waiting for a response
145    /// The server-side timeout and allow_empty=false handle the timing automatically
146    pub fn should_request_more(&self) -> bool {
147        self.auto_loading && !self.waiting_for_response
148    }
149
150    /// Try to receive data
151    /// # Errors
152    /// Return an error if the data is not received correctly
153    pub fn try_recv(&mut self, data: &mut Data) -> Result<(), Vec<TramexError>> {
154        while let Some(event) = self.ws_receiver.try_recv() {
155            log::debug!(
156                "🔵 WsConnection::try_recv() - event received, current state: connecting={}, available={}",
157                self.connecting,
158                self.available
159            );
160            match event {
161                WsEvent::Message(msg) => {
162                    // Only set available=true if we've already opened (connecting=false)
163                    // This handles the case where messages arrive before the Opened event
164                    if !self.connecting {
165                        self.available = true;
166                    }
167                    match msg {
168                        WsMessage::Text(event_text) => {
169                            // log::debug!("📨 Raw WebSocket text message: {}", event_text);
170                            let decoded: Result<WebSocketLog, serde_json::Error> = serde_json::from_str(&event_text);
171                            match decoded {
172                                Ok(decoded_data) => {
173                                    log::debug!("✅ Received log_get response with {} logs", decoded_data.logs.len());
174
175                                    // Mark that we received the response - ready for next request
176                                    self.waiting_for_response = false;
177
178                                    // Extract FileMetadata from top-level headers if present (first request only)
179                                    if !self.headers_received
180                                        && let Some(ref headers) = decoded_data.headers
181                                    {
182                                        data.metadata = FileMetadata::parse_from_lines(headers);
183                                        log::info!(
184                                            "📋 Parsed WebSocket metadata: technology={:?}, pci={:?}, mode={:?}",
185                                            data.metadata.technology,
186                                            data.metadata.pci,
187                                            data.metadata.mode
188                                        );
189                                        self.headers_received = true;
190                                    }
191
192                                    let mut errors = vec![];
193                                    for one_log in decoded_data.logs {
194                                        // Skip NR band combinations logs
195                                        if Layer::RRC == one_log.layer
196                                            && one_log.data.iter().any(|line| line.contains("NR band combinations"))
197                                        {
198                                            log::debug!("Skipping NR band combinations log");
199                                            continue;
200                                        }
201                                        match one_log.extract_data() {
202                                            Ok(trace) => {
203                                                data.events.push(trace);
204                                            }
205                                            Err(err) => {
206                                                log::error!("Error while extracting data: {err:?}");
207                                                errors.push(err);
208                                            }
209                                        }
210                                    }
211                                    if !errors.is_empty() {
212                                        return Err(errors);
213                                    }
214                                }
215                                Err(_err) => {
216                                    let decoded_base: Result<BaseMessage, serde_json::Error> =
217                                        serde_json::from_str(&event_text);
218                                    match decoded_base {
219                                        Ok(decoded_data) => {
220                                            if decoded_data.message == "ready" {
221                                                log::debug!(
222                                                    "✅ Received 'ready' message from server: {}",
223                                                    decoded_data.name
224                                                );
225                                                log::debug!(
226                                                    "💡 Server is ready. You need to click 'Load More' or enable auto-loading to request logs."
227                                                );
228                                            }
229                                            log::debug!("📥 Received BaseMessage: {decoded_data:?}");
230                                            self.name = decoded_data.name;
231                                        }
232                                        Err(err) => {
233                                            log::error!("Error decoding message: {err:?}");
234                                            log::error!("Message: {event_text:?}");
235                                            return Err(vec![tramex_error!(
236                                                err.to_string(),
237                                                crate::errors::ErrorCode::WebSocketErrorDecodingMessage
238                                            )]);
239                                        }
240                                    }
241                                }
242                            }
243                        }
244                        WsMessage::Unknown(str_error) => {
245                            log::error!("Unknown message: {str_error:?}");
246                            return Err(vec![tramex_error!(
247                                str_error,
248                                crate::errors::ErrorCode::WebSocketUnknownMessageReceived
249                            )]);
250                        }
251                        WsMessage::Binary(bin) => {
252                            log::error!("Unknown binary message: {bin:?}");
253                            return Err(vec![tramex_error!(
254                                format!("Unknown binary message: {bin:?}"),
255                                crate::errors::ErrorCode::WebSocketUnknownBinaryMessageReceived
256                            )]);
257                        }
258                        _ => {
259                            log::debug!("Received Ping-Pong")
260                        }
261                    }
262                }
263                WsEvent::Opened => {
264                    log::info!("✅ WsEvent::Opened - connection established! Setting connecting=false, available=true");
265                    self.connecting = false;
266                    self.available = true;
267                }
268                WsEvent::Closed => {
269                    log::warn!("⚠️ WsEvent::Closed - connection closed. Setting connecting=false, available=false");
270                    self.available = false;
271                    self.connecting = false;
272                    return Err(vec![tramex_error!(
273                        "WebSocket closed".to_string(),
274                        crate::errors::ErrorCode::WebSocketClosed
275                    )]);
276                }
277                WsEvent::Error(str_err) => {
278                    log::error!(
279                        "❌ WsEvent::Error - connection failed: {}. Setting connecting=false, available=false",
280                        str_err
281                    );
282                    self.available = false;
283                    self.connecting = false;
284                    return Err(vec![tramex_error!(str_err, crate::errors::ErrorCode::WebSocketError)]);
285                }
286            }
287        }
288        Ok(())
289    }
290}
291
292impl Debug for WsConnection {
293    fn fmt(&self, formatter: &mut Formatter<'_>) -> core::fmt::Result {
294        formatter
295            .debug_struct("Interface")
296            .field("ws_sender", &"Box<WsSender>")
297            .field("ws_receiver", &"Box<WsReceiver>")
298            .field("connecting", &self.connecting)
299            .finish()
300    }
301}
302
303impl Drop for WsConnection {
304    fn drop(&mut self) {
305        log::debug!("Cleaning WsConnection");
306        self.ws_sender.close()
307    }
308}