tramex_tools/interface/websocket/
ws_connection.rs1use 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
13pub const DEFAULT_ASKING_SIZE_MAX: u64 = 1024;
15
16pub const DEFAULT_HISTORY_HOURS: i64 = 12;
18
19pub struct WsConnection {
21 pub ws_sender: WsSender,
23
24 pub ws_receiver: WsReceiver,
26
27 pub msg_id: u64,
29
30 pub connecting: bool,
32
33 pub asking_size_max: u64,
35
36 pub history_hours: i64,
38
39 pub available: bool,
41
42 pub name: String,
44
45 pub auto_loading: bool,
47
48 pub waiting_for_response: bool,
50
51 pub headers_received: bool,
53}
54
55impl WsConnection {
56 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, name: "".to_string(),
68 auto_loading: true, waiting_for_response: false,
70 headers_received: false,
71 }
72 }
73
74 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 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 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 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 }
132
133 fn get_total_event_count(&self) -> Option<usize> {
134 None }
136
137 fn is_fully_read(&self) -> bool {
138 !self.available }
140}
141
142impl WsConnection {
143 pub fn should_request_more(&self) -> bool {
147 self.auto_loading && !self.waiting_for_response
148 }
149
150 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 if !self.connecting {
165 self.available = true;
166 }
167 match msg {
168 WsMessage::Text(event_text) => {
169 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 self.waiting_for_response = false;
177
178 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 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}