feat: support cancellation in e2e test app result

Author: jpraynaud

mithril-test-lab/mithril-end-to-end/src/main.rs

@@ -1,14 +1,15 @@
 use anyhow::{anyhow, Context};
 use clap::{CommandFactory, Parser, Subcommand};
 use slog::{Drain, Level, Logger};
-use slog_scope::{error, info, warn};
+use slog_scope::{error, info};
 use std::{
     fmt, fs,
     path::{Path, PathBuf},
     process::{ExitCode, Termination},
     sync::Arc,
     time::Duration,
 };
+use thiserror::Error;
 use tokio::{
     signal::unix::{signal, SignalKind},
     sync::Mutex,
@@ -217,13 +218,14 @@ enum AppResult {
     Success(),
     UnretryableError(anyhow::Error),
     RetryableError(anyhow::Error),
+    Cancelled(anyhow::Error),
 }
 
 impl AppResult {
     fn exit_code(&self) -> ExitCode {
         match self {
             AppResult::Success() => ExitCode::SUCCESS,
-            AppResult::UnretryableError(_) => ExitCode::FAILURE,
+            AppResult::UnretryableError(_) | AppResult::Cancelled(_) => ExitCode::FAILURE,
             AppResult::RetryableError(_) => ExitCode::from(2),
         }
     }
@@ -235,6 +237,7 @@ impl fmt::Display for AppResult {
             AppResult::Success() => write!(f, "Success"),
             AppResult::UnretryableError(error) => write!(f, "Error(Unretryable): {error:?}"),
             AppResult::RetryableError(error) => write!(f, "Error(Retryable): {error:?}"),
+            AppResult::Cancelled(error) => write!(f, "Cancelled: {error:?}"),
         }
     }
 }
@@ -259,6 +262,8 @@ impl From<StdResult<()>> for AppResult {
             Err(error) => {
                 if error.is::<RetryableDevnetError>() {
                     AppResult::RetryableError(error)
+                } else if error.is::<SignalError>() {
+                    AppResult::Cancelled(error)
                 } else {
                     AppResult::UnretryableError(error)
                 }
@@ -404,32 +409,30 @@ fn create_workdir_if_not_exist_clean_otherwise(work_dir: &Path) {
     fs::create_dir(work_dir).expect("Work dir creation failure");
 }
 
+#[derive(Error, Debug, PartialEq, Eq)]
+#[error("Signal received: `{0}`")]
+pub struct SignalError(pub String);
+
 fn with_gracefull_shutdown(join_set: &mut JoinSet<StdResult<()>>) {
     join_set.spawn(async move {
         let mut sigterm = signal(SignalKind::terminate()).expect("Failed to create SIGTERM signal");
-        sigterm
-            .recv()
-            .await
-            .ok_or(anyhow!("Failed to receive SIGTERM"))
-            .inspect(|()| warn!("Received SIGTERM"))
+        sigterm.recv().await;
+
+        Err(anyhow!(SignalError("SIGTERM".to_string())))
     });
 
     join_set.spawn(async move {
         let mut sigterm = signal(SignalKind::interrupt()).expect("Failed to create SIGINT signal");
-        sigterm
-            .recv()
-            .await
-            .ok_or(anyhow!("Failed to receive SIGINT"))
-            .inspect(|()| warn!("Received SIGINT"))
+        sigterm.recv().await;
+
+        Err(anyhow!(SignalError("SIGINT".to_string())))
     });
 
     join_set.spawn(async move {
         let mut sigterm = signal(SignalKind::quit()).expect("Failed to create SIGQUIT signal");
-        sigterm
-            .recv()
-            .await
-            .ok_or(anyhow!("Failed to receive SIGQUIT"))
-            .inspect(|()| warn!("Received SIGQUIT"))
+        sigterm.recv().await;
+
+        Err(anyhow!(SignalError("SIGQUIT".to_string())))
     });
 }
 
@@ -441,24 +444,19 @@ mod tests {
     fn app_result_exit_code() {
         let expected_exit_code = ExitCode::SUCCESS;
         let exit_code = AppResult::Success().exit_code();
-        assert_eq!(
-            format!("{:?}", expected_exit_code),
-            format!("{:?}", exit_code)
-        );
+        assert_eq!(expected_exit_code, exit_code);
 
         let expected_exit_code = ExitCode::FAILURE;
         let exit_code = AppResult::UnretryableError(anyhow::anyhow!("an error")).exit_code();
-        assert_eq!(
-            format!("{:?}", expected_exit_code),
-            format!("{:?}", exit_code)
-        );
+        assert_eq!(expected_exit_code, exit_code);
 
         let expected_exit_code = ExitCode::from(2);
         let exit_code = AppResult::RetryableError(anyhow::anyhow!("an error")).exit_code();
-        assert_eq!(
-            format!("{:?}", expected_exit_code),
-            format!("{:?}", exit_code)
-        );
+        assert_eq!(expected_exit_code, exit_code);
+
+        let expected_exit_code = ExitCode::FAILURE;
+        let exit_code = AppResult::Cancelled(anyhow::anyhow!("an error")).exit_code();
+        assert_eq!(expected_exit_code, exit_code);
     }
 
     #[test]
@@ -474,5 +472,10 @@ mod tests {
             AppResult::from(Err(anyhow!("an error"))),
             AppResult::UnretryableError(_)
         ));
+
+        assert!(matches!(
+            AppResult::from(Err(anyhow!(SignalError("an error".to_string())))),
+            AppResult::Cancelled(_)
+        ));
     }
 }