feat: capture specimen logs

Cargo.toml

@@ -45,7 +45,7 @@ uuid = { version = "1.4.1", features = ["v4", "serde"] }
 rand = "0.8.5"
 semver = { version = "1.0.18", features = ["serde"] }
 toml = "0.7.6"
-tokio = { version = "1.32.0", features = ["sync", "time"] }
+tokio = { version = "1.32.0", features = ["sync", "time", "process"] }
 clap = { version = "4.4.6", features = ["derive"] }
 actix-rt = "2.7.0"
 tera = { version = "1.19.1", default-features = false }

src/ctx.rs

@@ -10,7 +10,7 @@ use tokio::sync::mpsc::Sender;
 
 use crate::db::*;
 use crate::docker::Docker;
-use crate::docker::DockerLike;
+//use crate::docker::DockerLike;
 use crate::settings::Settings;
 
 use super::complaince::result::Result as CResult;
@@ -21,7 +21,7 @@ pub type ArcMinCtx = Arc<dyn MinAppContext>;
 pub trait FullAppContext: std::marker::Send + std::marker::Sync + CloneFullAppCtx {
     fn settings(&self) -> &Settings;
     fn db(&self) -> &Database;
-    fn docker(&self) -> Arc<dyn DockerLike>;
+    fn docker(&self) -> Arc<Docker>;
     fn results(&self) -> &ResultStore;
     fn port(&self) -> u32;
 }
@@ -46,13 +46,13 @@ impl Clone for Box<dyn FullAppContext> {
 }
 
 pub trait MinAppContext: std::marker::Send + std::marker::Sync {
-    fn docker_(&self) -> Arc<dyn DockerLike>;
+    fn docker_(&self) -> Arc<Docker>;
     fn results_(&self) -> &ResultStore;
     fn port_(&self) -> u32;
 }
 
 impl MinAppContext for Arc<dyn FullAppContext> {
-    fn docker_(&self) -> Arc<dyn DockerLike> {
+    fn docker_(&self) -> Arc<Docker> {
         self.docker()
     }
     fn results_(&self) -> &ResultStore {
@@ -68,7 +68,7 @@ pub struct DaemonCtx {
     settings: Settings,
     db: Database,
     results: ResultStore,
-    docker: Arc<dyn DockerLike>,
+    docker: Arc<Docker>,
 }
 
 impl FullAppContext for DaemonCtx {
@@ -78,7 +78,7 @@ impl FullAppContext for DaemonCtx {
     fn db(&self) -> &Database {
         &self.db
     }
-    fn docker(&self) -> Arc<dyn DockerLike> {
+    fn docker(&self) -> Arc<Docker> {
         self.docker.clone()
     }
     fn results(&self) -> &ResultStore {
@@ -90,7 +90,7 @@ impl FullAppContext for DaemonCtx {
 }
 
 impl MinAppContext for DaemonCtx {
-    fn docker_(&self) -> Arc<dyn DockerLike> {
+    fn docker_(&self) -> Arc<Docker> {
         self.docker()
     }
     fn results_(&self) -> &ResultStore {
@@ -120,11 +120,11 @@ impl DaemonCtx {
 #[derive(Clone)]
 pub struct CliCtx {
     results: ResultStore,
-    docker: Arc<dyn DockerLike>,
+    docker: Arc<Docker>,
 }
 
 impl MinAppContext for CliCtx {
-    fn docker_(&self) -> Arc<dyn DockerLike> {
+    fn docker_(&self) -> Arc<Docker> {
         self.docker.clone()
     }
     fn results_(&self) -> &ResultStore {

src/docker.rs

@@ -3,7 +3,9 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use std::collections::HashMap;
-use std::process::Command;
+use std::process::{Command, Stdio};
+
+use serde::{Deserialize, Serialize};
 
 #[derive(Default, Clone, Eq, PartialEq)]
 pub struct Docker;
@@ -14,24 +16,14 @@ impl Docker {
     }
 }
 
-pub trait DockerLike: std::marker::Send + std::marker::Sync + CloneDockerLike {
-    fn version(&self) -> String;
-    fn run_container(
-        &self,
-        name: &str,
-        img: &str,
-        detached: bool,
-        env: &HashMap<String, String>,
-        network: Option<String>,
-        pull: bool,
-    );
-    fn get_exit_status(&self, name: &str) -> isize;
-    fn get_logs(&self, name: &str) -> String;
-    fn rm_container(&self, name: &str, force: bool);
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub struct Log {
+    pub stdout: String,
+    pub stderr: String,
 }
 
-impl DockerLike for Docker {
-    fn version(&self) -> String {
+impl Docker {
+    pub fn version(&self) -> String {
         let version = Command::new("docker")
             .arg("--version")
             .output()
@@ -41,7 +33,7 @@ impl DockerLike for Docker {
         x.get(1).unwrap().trim().to_string()
     }
 
-    fn run_container(
+    pub fn run_container(
         &self,
         name: &str,
         img: &str,
@@ -74,12 +66,14 @@ impl DockerLike for Docker {
         env_args.push(img.to_string());
         let mut child = Command::new("docker")
             .args(&env_args)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
             .spawn()
             .expect("unable to obtain Docker version");
         child.wait().unwrap();
     }
 
-    fn get_exit_status(&self, name: &str) -> isize {
+    pub fn get_exit_status(&self, name: &str) -> isize {
         let output = Command::new("docker")
             .args(["inspect", name, "--format={{.State.ExitCode}}"])
             .output()
@@ -88,15 +82,40 @@ impl DockerLike for Docker {
         let out = out.trim();
         out.parse::<isize>().unwrap()
     }
-    fn get_logs(&self, name: &str) -> String {
+    pub fn get_logs(&self, name: &str) -> Log {
         let output = Command::new("docker")
             .args(["logs", name])
             .output()
             .expect("unable to get logs");
-        String::from_utf8(output.stdout).unwrap()
+        Log {
+            stderr: String::from_utf8(output.stderr).unwrap(),
+            stdout: String::from_utf8(output.stdout).unwrap(),
+        }
     }
 
-    fn rm_container(&self, name: &str, force: bool) {
+    pub async fn block_till_container_exists(&self, name: &str, mut timeout: usize) -> bool {
+        let args = ["container", "inspect", name, "--format={{.State.Status}}"];
+        loop {
+            let out = tokio::process::Command::new("docker")
+                .args(args)
+                .output()
+                .await
+                .unwrap_or_else(|_| panic!("unable to run docker command on container {name}"));
+            let out = String::from_utf8(out.stdout).unwrap();
+            let out = out.trim();
+            if out == "exited" {
+                return true;
+            }
+
+            if timeout == 0 {
+                return false;
+            }
+            tokio::time::sleep(std::time::Duration::new(1, 0)).await;
+            timeout -= 1;
+        }
+    }
+
+    pub fn rm_container(&self, name: &str, force: bool) {
         let args = if force {
             vec!["rm", "--force", name]
         } else {
@@ -109,34 +128,14 @@ impl DockerLike for Docker {
     }
 }
 
-pub trait CloneDockerLike {
-    /// clone DB
-    fn clone_docker_like(&self) -> Box<dyn DockerLike>;
-}
-
-impl<T> CloneDockerLike for T
-where
-    T: DockerLike + Clone + 'static,
-{
-    fn clone_docker_like(&self) -> Box<dyn DockerLike> {
-        Box::new(self.clone())
-    }
-}
-
-impl Clone for Box<dyn DockerLike> {
-    fn clone(&self) -> Self {
-        (**self).clone_docker_like()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::utils::get_random;
 
     use super::*;
 
-    #[test]
-    fn test_docker_util() {
+    #[actix_rt::test]
+    async fn test_docker_util() {
         let d = Docker::new();
         d.version();
         let name = format!("test_sleep__{}", get_random(4));
@@ -157,12 +156,18 @@ mod tests {
             .unwrap();
         let out = String::from_utf8(out.stdout).unwrap();
         assert!(out.contains("true"));
-        std::thread::sleep(std::time::Duration::new(10, 0));
+
+        loop {
+            if d.block_till_container_exists(&name, 13).await {
+                break;
+            }
+        }
+
         let logs = d.get_logs(&name);
-        println!("{logs}");
-        assert!(logs.contains("running"));
-        assert!(logs.contains("FOO=BAR"));
-        assert!(logs.contains("BAZ=BOO"));
+        println!("{:?}", logs);
+        assert!(logs.stdout.contains("running"));
+        assert!(logs.stdout.contains("FOO=BAR"));
+        assert!(logs.stdout.contains("BAZ=BOO"));
         assert_eq!(d.get_exit_status(&name), 0);
         d.rm_container(&name, true);
     }

src/docker_compose.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JValue;
 
-use crate::docker::DockerLike;
+use crate::docker::{Docker, Log};
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub struct Container {
@@ -20,11 +20,11 @@ pub struct Container {
 
 pub struct DockerCompose {
     base_dir: PathBuf,
-    docker: Arc<dyn DockerLike>,
+    docker: Arc<Docker>,
 }
 
 impl DockerCompose {
-    pub fn new(base_dir: PathBuf, docker: Arc<dyn DockerLike>) -> Self {
+    pub fn new(base_dir: PathBuf, docker: Arc<Docker>) -> Self {
         Self { base_dir, docker }
     }
     pub fn version() -> String {
@@ -72,7 +72,7 @@ impl DockerCompose {
         child.wait().unwrap();
     }
 
-    pub fn logs(&self, service: &str) -> String {
+    pub fn logs(&self, service: &str) -> Log {
         self.docker.get_logs(service)
     }
 
@@ -111,7 +111,7 @@ mod tests {
         assert_eq!(services.len(), 2);
         for service in services.iter() {
             let logs = cmp.logs(&service.name);
-            assert!(logs.contains(&format!("NAME={}", service.name)));
+            assert!(logs.stdout.contains(&format!("NAME={}", service.name)));
         }
         cmp.down(true, true);
         assert!(cmp.services().is_empty());

src/main.rs

@@ -108,12 +108,13 @@ async fn main() -> std::io::Result<()> {
             }
 
             crate::runner::suite::SuiteRunnerState::run_proxy(ctx.as_ref());
-            let (suite_results, init_containers) =
+            let (suite_results, init_containers, specimen_logs) =
                 crate::runner::target::run_target(ctx.as_ref(), path.clone()).await;
             let content = crate::runner::results::ArchivableResult {
                 commit: "".into(),
                 suites: suite_results,
                 init_containers,
+               specimen_logs,
             };
             let results_file = path.join("results.json");
             println!("Writing results to: {:?}", path.canonicalize());

src/runner/init_scripts.rs

@@ -104,7 +104,10 @@ mod tests {
         let init = init.get(0).unwrap();
         assert!(init.success);
         assert_eq!(init.exit_code, 0);
-        assert!(init.container.logs.contains("All Good"));
+        assert!(
+            init.container.logs.stdout.contains("All Good")
+                || init.container.logs.stderr.contains("All Good")
+        );
         compose.down(true, true);
     }
 }

src/runner/mod.rs

@@ -23,12 +23,13 @@ pub async fn run(ctx: AppFullCtx, commit: &str) {
     Git::checkout_commit(commit, &control);
 
     for entry in crate::runner::target::get_targets(&control).iter() {
-        let (suite_results, init_containers) =
+        let (suite_results, init_containers, target_logs) =
             crate::runner::target::run_target(ctx.as_ref(), entry.into()).await;
         let content = ArchivableResult {
             commit: commit.to_string(),
             suites: suite_results,
             init_containers,
+           specimen_logs : target_logs,
         };
 
         let results_repo = base_dir.join("results");

src/runner/results.rs

@@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize};
 use url::Url;
 
 use crate::complaince::suite::Suite;
+use crate::docker::Log;
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct ArchivableInitResult {
@@ -27,9 +28,10 @@ pub struct ArchivableTestResult {
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct ArchivableContainer {
-    pub logs: String,
+    pub logs: Log,
     pub name: String,
 }
+
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct ArchivableTest {
     pub name: String,
@@ -52,6 +54,7 @@ pub struct ArchivableResult {
     pub commit: String,
     pub suites: Vec<ArchivableSuiteResult>,
     pub init_containers: Option<Vec<ArchivableInitResult>>,
+    pub specimen_logs: Vec<ArchivableContainer>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]

src/runner/suite.rs

@@ -59,7 +59,7 @@ impl SuiteRunnerState {
             "run",
             "-d",
             "-p",
-            "9080:9000",
+            "9080:80",
             "--name",
             FTEST_NGINX_PROXY,
             "--network",
@@ -132,9 +132,14 @@ impl SuiteRunnerState {
     }
 
     async fn collect_results(mut self, ctx: &dyn MinAppContext) -> ArchivableSuiteResult {
+        const TIMEOUT: usize = 40;
+
         let mut tests = Vec::with_capacity(self.tests.len());
         for (_auth, mut r) in self.tests.drain() {
             let result = r.rx.recv().await.unwrap();
+            ctx.docker_()
+                .block_till_container_exists(&r.container_name, TIMEOUT)
+                .await;
             let log = ctx.docker_().get_logs(&r.container_name);
             ctx.docker_().rm_container(&r.container_name, true);
             let container = ArchivableContainer {
@@ -307,19 +312,36 @@ mod tests {
                 archivable_test.result.logs,
                 format!("{}{LOGS}", archivable_test.result.container.name)
             );
-            println!("{}", archivable_test.result.container.logs);
-            assert!(archivable_test.result.container.logs.contains("FTEST_AUTH"));
-            assert!(archivable_test.result.container.logs.contains("FTEST_HOST"));
+            println!("{:?}", archivable_test.result.container.logs);
             assert!(archivable_test
                 .result
                 .container
                 .logs
+                .stdout
+                .contains("FTEST_AUTH"));
+            assert!(archivable_test
+                .result
+                .container
+                .logs
+                .stdout
+                .contains("FTEST_HOST"));
+            assert!(archivable_test
+                .result
+                .container
+                .logs
+                .stdout
                 .contains("FTEST_TARGET_HOST"));
-            assert!(archivable_test.result.container.logs.contains("FTEST_USER"));
             assert!(archivable_test
                 .result
                 .container
                 .logs
+                .stdout
+                .contains("FTEST_USER"));
+            assert!(archivable_test
+                .result
+                .container
+                .logs
+                .stdout
                 .contains(&format!("TEST_NAME={}", t.name)));
         }
     }

src/runner/target.rs

@@ -21,10 +21,11 @@ pub async fn run_target(
 ) -> (
     Vec<ArchivableSuiteResult>,
     Option<Vec<ArchivableInitResult>>,
+    Vec<ArchivableContainer>,
 ) {
     let compose = DockerCompose::new(target.canonicalize().unwrap(), ctx.docker_().clone());
     compose.up();
-    let services = compose.services();
+    let mut services = compose.services();
 
     // Read test suite
     let ftest_path = target.join(FTEST_TARGET_FILE);
@@ -43,13 +44,17 @@ pub async fn run_target(
 
     // shut down target instance
     let mut target_logs = Vec::with_capacity(services.len());
-    for s in services.iter() {
-        target_logs.push(compose.logs(&s.service));
+    for s in services.drain(0..) {
+        let logs = compose.logs(&s.service);
+        target_logs.push(ArchivableContainer {
+            logs,
+            name: s.service,
+        });
     }
 
     compose.down(true, true);
 
-    (suite_results, init_containers)
+    (suite_results, init_containers, target_logs)
 }
 
 pub fn get_targets(control: &Path) -> Vec<PathBuf> {

templates/index.html

@@ -22,27 +22,48 @@
       <h4>Logs</h4>
       <code>{{ test.result.logs | linebreaksbr }}</code>
       <h4>Container Logs: {{ test.result.container.name }}</h4>
-      <code>{{ test.result.container.logs | linebreaksbr }}</code>
+      <h5>STDOUT</h5>
+      <code>{{ test.result.container.logs.stdout | linebreaksbr }}</code>
+      <h5>STDERR</h5>
+      <code>{{ test.result.container.logs.stderr | linebreaksbr }}</code>
+
     </details>
     {% endfor %} {% endfor %} {% if payload.results.init_containers %}
 
     <h2>Initialization Workflow</h2>
 
     {% for init in payload.results.init_containers %}
-
-    <details>
-      {% if init.success %}
-      <summary>
-        <h3 class="test__name">[OK] {{init.container.name}}</h3>
-      </summary>
-      {% else %}
-      <summary>
-        <h3 class="test__name">[FAILED] {{init.container.name}}</h3>
-      </summary>
-      {% endif %}
-    <code>{{ init.container.logs | linebreaksbr }}</code>
-    </details>
+      <details>
+        {% if init.success %}
+        <summary>
+          <h3 class="test__name">[OK] {{init.container.name}}</h3>
+        </summary>
+        {% else %}
+        <summary>
+          <h3 class="test__name">[FAILED] {{init.container.name}}</h3>
+        </summary>
+        {% endif %}
+        <h4>STDOUT</h4>
+        <code>{{ init.container.logs.stdout | linebreaksbr }}</code>
+        <h4>STDERR</h4>
+        <code>{{ init.container.logs.stderr | linebreaksbr }}</code>
+      </details>
     {% endfor %} {% endif %}
+
+
+    <h2>Specimen Logs</h2>
+    {% for specimen in payload.results.specimen_logs %}
+      <details>
+        <summary>
+          <h3 class="test__name">{{specimen.name}}</h3>
+        </summary>
+        <h4>STDOUT</h4>
+        <code>{{ specimen.logs.stdout | linebreaksbr }}</code>
+        <h4>STDERR</h4>
+        <code>{{ specimen.logs.stderr | linebreaksbr }}</code>
+      </details>
+    {% endfor %}
+
   </body>
   <style>
     .test__name {