add compose down and structure project better

lib/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "bollard_compose"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bollard = "*"
+serde = "1.0"
+serde_yaml = "0.9"
+
+
+tokio = {workspace = true, features = ["signal"]}
+anyhow.workspace = true
+log.workspace = true
+futures-util = "0.3.30"

lib/src/configuration/compose_types.rs

@@ -0,0 +1,35 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DockerCompose {
+    pub version: Option<String>,
+    pub services: HashMap<String, Service>,
+    pub volumes: Option<HashMap<String, Volume>>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Service {
+    pub image: Option<String>,
+    pub container_name: Option<String>,
+    pub build: Option<Build>,
+    pub ports: Option<Vec<String>>,
+    pub volumes: Option<Vec<String>>,
+    pub environment: Option<HashMap<String, String>>,
+    pub depends_on: Option<Vec<String>>,
+    pub auto_remove: Option<bool>,
+    pub restart: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Build {
+    pub context: Option<String>,
+    pub dockerfile: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Volume {
+    pub driver: Option<String>,
+    pub driver_opts: Option<HashMap<String, String>>,
+    pub labels: Option<HashMap<String, String>>,
+}

lib/src/configuration/mod.rs

@@ -0,0 +1,2 @@
+pub mod compose_types;
+pub mod parser;

lib/src/configuration/parser.rs

@@ -0,0 +1,12 @@
+use crate::configuration::compose_types::DockerCompose;
+use std::fs::File;
+use std::io::Read;
+
+pub fn parse_compose_config(file: Option<String>) -> anyhow::Result<DockerCompose> {
+    let file_path = file.unwrap_or("docker-compose.yaml".to_string());
+    let mut file = File::open(file_path)?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    let compose: DockerCompose = serde_yaml::from_str(&contents)?;
+    Ok(compose)
+}

lib/src/container.rs

@@ -0,0 +1,215 @@
+use crate::configuration::compose_types::DockerCompose;
+use crate::helpers::dir::parent_dir_name;
+use anyhow::anyhow;
+use bollard::container::{Config, CreateContainerOptions, RemoveContainerOptions};
+use bollard::models::{HostConfig, PortBinding, PortMap, RestartPolicy, RestartPolicyNameEnum};
+use bollard::Docker;
+use std::collections::HashMap;
+
+pub(crate) async fn create_containers(
+    compose: &DockerCompose,
+    docker: &Docker,
+    detach: bool,
+) -> anyhow::Result<Vec<String>> {
+    let mut container_ids = Vec::new();
+    let parent_dir = parent_dir_name()?;
+    for (name, service) in &compose.services {
+        let env = create_env_vec(&service.environment);
+        let conf: Config<String> = Config {
+            image: service.image.clone(),
+            attach_stdout: Some(!detach),
+            attach_stderr: Some(!detach),
+            open_stdin: Some(false),
+            env,
+            host_config: Some(HostConfig {
+                auto_remove: service.auto_remove,
+                restart_policy: parse_restart_policy(&service.restart),
+                port_bindings: create_port_map(&service.ports),
+                binds: parse_volume_mounts(compose, &service.volumes)?,
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        let container_name = service
+            .container_name
+            .clone()
+            .unwrap_or_else(|| format!("{}_{}_1", parent_dir, name));
+        let create_info = docker
+            .create_container::<String, String>(
+                Some(CreateContainerOptions {
+                    name: container_name,
+                    platform: None,
+                }),
+                conf,
+            )
+            .await?;
+        container_ids.push(create_info.id);
+    }
+    Ok(container_ids)
+}
+
+pub(crate) async fn start_containers(docker: &Docker, ids: Vec<String>) -> anyhow::Result<()> {
+    for id in ids {
+        docker.start_container::<String>(&id, None).await?;
+    }
+    Ok(())
+}
+
+pub async fn stop_containers(compose: &DockerCompose, docker: &Docker) -> anyhow::Result<()> {
+    let parent_dir = parent_dir_name()?;
+    for (name, service) in &compose.services {
+        let container_name = service
+            .container_name
+            .clone()
+            .unwrap_or_else(|| format!("{}_{}_1", parent_dir, name));
+        docker.stop_container(&container_name, None).await?;
+    }
+    Ok(())
+}
+
+pub async fn remove_containers(compose: &DockerCompose, docker: &Docker) -> anyhow::Result<()> {
+    let parent_dir = parent_dir_name()?;
+    for (name, service) in &compose.services {
+        let container_name = service
+            .container_name
+            .clone()
+            .unwrap_or_else(|| format!("{}_{}_1", parent_dir, name));
+        docker
+            .remove_container(
+                &container_name,
+                Some(RemoveContainerOptions {
+                    force: true,
+                    ..Default::default()
+                }),
+            )
+            .await?;
+    }
+    Ok(())
+}
+
+pub(crate) async fn stop_containers_by_ids(
+    docker: &Docker,
+    ids: Vec<String>,
+) -> anyhow::Result<()> {
+    for id in ids {
+        docker.stop_container(&id, None).await?;
+    }
+    Ok(())
+}
+
+fn create_env_vec(env: &Option<HashMap<String, String>>) -> Option<Vec<String>> {
+    match env {
+        Some(env) => {
+            let list = env
+                .iter()
+                .map(|(key, value)| format!("{}={}", key, value))
+                .collect();
+            Some(list)
+        }
+        None => None,
+    }
+}
+
+fn create_port_map(ports: &Option<Vec<String>>) -> Option<PortMap> {
+    ports.as_ref().map(|ports| {
+        ports
+            .iter()
+            .map(|port| {
+                let parts: Vec<&str> = port.split(':').collect();
+                (
+                    parts[1].to_string(),
+                    Some(vec![PortBinding {
+                        host_ip: None,
+                        host_port: Some(parts[0].to_string()),
+                    }]),
+                )
+            })
+            .collect()
+    })
+}
+
+fn parse_restart_policy(restart: &Option<String>) -> Option<RestartPolicy> {
+    match restart {
+        None => None,
+        Some(restart) => match restart.as_str() {
+            "no" => Some(RestartPolicy {
+                name: Some(RestartPolicyNameEnum::NO),
+                ..Default::default()
+            }),
+            "always" => Some(RestartPolicy {
+                name: Some(RestartPolicyNameEnum::ALWAYS),
+                ..Default::default()
+            }),
+            "unless-stopped" => Some(RestartPolicy {
+                name: Some(RestartPolicyNameEnum::UNLESS_STOPPED),
+                ..Default::default()
+            }),
+            "on-failure" => Some(RestartPolicy {
+                name: Some(RestartPolicyNameEnum::NO),
+                ..Default::default()
+            }),
+            v => {
+                // handle special case when retry count is specified
+                if v.starts_with("on-failure:") {
+                    let parts: Vec<&str> = v.split(':').collect();
+                    Some(RestartPolicy {
+                        name: Some(RestartPolicyNameEnum::ON_FAILURE),
+                        maximum_retry_count: Some(parts[1].parse().unwrap()),
+                    })
+                } else {
+                    None
+                }
+            }
+        },
+    }
+}
+
+fn parse_volume_mount(compose: &DockerCompose, volume: String) -> anyhow::Result<String> {
+    let parts: Vec<&str> = volume.split(':').collect();
+    if parts.len() != 2 {
+        return Err(anyhow!("Invalid volume mount: {}", volume));
+    }
+
+    if parts[0].starts_with('/') {
+        return Ok(volume);
+    }
+
+    let parent_dir = parent_dir_name()?;
+
+    let field_missing = format!("volume field for {} missing", volume);
+
+    // volumes map has to contain the volume defined here
+    if compose
+        .volumes
+        .as_ref()
+        .ok_or(anyhow!(field_missing.clone()))?
+        .contains_key(parts[0])
+    {
+        Ok(format!("{}_{}:{}", parent_dir, parts[0], parts[1]))
+    } else {
+        Err(anyhow!(field_missing))
+    }
+}
+
+fn parse_volume_mounts(
+    compose: &DockerCompose,
+    volumes: &Option<Vec<String>>,
+) -> anyhow::Result<Option<Vec<String>>> {
+    match volumes {
+        None => Ok(None),
+        Some(volumes) => {
+            let mounts: Vec<anyhow::Result<String>> = volumes
+                .iter()
+                .map(|volume| parse_volume_mount(compose, volume.clone()))
+                .collect();
+            let mounts = mounts
+                .into_iter()
+                .collect::<anyhow::Result<Vec<String>>>()?;
+            if mounts.is_empty() {
+                Ok(None)
+            } else {
+                Ok(Some(mounts))
+            }
+        }
+    }
+}

lib/src/helpers/dir.rs

@@ -0,0 +1,13 @@
+use anyhow::anyhow;
+use std::env;
+
+pub fn parent_dir_name() -> anyhow::Result<String> {
+    let current_dir = env::current_dir().expect("Failed to get current directory");
+
+    // Get the parent directory of the current directory
+    let parent_dir = current_dir
+        .file_name()
+        .ok_or(anyhow!("Current directory has no parent"))?;
+    let parent_dir_name = parent_dir.to_string_lossy().to_string();
+    Ok(parent_dir_name)
+}

lib/src/helpers/docker.rs

@@ -0,0 +1,12 @@
+use anyhow::anyhow;
+use bollard::Docker;
+
+pub async fn init_docker() -> anyhow::Result<Docker> {
+    let docker = Docker::connect_with_local_defaults()?;
+
+    docker
+        .ping()
+        .await
+        .map_err(|e| anyhow!("Connection to Docker Socket failed: {}", e))?;
+    Ok(docker)
+}

lib/src/helpers/mod.rs

@@ -0,0 +1,2 @@
+pub mod dir;
+pub mod docker;

lib/src/images.rs

@@ -0,0 +1,32 @@
+use crate::configuration::compose_types::DockerCompose;
+use bollard::image::CreateImageOptions;
+use bollard::models::CreateImageInfo;
+use bollard::Docker;
+use futures_util::StreamExt;
+
+pub(crate) async fn pull_images(compose: &DockerCompose, docker: &Docker) {
+    for service in compose.services.values() {
+        println!("Trying to pull {}", service.image.clone().unwrap());
+        let mut stream = docker.create_image(
+            Some(CreateImageOptions {
+                from_image: service.image.clone().unwrap(),
+                ..Default::default()
+            }),
+            None,
+            None,
+        );
+
+        while let Some(pull_result) = stream.next().await {
+            match pull_result {
+                Err(e) => println!("{:?}", e),
+                Ok(CreateImageInfo {
+                    status: Some(status),
+                    ..
+                }) => {
+                    println!("{}", status)
+                }
+                _ => {}
+            }
+        }
+    }
+}

lib/src/lib.rs

@@ -0,0 +1,42 @@
+use crate::configuration::parser::parse_compose_config;
+use crate::container::{create_containers, remove_containers, start_containers, stop_containers};
+use crate::helpers::docker::init_docker;
+use crate::images::pull_images;
+use crate::monitor::monitor_build_outputs;
+use crate::volume::create_volumes;
+
+mod configuration;
+mod container;
+mod helpers;
+mod images;
+mod monitor;
+mod volume;
+
+pub async fn down(compose_file: Option<String>) -> anyhow::Result<()> {
+    let compose = parse_compose_config(compose_file)?;
+    let docker = init_docker().await?;
+
+    stop_containers(&compose, &docker).await?;
+    remove_containers(&compose, &docker).await?;
+    Ok(())
+}
+
+pub async fn ps() -> anyhow::Result<()> {
+    // Here you would implement starting the services.
+    Ok(())
+}
+
+pub async fn up(compose_file: Option<String>, detach: bool) -> anyhow::Result<()> {
+    let compose = parse_compose_config(compose_file)?;
+    let docker = init_docker().await?;
+
+    pull_images(&compose, &docker).await;
+    create_volumes(&compose, &docker).await?;
+    let ids = create_containers(&compose, &docker, detach).await?;
+    start_containers(&docker, ids.clone()).await?;
+
+    if !detach {
+        monitor_build_outputs(&docker, ids).await?;
+    }
+    Ok(())
+}

lib/src/monitor.rs

@@ -0,0 +1,59 @@
+use crate::container::stop_containers_by_ids;
+use bollard::container::{AttachContainerOptions, LogOutput};
+use bollard::Docker;
+use futures_util::future::join_all;
+use futures_util::StreamExt;
+
+pub(crate) async fn monitor_build_outputs(docker: &Docker, ids: Vec<String>) -> anyhow::Result<()> {
+    let mut handles = vec![];
+    for id in ids.clone() {
+        let docker = docker.clone();
+        handles.push(tokio::spawn(async move {
+            let r = monitor_logs(&docker, id.clone()).await;
+            println!("Container {} exited with {:?}", id, r)
+        }));
+    }
+
+    tokio::select! {
+        _ = tokio::signal::ctrl_c() => {
+            println!("Ctrl-c received, stopping containers");
+            stop_containers_by_ids(docker, ids.clone()).await?;
+        }
+        _ = join_all(handles) => {
+            println!("All containers exited");
+        }
+    }
+    Ok(())
+}
+
+async fn monitor_logs(docker: &Docker, id: String) -> anyhow::Result<()> {
+    let mut attach_results = docker
+        .attach_container(
+            &id,
+            Some(AttachContainerOptions::<String> {
+                stdout: Some(true),
+                stderr: Some(true),
+                stdin: Some(false),
+                stream: Some(true),
+                ..Default::default()
+            }),
+        )
+        .await?;
+
+    while let Some(log_result) = attach_results.output.next().await {
+        match log_result {
+            Ok(chunk) => match chunk {
+                LogOutput::StdIn { .. } => unreachable!(),
+                LogOutput::Console { .. } => unreachable!(),
+                LogOutput::StdOut { message } => {
+                    println!("{}", String::from_utf8_lossy(&message));
+                }
+                LogOutput::StdErr { message } => {
+                    println!("{}", String::from_utf8_lossy(&message));
+                }
+            },
+            Err(e) => println!("{}", e),
+        }
+    }
+    Ok(())
+}

lib/src/volume.rs

@@ -0,0 +1,21 @@
+use crate::configuration::compose_types::DockerCompose;
+use crate::helpers::dir::parent_dir_name;
+use bollard::volume::CreateVolumeOptions;
+use bollard::Docker;
+
+pub(crate) async fn create_volumes(compose: &DockerCompose, docker: &Docker) -> anyhow::Result<()> {
+    if let Some(volumes) = &compose.volumes {
+        let parent_dir = parent_dir_name()?;
+        for (name, volume) in volumes {
+            docker
+                .create_volume::<String>(CreateVolumeOptions {
+                    name: format!("{}_{}", parent_dir, name),
+                    driver: volume.driver.clone().unwrap_or_else(Default::default),
+                    driver_opts: volume.driver_opts.clone().unwrap_or_else(Default::default),
+                    labels: volume.labels.clone().unwrap_or_else(Default::default),
+                })
+                .await?;
+        }
+    }
+    Ok(())
+}