Better logs for rust e2e tests:

* always output logs if the test failed
* show a frame containing the process name when dumping logs
* write process logs synchronously so there's no logs from
  other sources stuck between dumped process logs.

Author: Alenar

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

@@ -15,15 +15,24 @@ impl Spec {
         Self { infrastructure }
     }
 
-    pub async fn run(&mut self) -> Result<(), Box<dyn Error>> {
+    pub async fn run(&self) -> Result<(), Box<dyn Error>> {
         let aggregator_endpoint = self.infrastructure.aggregator().endpoint();
 
         wait_for_pending_certificate(&aggregator_endpoint).await?;
         let digest = assert_node_producing_snapshot(&aggregator_endpoint).await?;
         let certificate_hash =
             assert_signer_is_signing_snapshot(&aggregator_endpoint, &digest).await?;
         assert_is_creating_certificate(&aggregator_endpoint, &certificate_hash).await?;
-        assert_client_can_verify_snapshot(self.infrastructure.client_mut(), &digest).await?;
+
+        let mut client = self.infrastructure.build_client()?;
+        assert_client_can_verify_snapshot(&mut client, &digest).await?;
+
+        Ok(())
+    }
+
+    pub async fn dump_processes_logs(&mut self) -> Result<(), String> {
+        self.infrastructure.aggregator_mut().dump_logs().await?;
+        self.infrastructure.signer_mut().dump_logs().await?;
 
         Ok(())
     }

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

@@ -43,8 +43,8 @@ async fn main() -> Result<(), Box<dyn Error>> {
     match spec.run().await {
         Ok(_) => Ok(()),
         Err(error) => {
+            spec.dump_processes_logs().await?;
             error!("Mithril End to End test failed: {}", error);
-            spec.dump_logs_of_failed_processes().await?;
             Err(error)
         }
     }

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

@@ -61,12 +61,16 @@ impl Aggregator {
         self.process = Some(self.command.start(&[]));
     }
 
+    pub async fn dump_logs(&self) -> Result<(), String> {
+        self.command.dump_logs_to_stdout().await
+    }
+
     pub async fn dump_logs_if_crashed(&mut self) -> Result<(), String> {
         match self.process.as_mut() {
             Some(child) => match child.try_wait() {
                 Ok(Some(status)) => {
                     if !status.success() {
-                        self.command.dump_logs_to_stdout().await?;
+                        self.dump_logs().await?;
                     }
                     Ok(())
                 }

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

@@ -49,7 +49,7 @@ impl Client {
 
                     Err(match status.code() {
                         Some(c) => format!("mithril-signer exited with code: {}", c),
-                        None => "mithril-signer was terminated with a signal".to_string(),
+                        None => "mithril-client was terminated with a signal".to_string(),
                     })
                 }
             }

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

@@ -1,10 +1,11 @@
 use crate::{Aggregator, Client, Signer};
 use std::borrow::BorrowMut;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 pub struct MithrilInfrastructure {
+    work_dir: PathBuf,
+    bin_dir: PathBuf,
     aggregator: Aggregator,
-    client: Client,
     signer: Signer,
 }
 
@@ -16,15 +17,15 @@ impl MithrilInfrastructure {
         bin_dir: &Path,
     ) -> Result<Self, String> {
         let mut aggregator = Aggregator::new(server_port, db_dir, work_dir, bin_dir)?;
-        let client = Client::new(aggregator.endpoint(), work_dir, bin_dir)?;
         let mut signer = Signer::new(aggregator.endpoint(), db_dir, work_dir, bin_dir)?;
 
         aggregator.start();
         signer.start();
 
         Ok(Self {
+            work_dir: work_dir.to_path_buf(),
+            bin_dir: bin_dir.to_path_buf(),
             aggregator,
-            client,
             signer,
         })
     }
@@ -37,19 +38,15 @@ impl MithrilInfrastructure {
         self.aggregator.borrow_mut()
     }
 
-    pub fn client(&self) -> &Client {
-        &self.client
-    }
-
-    pub fn client_mut(&mut self) -> &mut Client {
-        self.client.borrow_mut()
-    }
-
     pub fn signer(&self) -> &Signer {
         &self.signer
     }
 
     pub fn signer_mut(&mut self) -> &mut Signer {
         self.signer.borrow_mut()
     }
+
+    pub fn build_client(&self) -> Result<Client, String> {
+        Client::new(self.aggregator.endpoint(), &self.work_dir, &self.bin_dir)
+    }
 }

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

@@ -1,7 +1,7 @@
 use slog_scope::info;
 use std::collections::HashMap;
+use std::io::Write;
 use std::path::{Path, PathBuf};
-use tokio::io::AsyncWriteExt;
 use tokio::process::{Child, Command};
 
 #[derive(Debug)]
@@ -95,9 +95,12 @@ impl MithrilCommand {
             )
         })?;
 
-        tokio::io::stdout()
+        println!("{:-^100}", "");
+        println!("{:^30}", format!("{} LOGS:", self.name.to_uppercase()));
+        println!("{:-^100}", "");
+
+        std::io::stdout()
             .write_all(&buffer)
-            .await
             .map_err(|e| format!("failed to dump {} logs: {}", &self.name, e))?;
 
         Ok(())

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

@@ -37,12 +37,16 @@ impl Signer {
         self.process = Some(self.command.start(&[]));
     }
 
+    pub async fn dump_logs(&self) -> Result<(), String> {
+        self.command.dump_logs_to_stdout().await
+    }
+
     pub async fn dump_logs_if_crashed(&mut self) -> Result<(), String> {
         match self.process.as_mut() {
             Some(child) => match child.try_wait() {
                 Ok(Some(status)) => {
                     if !status.success() {
-                        self.command.dump_logs_to_stdout().await?;
+                        self.dump_logs().await?;
                     }
                     Ok(())
                 }