Merge pull request #6 from FKMTime/new-ws-packets

New packets structure

Author: filipton

Cargo.lock

@@ -33,3 +33,4 @@ uuid = "1.10.0"
 dbus = { version = "0.9.7", features = ["vendored"] }
 rand = "0.8.5"
 unix-utils = { path = "./unix-utils" }
+crc32fast = "1.4.2"

Cargo.toml

@@ -1,6 +1,6 @@
 use crate::{
     http::EspConnectInfo,
-    structs::{SharedAppState, TimerPacket},
+    structs::{SharedAppState, TimerPacket, TimerPacketInner},
 };
 use anyhow::Result;
 use axum::extract::ws::{Message, WebSocket};
@@ -97,18 +97,22 @@ async fn send_device_status(
     let state = state.inner.read().await;
     let settings = state.devices_settings.get(&esp_connect_info.id);
     let frame = if let Some(settings) = settings {
-        TimerPacket::DeviceSettings {
-            esp_id: esp_connect_info.id,
-            use_inspection: settings.use_inspection,
-            secondary_text: settings.secondary_text.clone(),
-            added: true,
+        TimerPacket {
+            tag: None,
+            data: TimerPacketInner::DeviceSettings {
+                use_inspection: settings.use_inspection,
+                secondary_text: settings.secondary_text.clone(),
+                added: true,
+            },
         }
     } else {
-        TimerPacket::DeviceSettings {
-            esp_id: esp_connect_info.id,
-            use_inspection: false,
-            secondary_text: "".to_string(),
-            added: false,
+        TimerPacket {
+            tag: None,
+            data: TimerPacketInner::DeviceSettings {
+                use_inspection: false,
+                secondary_text: "".to_string(),
+                added: false,
+            },
         }
     };
 
@@ -118,10 +122,13 @@ async fn send_device_status(
 }
 
 async fn send_epoch_time(socket: &mut WebSocket) -> Result<()> {
-    let packet = TimerPacket::EpochTime {
-        current_epoch: std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)?
-            .as_secs(),
+    let packet = TimerPacket {
+        tag: None,
+        data: TimerPacketInner::EpochTime {
+            current_epoch: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)?
+                .as_secs(),
+        },
     };
 
     let resp = serde_json::to_string(&packet)?;
@@ -147,7 +154,7 @@ async fn on_ws_msg(
             tracing::trace!("WS payload recv [{}]: {payload}", esp_connect_info.id);
 
             let response: TimerPacket = serde_json::from_str(&payload)?;
-            let res = on_timer_response(socket, response).await;
+            let res = on_timer_response(socket, response, esp_connect_info).await;
             if let Err(e) = res {
                 error!("on_timer_response error: {e:?}");
             }
@@ -161,17 +168,25 @@ async fn on_ws_msg(
     Ok(false)
 }
 
-async fn on_timer_response(socket: &mut WebSocket, response: TimerPacket) -> Result<()> {
-    match response {
-        TimerPacket::CardInfoRequest {
+async fn on_timer_response(
+    socket: &mut WebSocket,
+    response: TimerPacket,
+    esp_connect_info: &EspConnectInfo,
+) -> Result<()> {
+    let esp_id = esp_connect_info.id;
+
+    match response.data {
+        TimerPacketInner::CardInfoRequest {
             card_id,
-            esp_id,
             attendance_device,
         } => {
             let attendance_device = attendance_device.unwrap_or(false);
             if attendance_device {
                 _ = crate::socket::api::mark_attendance(esp_id, card_id).await;
-                let resp = serde_json::to_string(&TimerPacket::AttendanceMarked { esp_id })?;
+                let resp = serde_json::to_string(&TimerPacket {
+                    tag: response.tag,
+                    data: TimerPacketInner::AttendanceMarked,
+                })?;
                 socket.send(Message::Text(resp)).await?;
 
                 return Ok(());
@@ -185,32 +200,35 @@ async fn on_timer_response(socket: &mut WebSocket, response: TimerPacket) -> Res
                     };
 
                     trace!("Card info: {} {} {:?}", card_id, esp_id, info);
-                    let response = TimerPacket::CardInfoResponse {
-                        card_id,
-                        esp_id,
-                        country_iso2: info.country_iso2.unwrap_or_default(),
-                        display: format!("{}{}", info.name, registrant_display),
-                        can_compete: info.can_compete,
+                    let response = TimerPacket {
+                        tag: response.tag,
+                        data: TimerPacketInner::CardInfoResponse {
+                            card_id,
+                            country_iso2: info.country_iso2.unwrap_or_default(),
+                            display: format!("{}{}", info.name, registrant_display),
+                            can_compete: info.can_compete,
+                        },
                     };
 
                     response
                 }
-                Err(e) => TimerPacket::ApiError {
-                    esp_id,
-                    error: e.message,
-                    should_reset_time: e.should_reset_time,
+                Err(e) => TimerPacket {
+                    tag: response.tag,
+                    data: TimerPacketInner::ApiError {
+                        error: e.message,
+                        should_reset_time: e.should_reset_time,
+                    },
                 },
             };
 
             let response = serde_json::to_string(&response)?;
             socket.send(Message::Text(response)).await?;
         }
-        TimerPacket::Solve {
+        TimerPacketInner::Solve {
             solve_time,
             penalty,
             competitor_id,
             judge_id,
-            esp_id,
             timestamp,
             session_id,
             delegate,
@@ -237,23 +255,27 @@ async fn on_timer_response(socket: &mut WebSocket, response: TimerPacket) -> Res
                         return Ok(());
                     }
 
-                    TimerPacket::SolveConfirm {
-                        esp_id,
-                        session_id,
-                        competitor_id,
+                    TimerPacket {
+                        tag: response.tag,
+                        data: TimerPacketInner::SolveConfirm {
+                            session_id,
+                            competitor_id,
+                        },
                     }
                 }
-                Err(e) => TimerPacket::ApiError {
-                    esp_id,
-                    error: e.message,
-                    should_reset_time: e.should_reset_time,
+                Err(e) => TimerPacket {
+                    tag: response.tag,
+                    data: TimerPacketInner::ApiError {
+                        error: e.message,
+                        should_reset_time: e.should_reset_time,
+                    },
                 },
             };
 
             let response = serde_json::to_string(&resp)?;
             socket.send(Message::Text(response)).await?;
         }
-        TimerPacket::Logs { logs, esp_id } => {
+        TimerPacketInner::Logs { logs } => {
             for log in logs.iter().rev() {
                 for line in log.msg.lines() {
                     if line.is_empty() {
@@ -264,21 +286,17 @@ async fn on_timer_response(socket: &mut WebSocket, response: TimerPacket) -> Res
                 }
             }
         }
-        TimerPacket::Battery {
-            esp_id,
-            level,
-            voltage: _,
-        } => {
+        TimerPacketInner::Battery { level, voltage: _ } => {
             _ = crate::socket::api::send_battery_status(esp_id, level).await;
         }
-        TimerPacket::Add { esp_id, firmware } => {
+        TimerPacketInner::Add { firmware } => {
             _ = crate::socket::api::add_device(esp_id, &firmware).await;
             trace!("Add device: {}", esp_id);
         }
-        TimerPacket::Snapshot(data) => {
+        TimerPacketInner::Snapshot(data) => {
             _ = crate::socket::api::send_snapshot_data(data).await;
         }
-        TimerPacket::TestAck { esp_id } => {
+        TimerPacketInner::TestAck => {
             _ = crate::socket::api::send_test_ack(esp_id).await;
         }
         _ => {

src/handler.rs

@@ -29,9 +29,6 @@ pub struct EspConnectInfo {
     #[serde(default = "default_chip")]
     pub chip: String,
 
-    #[serde(rename = "bt")]
-    pub build_time: u64,
-
     #[serde(default = "default_firmware")]
     pub firmware: String,
 }

src/http.rs

@@ -1,4 +1,4 @@
-use crate::structs::{SharedAppState, TimerPacket};
+use crate::structs::{SharedAppState, TimerPacket, TimerPacketInner};
 use anyhow::Result;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use tokio::{
@@ -237,11 +237,13 @@ async fn process_untagged_response(data: UnixResponseData) -> Result<()> {
             should_scan_cards,
             attempt,
         } => {
-            let packet = TimerPacket::DelegateResponse {
-                esp_id,
-                should_scan_cards,
-                solve_time: attempt.value.map(|x| x * 10), // from cs to ms
-                penalty: attempt.penalty,
+            let packet = TimerPacket {
+                tag: None,
+                data: TimerPacketInner::DelegateResponse {
+                    should_scan_cards,
+                    solve_time: attempt.value.map(|x| x * 10), // from cs to ms
+                    penalty: attempt.penalty,
+                },
             };
 
             let inner = crate::UNIX_SOCKET.get_inner().await?;
@@ -256,7 +258,13 @@ async fn process_untagged_response(data: UnixResponseData) -> Result<()> {
             let state = &inner.state;
 
             state
-                .send_timer_packet(esp_id, TimerPacket::TestPacket(data))
+                .send_timer_packet(
+                    esp_id,
+                    TimerPacket {
+                        tag: None,
+                        data: TimerPacketInner::TestPacket(data),
+                    },
+                )
                 .await?;
         }
         _ => {}

src/socket/mod.rs

@@ -2,6 +2,13 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use unix_utils::{SnapshotData, TestPacketData};
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct TimerPacket {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tag: Option<u64>,
+    pub data: TimerPacketInner,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct LogData {
     pub millis: u64,
@@ -10,32 +17,29 @@ pub struct LogData {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "snake_case")]
-pub enum TimerPacket {
+pub enum TimerPacketInner {
     StartUpdate {
-        esp_id: u32,
         version: String,
         build_time: u64, // NOT USED
-        size: i64,
+        size: u32,
+        crc: u32,
         firmware: String,
     },
     Solve {
         solve_time: u64,
         penalty: i64,
         competitor_id: u64,
         judge_id: u64,
-        esp_id: u32,
         timestamp: u64,
         session_id: String, // UUID
         delegate: bool,
         inspection_time: i64,
     },
     SolveConfirm {
-        esp_id: u32,
         competitor_id: u64,
         session_id: String,
     },
     DelegateResponse {
-        esp_id: u32,
         should_scan_cards: bool,
 
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -45,44 +49,35 @@ pub enum TimerPacket {
         penalty: Option<i64>,
     },
     ApiError {
-        esp_id: u32,
         error: String,
         should_reset_time: bool,
     },
     CardInfoRequest {
         card_id: u64,
-        esp_id: u32,
 
         #[serde(skip_serializing_if = "Option::is_none")]
         attendance_device: Option<bool>,
     },
     CardInfoResponse {
         card_id: u64,
-        esp_id: u32,
         display: String,
         country_iso2: String,
         can_compete: bool,
     },
-    AttendanceMarked {
-        esp_id: u32,
-    },
+    AttendanceMarked,
     DeviceSettings {
-        esp_id: u32,
         use_inspection: bool,
         secondary_text: String,
         added: bool,
     },
     Logs {
-        esp_id: u32,
         logs: Vec<LogData>,
     },
     Battery {
-        esp_id: u32,
         level: Option<f64>,
         voltage: Option<f64>,
     },
     Add {
-        esp_id: u32,
         firmware: String,
     },
     EpochTime {
@@ -92,9 +87,7 @@ pub enum TimerPacket {
     // packet for end to end testing
     TestPacket(TestPacketData),
     Snapshot(SnapshotData),
-    TestAck {
-        esp_id: u32,
-    },
+    TestAck,
 }
 
 #[derive(Debug, Clone)]