Using postcard

src/terminal/terminal.rs

@@ -1,4 +1,5 @@
-use pulse_wire::prelude::*;
+use pulse_ui::state::State;
+use pulse_wire::{map_postcard_err, prelude::*};
 
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
@@ -29,7 +30,7 @@ impl TerminalClient {
         &mut self,
         message: pulse_wire::terminal::TerminalClientMessage,
     ) -> tokio::io::Result<()> {
-        let msg = message.to_com();
+        let msg = map_postcard_err(postcard::to_allocvec(&message))?;
         self.writer.write(&msg.len().to_le_bytes()).await?;
         self.writer.write(&msg).await?;
         self.writer.flush().await?;
@@ -42,7 +43,7 @@ impl TerminalClient {
 
         std::mem::swap(&mut self.reader, &mut reader);
 
-        let mut reader = reader.expect("Reader failed to swap");
+        let reader = reader.expect("Reader failed to swap");
 
         let watch_list = app.watch_list.clone();
         let active_positions = app.active_positions.clone();
@@ -52,61 +53,82 @@ impl TerminalClient {
         let status = app.status.clone();
         let inspect = app.inspect.clone();
 
-        tokio::spawn(async move {
-            loop {
-                let mut len_buf = [0u8; size_of::<usize>()];
-                reader
-                    .read_exact(&mut len_buf)
-                    .await
-                    .expect("Failed to get header length");
-
-                let len = usize::from_le_bytes(len_buf);
-
-                let mut buffer = vec![0u8; len];
-
-                reader
-                    .read_exact(&mut buffer)
-                    .await
-                    .expect("Failed to read socket");
-
-                match TerminalServerMessage::from_com(&mut buffer) {
-                    TerminalServerMessage::WatchListUpdated(v) => {
-                        *watch_list.lock().await = v;
-                    }
-
-                    TerminalServerMessage::PositionsUpdated(v) => {
-                        *active_positions.lock().await = v;
-                    }
-
-                    TerminalServerMessage::StrategyUpdated(v) => {
-                        *market_overview.lock().await = Some(v);
-                    }
-
-                    TerminalServerMessage::SignalsUpdated(v) => {
-                        *signals.lock().await = v;
-                    }
-
-                    TerminalServerMessage::Inspect(v) => {
-                        *inspect.lock().await = v;
-                    }
-
-                    TerminalServerMessage::StatusUpdated(v) => {
-                        *status.lock().await = Some(v);
-                    }
-
-                    TerminalServerMessage::SetLogs(v) => {
-                        *logs.lock().await = v;
-                    }
-
-                    TerminalServerMessage::AddLog(v) => {
-                        logs.lock().await.push(v);
-                    }
-                }
-            }
-        });
+        tokio::spawn(Self::run_client(
+            reader,
+            watch_list,
+            active_positions,
+            logs,
+            signals,
+            market_overview,
+            status,
+            inspect,
+        ));
 
         app.sock = Some(self);
 
         app
     }
+
+    pub async fn run_client(
+        mut reader: OwnedReadHalf,
+
+        watch_list: State<Vec<MarketItem>>,
+        active_positions: State<Vec<Position>>,
+        logs: State<Vec<EventLog>>,
+        signals: State<Vec<Signal>>,
+        market_overview: State<Option<Strategy>>,
+        status: State<Option<Status>>,
+        inspect: State<InspectTarget>,
+    ) -> tokio::io::Result<()> {
+        let mut len_buf = [0u8; size_of::<usize>()];
+        reader
+            .read_exact(&mut len_buf)
+            .await
+            .expect("Failed to get header length");
+
+        let len = usize::from_le_bytes(len_buf);
+
+        let mut buffer = vec![0u8; len];
+
+        reader
+            .read_exact(&mut buffer)
+            .await
+            .expect("Failed to read socket");
+
+        match map_postcard_err(postcard::from_bytes(&buffer))? {
+            TerminalServerMessage::WatchListUpdated(v) => {
+                *watch_list.lock().await = v;
+            }
+
+            TerminalServerMessage::PositionsUpdated(v) => {
+                *active_positions.lock().await = v;
+            }
+
+            TerminalServerMessage::StrategyUpdated(v) => {
+                *market_overview.lock().await = Some(v);
+            }
+
+            TerminalServerMessage::SignalsUpdated(v) => {
+                *signals.lock().await = v;
+            }
+
+            TerminalServerMessage::Inspect(v) => {
+                *inspect.lock().await = v;
+            }
+
+            TerminalServerMessage::StatusUpdated(v) => {
+                *status.lock().await = Some(v);
+            }
+
+            TerminalServerMessage::SetLogs(v) => {
+                *logs.lock().await = v;
+            }
+
+            TerminalServerMessage::AddLog(v) => {
+                logs.lock().await.push(v);
+            }
+        }
+
+        Ok(())
+    }
 }