feat: rely on DockerLike trait for container ops

src/ctx.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 /*
  * Copyright (C) 2022  Aravinth Manivannan <realaravinth@batsense.net>
  *
@@ -14,13 +15,17 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-use std::sync::Arc;
-use std::thread;
+use std::sync::{Arc, RwLock};
+
+use reqwest::Client;
+use tokio::sync::mpsc::Sender;
 
 use crate::db::*;
+use crate::docker::Docker;
+use crate::docker::DockerLike;
 use crate::settings::Settings;
-use reqwest::Client;
-use tracing::info;
+
+use super::complaince::result::Result as CResult;
 
 pub type ArcCtx = Arc<Ctx>;
 
@@ -28,19 +33,23 @@ pub type ArcCtx = Arc<Ctx>;
 pub struct Ctx {
     pub settings: Settings,
     pub db: Database,
-    client: Client,
+    pub client: Client,
+    pub results: Arc<RwLock<HashMap<String, Sender<CResult>>>>,
+    pub docker: Arc<dyn DockerLike>,
 }
 
 impl Ctx {
     pub async fn new(settings: Settings) -> Arc<Self> {
+        let results = HashMap::default();
+        let results = Arc::new(RwLock::new(results));
         let client = Client::default();
         let db = get_db(&settings).await;
-        #[cfg(not(debug_assertions))]
-        init.join();
         Arc::new(Self {
             settings,
             client,
             db,
+            results,
+            docker: Arc::new(Docker::new()),
         })
     }
 }

src/docker.rs

@@ -1,10 +1,33 @@
 use std::collections::HashMap;
 use std::process::Command;
 
+#[derive(Default, Clone, Eq, PartialEq)]
 pub struct Docker;
 
 impl Docker {
-    pub fn version() -> String {
+    pub fn new() -> Self {
+        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);
+}
+
+impl DockerLike for Docker {
+    fn version(&self) -> String {
         let version = Command::new("docker")
             .arg("--version")
             .output()
@@ -14,7 +37,8 @@ impl Docker {
         x.get(1).unwrap().trim().to_string()
     }
 
-    pub fn run_container(
+    fn run_container(
+        &self,
         name: &str,
         img: &str,
         detached: bool,
@@ -51,7 +75,7 @@ impl Docker {
         child.wait().unwrap();
     }
 
-    pub fn get_exit_status(name: &str) -> isize {
+    fn get_exit_status(&self, name: &str) -> isize {
         let output = Command::new("docker")
             .args(["inspect", name, "--format={{.State.ExitCode}}"])
             .output()
@@ -60,7 +84,7 @@ impl Docker {
         let out = out.trim();
         out.parse::<isize>().unwrap()
     }
-    pub fn get_logs(name: &str) -> String {
+    fn get_logs(&self, name: &str) -> String {
         let output = Command::new("docker")
             .args(["logs", name])
             .output()
@@ -68,7 +92,7 @@ impl Docker {
         String::from_utf8(output.stdout).unwrap()
     }
 
-    pub fn rm_container(name: &str, force: bool) {
+    fn rm_container(&self, name: &str, force: bool) {
         let args = if force {
             vec!["rm", name]
         } else {
@@ -81,6 +105,26 @@ impl 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;
@@ -89,12 +133,13 @@ mod tests {
 
     #[test]
     fn test_docker_util() {
-        Docker::version();
+        let d = Docker::new();
+        d.version();
         let name = format!("test_sleep__{}", get_random(4));
         let mut env = HashMap::new();
         env.insert("FOO".to_string(), "BAR".to_string());
         env.insert("BAZ".to_string(), "BOO".to_string());
-        Docker::run_container(
+        d.run_container(
             &name,
             "forgeflux/ftest-dev-docker-cmd",
             true,
@@ -109,12 +154,12 @@ mod tests {
         let out = String::from_utf8(out.stdout).unwrap();
         assert!(out.contains("true"));
         std::thread::sleep(std::time::Duration::new(10, 0));
-        let logs = Docker::get_logs(&name);
+        let logs = d.get_logs(&name);
         println!("{logs}");
         assert!(logs.contains("running"));
         assert!(logs.contains("FOO=BAR"));
         assert!(logs.contains("BAZ=BOO"));
-        assert_eq!(Docker::get_exit_status(&name), 0);
-        Docker::rm_container(&name, true);
+        assert_eq!(d.get_exit_status(&name), 0);
+        d.rm_container(&name, true);
     }
 }

src/docker_compose.rs

@@ -1,10 +1,12 @@
 use std::path::PathBuf;
 use std::process::Command;
+use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JValue;
 
 use crate::docker::Docker;
+use crate::docker::DockerLike;
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub struct Container {
@@ -15,11 +17,12 @@ pub struct Container {
 
 pub struct DockerCompose {
     base_dir: PathBuf,
+    docker: Arc<dyn DockerLike>,
 }
 
 impl DockerCompose {
-    pub fn new(base_dir: PathBuf) -> Self {
-        Self { base_dir }
+    pub fn new(base_dir: PathBuf, docker: Arc<dyn DockerLike>) -> Self {
+        Self { base_dir, docker }
     }
     pub fn version() -> String {
         let version = Command::new("docker-compose")
@@ -67,7 +70,7 @@ impl DockerCompose {
     }
 
     pub fn logs(&self, service: &str) -> String {
-        Docker::get_logs(service)
+        self.docker.get_logs(service)
     }
 
     pub fn down(&self, remove_orphans: bool, volumes: bool) {
@@ -95,7 +98,7 @@ mod tests {
     #[test]
     fn test_docker_compose() {
         DockerCompose::version();
-        let cmp = DockerCompose::new("./tests/".into());
+        let cmp = DockerCompose::new("./tests/".into(), Arc::new(Docker::new()));
         assert!(cmp.services().is_empty());
         cmp.up();
         let services = cmp.services();

src/runner/init_scripts.rs

@@ -2,11 +2,13 @@ use std::collections::HashMap;
 
 use crate::complaince::target::Target;
 use crate::docker::Docker;
+use crate::docker::DockerLike;
 use crate::utils::get_random;
+use crate::AppCtx;
 
 use super::results::{ArchivableContainer, ArchivableInitResult};
 
-pub fn launch_init_containers(target: &Target) -> Option<Vec<ArchivableInitResult>> {
+pub fn launch_init_containers(ctx: &AppCtx, target: &Target) -> Option<Vec<ArchivableInitResult>> {
     if let Some(init_scripts) = target.init_scripts.as_ref() {
         let mut init_results = Vec::with_capacity(init_scripts.len());
         for init in init_scripts.iter() {
@@ -17,7 +19,7 @@ pub fn launch_init_containers(target: &Target) -> Option<Vec<ArchivableInitResul
                 env.extend(custom_vars);
             }
             let name = format!("{}--{}", init.name, &auth[0..5]);
-            Docker::run_container(
+            ctx.docker.run_container(
                 &name,
                 &init.container,
                 false,
@@ -25,9 +27,9 @@ pub fn launch_init_containers(target: &Target) -> Option<Vec<ArchivableInitResul
                 Some("ftest".to_string()),
                 true,
             );
-            let logs = Docker::get_logs(&name);
-            let exit_code = Docker::get_exit_status(&name);
-            Docker::rm_container(&name, true);
+            let logs = ctx.docker.get_logs(&name);
+            let exit_code = ctx.docker.get_exit_status(&name);
+            ctx.docker.rm_container(&name, true);
             let c = ArchivableInitResult {
                 success: exit_code == 0,
                 exit_code,
@@ -56,8 +58,8 @@ mod tests {
 
     #[actix_rt::test]
     async fn launch_init_containers_works() {
-        //        let settings = Settings::new().unwrap();
-        //        let ctx = AppCtx::new(Ctx::new(settings.clone()).await);
+        let settings = Settings::new().unwrap();
+        let ctx = AppCtx::new(Ctx::new(settings.clone()).await);
         //        let base_dir = Path::new(&ctx.settings.repository.base_dir);
         //        let control = base_dir.join("control");
 
@@ -84,7 +86,7 @@ mod tests {
             suites: Vec::default(),
         };
 
-        let init = launch_init_containers(&target);
+        let init = launch_init_containers(&ctx, &target);
         assert!(init.is_some());
         let init = init.unwrap();
         assert_eq!(init.len(), 1);