Strategy protocol

pulse-wire/src/plugin.rs

@@ -30,7 +30,11 @@ pub struct RiskManifest {
 
 #[pwp]
 pub enum StrategyMessage {
-    RequestOHLC {
+    Log(EventLog),
+
+    GetWatchList,
+
+    RequestCandlestick {
         symbol: String,
         interval: CandleInterval,
         count: u32,
@@ -43,44 +47,50 @@ pub enum StrategyMessage {
     UnsubscribeAll,
 
     Signal(StrategySignal),
+}
 
+#[pwp]
+pub enum RiskMessage {
     Log(EventLog),
+
+    GetWatchList,
+
+    Approve(Signal),
+
+    Reject { reason: String },
 }
 
 #[pwp]
 pub enum StrategyEngineMessage {
-    Initialize {
+    Initialize,
-        watchlist: Vec<MarketItem>,
+
-    },
+    WatchList(Vec<MarketItem>),
 
     CandleUpdate {
         symbol: String,
-        candle: String,
+        interval: CandleInterval,
+        candle: Candle,
     },
 
-    OHLC {
+    Candlestick {
         symbol: String,
         interval: CandleInterval,
         candles: Vec<Candle>,
     },
 
-    Start,
+    Command {
-
+        command: String,
-    Stop,
+        args: Vec<String>,
-}
+    },
-
-#[pwp]
-pub enum RiskMessage {
-    Approve(Signal),
-
-    Reject { reason: String },
-
-    Log(EventLog),
 }
 
 #[pwp]
 pub enum RiskEngineMessage {
-    Initialize { strategy: String },
+    Initialize,
+
+    WatchList(Vec<MarketItem>),
+
+    Command { command: String, args: Vec<String> },
 
     Signal(StrategySignal),
 

src/engine/engine/plugin.rs

@@ -68,10 +68,20 @@ impl StrategyEngine {
         let strategy = self.strategy.clone();
         let risk = self.risk.clone();
 
+        strategy.send(&StrategyEngineMessage::Initialize).await?;
+
         loop {
             match strategy.recv().await? {
                 None => {}
 
+                Some(StrategyMessage::GetWatchList) => {
+                    let mut v = vec![1];
+
+                    v.extend(engine.config.lock().await.watchlist.to_com());
+
+                    self.strategy.send_raw(&v).await?;
+                }
+
                 Some(StrategyMessage::Log(mut log)) => {
                     log.name.insert_str(0, "strategy::");
                     engine.terminal_server.log_raw(log).await?;
@@ -97,7 +107,7 @@ impl StrategyEngine {
                     }
                 }
 
-                Some(StrategyMessage::RequestOHLC {
+                Some(StrategyMessage::RequestCandlestick {
                     symbol,
                     interval,
                     count,
@@ -144,10 +154,20 @@ impl StrategyEngine {
 
         let risk = self.risk.clone();
 
+        risk.send(&RiskEngineMessage::Initialize).await?;
+
         loop {
             match risk.recv().await? {
                 None => {}
 
+                Some(RiskMessage::GetWatchList) => {
+                    let mut v = vec![1];
+
+                    v.extend(engine.config.lock().await.watchlist.to_com());
+
+                    self.risk.send_raw(&v).await?;
+                }
+
                 Some(RiskMessage::Log(mut log)) => {
                     log.name.insert_str(0, "risk::");
                     engine.terminal_server.log_raw(log).await?;