Implement cancelling program

src/mqtt/request/mod.rs

@@ -262,6 +262,7 @@ pub enum Request {
     CancelSectionRunId(sections::CancelSectionRunIdRequest),
     PauseSectionRunner(sections::PauseSectionRunnerRequest),
     RunProgram(programs::RunProgramRequest),
+    CancelProgram(programs::CancelProgramRequest),
 }
 
 impl IRequest for Request {
@@ -274,6 +275,7 @@ impl IRequest for Request {
             Request::CancelSectionRunId(req) => req.exec_erased(ctx),
             Request::PauseSectionRunner(req) => req.exec_erased(ctx),
             Request::RunProgram(req) => req.exec_erased(ctx),
+            Request::CancelProgram(req) => req.exec_erased(ctx),
         }
     }
 }

src/mqtt/request/programs.rs

@@ -30,3 +30,35 @@ impl IRequest for RunProgramRequest {
         })
     }
 }
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelProgramRequest {
+    program_id: ProgramId,
+}
+
+impl IRequest for CancelProgramRequest {
+    type Response = ResponseMessage;
+
+    fn exec(&mut self, ctx: &mut RequestContext) -> RequestFuture<Self::Response> {
+        let mut program_runner = ctx.program_runner.clone();
+        let program_id = self.program_id;
+        Box::pin(async move {
+            let cancelled = program_runner
+                .cancel_program(program_id)
+                .await
+                .wrap_err("could not run cancel program")?;
+            match cancelled {
+                Some(program) => Ok(ResponseMessage::new(format!(
+                    "program '{}' cancelled",
+                    program.name
+                ))),
+                None => Err(RequestError::with_name(
+                    ErrorCode::NoSuchProgram,
+                    "program was not running",
+                    "program",
+                )),
+            }
+        })
+    }
+}

src/program_runner.rs

@@ -297,19 +297,22 @@ impl Handler<RunProgram> for ProgramRunnerActor {
 }
 
 #[derive(Message)]
-#[rtype(result = "()")]
+#[rtype(result = "Option<ProgramRef>")]
 struct CancelProgram(ProgramId);
 
 impl Handler<CancelProgram> for ProgramRunnerActor {
-    type Result = ();
+    type Result = Option<ProgramRef>;
     fn handle(&mut self, msg: CancelProgram, ctx: &mut Self::Context) -> Self::Result {
         let CancelProgram(program_id) = msg;
+        let mut cancelled = None;
         for run in self.run_queue.iter_mut() {
             if run.program.id == program_id {
                 run.state = RunState::Cancelled;
+                cancelled = Some(run.program.clone());
             }
         }
         ctx.notify(Process);
+        cancelled
     }
 }
 
@@ -448,7 +451,7 @@ impl ProgramRunner {
             .map_err(ProgramRunnerError::from)
     }
 
-    pub async fn cancel_program(&mut self, program_id: ProgramId) -> Result<()> {
+    pub async fn cancel_program(&mut self, program_id: ProgramId) -> Result<Option<ProgramRef>> {
         self.addr
             .send(CancelProgram(program_id))
             .await