Implement Docker integration with BollardAdapter; add Dockerfile, docker-compose, and update dependencies

src/docker/bollard.rs

@@ -0,0 +1,49 @@
+use bollard::Docker;
+use std::sync::{Arc, Mutex};
+
+pub struct BollardAdapter {
+    client: Arc<Mutex<Option<Docker>>>,
+}
+
+impl BollardAdapter {
+    pub fn new() -> Self {
+        Self {
+            client: Arc::new(Mutex::new(None)),
+        }
+    }
+}
+
+impl crate::docker::DockerAdapter for BollardAdapter {
+    async fn connect_docker(&self, docker_host: Option<String>) -> anyhow::Result<()> {
+        let docker = match docker_host {
+            Some(host) => Docker::connect_with_http(&host, 60, bollard::API_DEFAULT_VERSION)?,
+            None => Docker::connect_with_socket_defaults()?,
+        };
+
+        docker.ping().await?;
+
+        let mut client = self.client.lock().unwrap();
+        *client = Some(docker);
+
+        Ok(())
+    }
+
+    async fn list_service_with_label(&self, label: &str) -> anyhow::Result<Vec<String>> {
+        Ok(vec![])
+    }
+
+    async fn shutdown_service(&self, service_name: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    async fn start_service(&self, service_name: &str) -> anyhow::Result<()> {
+        Ok(())
+    }
+}
+
+impl Default for BollardAdapter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+

src/docker/mod.rs

@@ -0,0 +1,24 @@
+mod bollard;
+
+pub use bollard::BollardAdapter;
+
+pub struct Docker<T: DockerAdapter> {
+    adapter: T,
+}
+
+impl<T: DockerAdapter> Docker<T> {
+    pub fn new(adapter: T) -> Self {
+        Self { adapter }
+    }
+
+    pub async fn connect_docker(&self, docker_host: Option<String>) -> anyhow::Result<()> {
+        self.adapter.connect_docker(docker_host).await
+    }
+}
+
+pub trait DockerAdapter {
+    async fn connect_docker(&self, docker_host: Option<String>) -> anyhow::Result<()>;
+    async fn list_service_with_label(&self, label: &str) -> anyhow::Result<Vec<String>>;
+    async fn shutdown_service(&self, service_name: &str) -> anyhow::Result<()>;
+    async fn start_service(&self, service_name: &str) -> anyhow::Result<()>;
+}

src/main.rs

@@ -1,26 +1,30 @@
-use bollard::Docker;
+mod docker;
+
+use docker::{BollardAdapter, Docker};
+
+struct AppEnvVars {
+    backup_folder: String,
+    docker_host: Option<String>,
+}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let backup_root_folder = std::env::var("BACKUP_FOLDER")?;
-    let backup_root_path = std::path::Path::new(&backup_root_folder);
+    let envs = load_envs()?;
 
+    let backup_root_path = std::path::Path::new(&envs.backup_folder);
     let folders = list_folders(backup_root_path).await?;
 
-    let docker_host = std::env::var("DOCKER_HOST").ok();
-    let docker_conn = connect_docker(docker_host).await?;
-    
+    let docker_conn = connect_docker(envs.docker_host).await?;
 
     Ok(())
 }
 
-async fn connect_docker(docker_host: Option<String>) -> anyhow::Result<Docker> {
-    Ok(
-        match docker_host {
-            Some(host) => Docker::connect_with_http(&host, 60, bollard::API_DEFAULT_VERSION)?,
-            None => Docker::connect_with_socket_defaults()?,
-        }
-    )
+async fn connect_docker(docker_host: Option<String>) -> anyhow::Result<Docker<BollardAdapter>> {
+    let adapter = BollardAdapter::new();
+    let docker = Docker::new(adapter);
+    docker.connect_docker(docker_host).await?;
+
+    Ok(docker)
 }
 
 async fn list_folders(path: &std::path::Path) -> anyhow::Result<Vec<std::path::PathBuf>> {
@@ -34,4 +38,16 @@ async fn list_folders(path: &std::path::Path) -> anyhow::Result<Vec<std::path::P
     }
 
     Ok(folders)
+}
+
+fn load_envs() -> anyhow::Result<AppEnvVars> {
+    let backup_folder = std::env::var("BACKUP_FOLDER")?;
+    let docker_host = std::env::var("DOCKER_HOST").ok();
+
+    Ok(
+        AppEnvVars {
+            backup_folder,
+            docker_host,
+        }
+    )
 }