Using postcard

src/engine/engine/plugin.rs

@@ -166,11 +166,11 @@ impl StrategyEngine {
                 None => {}
 
                 Some(RiskMessage::GetWatchList) => {
-                    let mut v = vec![1];
-
-                    v.extend(engine.config.lock().await.watchlist.to_com());
-
-                    self.risk.send_raw(&v).await?;
+                    self.risk
+                        .send(&&RiskEngineMessage::WatchList(
+                            engine.watch_list.lock().await.clone(),
+                        ))
+                        .await?;
                 }
 
                 Some(RiskMessage::Log(mut log)) => {

src/engine/store/plugin.rs

@@ -1,16 +1,14 @@
 use std::marker::PhantomData;
 
-use pulse_wire::PulseWire;
-
-use serde::Deserialize;
+use pulse_wire::map_postcard_err;
+use serde::{Deserialize, Serialize};
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
     process::{Child, ChildStdout},
     sync::Mutex,
 };
-
 #[derive(Debug)]
-pub struct Plugin<S: PulseWire, R: PulseWire, M: for<'de> Deserialize<'de>> {
+pub struct Plugin<S: Serialize, R: for<'de> Deserialize<'de>, M: for<'de> Deserialize<'de>> {
     pub manifest: Mutex<M>,
     pub stdout: Mutex<ChildStdout>,
     pub process: Mutex<Child>,
@@ -18,7 +16,7 @@ pub struct Plugin<S: PulseWire, R: PulseWire, M: for<'de> Deserialize<'de>> {
     pub _p: (PhantomData<S>, PhantomData<R>),
 }
 
-impl<S: PulseWire, R: PulseWire, M: for<'de> Deserialize<'de>> Plugin<S, R, M> {
+impl<S: Serialize, R: for<'de> Deserialize<'de>, M: for<'de> Deserialize<'de>> Plugin<S, R, M> {
     pub fn new(mut child: Child, manifest: M) -> Self {
         Self {
             stdout: Mutex::new(child.stdout.take().expect("Failed to obtain child stdout")),
@@ -45,11 +43,12 @@ impl<S: PulseWire, R: PulseWire, M: for<'de> Deserialize<'de>> Plugin<S, R, M> {
 
         stdout.read_exact(&mut buffer).await?;
 
-        Ok(Some(R::from_com(&mut buffer)))
+        Ok(Some(map_postcard_err(postcard::from_bytes(&buffer))?))
     }
 
     pub async fn send(&self, msg: &S) -> tokio::io::Result<()> {
-        self.send_raw(&msg.to_com()).await
+        self.send_raw(&map_postcard_err(postcard::to_allocvec(msg))?)
+            .await
     }
 
     pub async fn send_raw(&self, msg: &[u8]) -> tokio::io::Result<()> {

src/engine/terminal.rs

@@ -1,5 +1,5 @@
 use crate::engine::Engine;
-use pulse_wire::prelude::*;
+use pulse_wire::{map_postcard_err, prelude::*};
 use std::{
     collections::HashMap,
     sync::{Arc, Weak},
@@ -104,7 +104,7 @@ impl TerminalServer {
 
             reader.read_exact(&mut buffer).await?;
 
-            match TerminalClientMessage::from_com(&mut buffer) {
+            match map_postcard_err(postcard::from_bytes(&buffer))? {
                 TerminalClientMessage::ExecuteCommand(command) => {
                     let command = command.as_str();
 
@@ -126,7 +126,7 @@ impl TerminalServer {
         self: &Arc<Self>,
         message: pulse_wire::terminal::TerminalServerMessage,
     ) -> tokio::io::Result<()> {
-        let msg = message.to_com();
+        let msg = map_postcard_err(postcard::to_allocvec(&message))?;
 
         let mut clients = self.clients.lock().await;
 
@@ -158,7 +158,7 @@ impl TerminalServer {
                     format!("Client({id}) does not exist"),
                 )
             })?,
-            &message.to_com(),
+            &map_postcard_err(postcard::to_allocvec(&message))?,
         )
         .await
     }