Introduce maker_cfd::CfdAction enum

To reduce boilerplate and allow us to use an
`xtra::MessageChannel<maker_cfd::CfdAction>` in the (very near)
future.

daemon/src/maker_cfd.rs

@@ -24,32 +24,14 @@ use tokio::sync::watch;
 use xtra::prelude::*;
 use xtra::KeepRunning;
 
-pub struct AcceptOrder {
+pub enum CfdAction {
-    pub order_id: OrderId,
+    AcceptOrder { order_id: OrderId },
-}
+    RejectOrder { order_id: OrderId },
-
+    AcceptSettlement { order_id: OrderId },
-pub struct RejectOrder {
+    RejectSettlement { order_id: OrderId },
-    pub order_id: OrderId,
+    AcceptRollOver { order_id: OrderId },
-}
+    RejectRollOver { order_id: OrderId },
-
+    Commit { order_id: OrderId },
-pub struct Commit {
-    pub order_id: OrderId,
-}
-
-pub struct AcceptSettlement {
-    pub order_id: OrderId,
-}
-
-pub struct RejectSettlement {
-    pub order_id: OrderId,
-}
-
-pub struct AcceptRollOver {
-    pub order_id: OrderId,
-}
-
-pub struct RejectRollOver {
-    pub order_id: OrderId,
 }
 
 pub struct NewOrder {
@@ -984,51 +966,20 @@ impl Actor {
 }
 
 #[async_trait]
-impl Handler<AcceptOrder> for Actor {
+impl Handler<CfdAction> for Actor {
-    async fn handle(&mut self, msg: AcceptOrder, ctx: &mut Context<Self>) {
+    async fn handle(&mut self, msg: CfdAction, ctx: &mut Context<Self>) {
-        log_error!(self.handle_accept_order(msg.order_id, ctx))
+        use CfdAction::*;
-    }
+        if let Err(e) = match msg {
-}
+            AcceptOrder { order_id } => self.handle_accept_order(order_id, ctx).await,
-
+            RejectOrder { order_id } => self.handle_reject_order(order_id).await,
-#[async_trait]
+            AcceptSettlement { order_id } => self.handle_accept_settlement(order_id).await,
-impl Handler<RejectOrder> for Actor {
+            RejectSettlement { order_id } => self.handle_reject_settlement(order_id).await,
-    async fn handle(&mut self, msg: RejectOrder, _ctx: &mut Context<Self>) {
+            AcceptRollOver { order_id } => self.handle_accept_roll_over(order_id, ctx).await,
-        log_error!(self.handle_reject_order(msg.order_id))
+            RejectRollOver { order_id } => self.handle_reject_roll_over(order_id).await,
-    }
+            Commit { order_id } => self.handle_commit(order_id).await,
-}
+        } {
-
+            tracing::error!("Message handler failed: {:#}", e);
-#[async_trait]
+        }
-impl Handler<AcceptSettlement> for Actor {
-    async fn handle(&mut self, msg: AcceptSettlement, _ctx: &mut Context<Self>) {
-        log_error!(self.handle_accept_settlement(msg.order_id))
-    }
-}
-
-#[async_trait]
-impl Handler<RejectSettlement> for Actor {
-    async fn handle(&mut self, msg: RejectSettlement, _ctx: &mut Context<Self>) {
-        log_error!(self.handle_reject_settlement(msg.order_id))
-    }
-}
-
-#[async_trait]
-impl Handler<AcceptRollOver> for Actor {
-    async fn handle(&mut self, msg: AcceptRollOver, ctx: &mut Context<Self>) {
-        log_error!(self.handle_accept_roll_over(msg.order_id, ctx))
-    }
-}
-
-#[async_trait]
-impl Handler<RejectRollOver> for Actor {
-    async fn handle(&mut self, msg: RejectRollOver, _ctx: &mut Context<Self>) {
-        log_error!(self.handle_reject_roll_over(msg.order_id))
-    }
-}
-
-#[async_trait]
-impl Handler<Commit> for Actor {
-    async fn handle(&mut self, msg: Commit, _ctx: &mut Context<Self>) {
-        log_error!(self.handle_commit(msg.order_id))
     }
 }
 
@@ -1159,31 +1110,7 @@ impl Message for CfdRollOverCompleted {
     type Result = ();
 }
 
-impl Message for AcceptOrder {
+impl Message for CfdAction {
-    type Result = ();
-}
-
-impl Message for RejectOrder {
-    type Result = ();
-}
-
-impl Message for Commit {
-    type Result = ();
-}
-
-impl Message for AcceptSettlement {
-    type Result = ();
-}
-
-impl Message for RejectSettlement {
-    type Result = ();
-}
-
-impl Message for AcceptRollOver {
-    type Result = ();
-}
-
-impl Message for RejectRollOver {
     type Result = ();
 }
 

daemon/src/routes_maker.rs

@@ -150,47 +150,48 @@ pub async fn post_cfd_action(
     cfd_actor_address: &State<Address<maker_cfd::Actor>>,
     _auth: Authenticated,
 ) -> Result<status::Accepted<()>, status::BadRequest<String>> {
+    use maker_cfd::CfdAction::*;
     match action {
         CfdAction::AcceptOrder => {
             cfd_actor_address
-                .do_send_async(maker_cfd::AcceptOrder { order_id: id })
+                .do_send_async(AcceptOrder { order_id: id })
                 .await
                 .expect("actor to always be available");
         }
         CfdAction::RejectOrder => {
             cfd_actor_address
-                .do_send_async(maker_cfd::RejectOrder { order_id: id })
+                .do_send_async(RejectOrder { order_id: id })
                 .await
                 .expect("actor to always be available");
         }
         CfdAction::AcceptSettlement => {
             cfd_actor_address
-                .do_send_async(maker_cfd::AcceptSettlement { order_id: id })
+                .do_send_async(AcceptSettlement { order_id: id })
                 .await
                 .expect("actor to always be available");
         }
         CfdAction::RejectSettlement => {
             cfd_actor_address
-                .do_send_async(maker_cfd::RejectSettlement { order_id: id })
+                .do_send_async(RejectSettlement { order_id: id })
                 .await
                 .expect("actor to always be available");
         }
 
         CfdAction::AcceptRollOver => {
             cfd_actor_address
-                .do_send_async(maker_cfd::AcceptRollOver { order_id: id })
+                .do_send_async(AcceptRollOver { order_id: id })
                 .await
                 .expect("actor to always be available");
         }
         CfdAction::RejectRollOver => {
             cfd_actor_address
-                .do_send_async(maker_cfd::RejectRollOver { order_id: id })
+                .do_send_async(RejectRollOver { order_id: id })
                 .await
                 .expect("actor to always be available");
         }
         CfdAction::Commit => {
             cfd_actor_address
-                .do_send_async(maker_cfd::Commit { order_id: id })
+                .do_send_async(Commit { order_id: id })
                 .await
                 .expect("actor to always be available");
         }