Docker start/stop

src/container/docker.rs

@@ -1,13 +1,15 @@
-use std::{path::Path, process::Command};
+use std::{
+    path::Path,
+    process::{Command, ExitStatus},
+};
 
 use directories::BaseDirs;
 
-pub fn is_container_running(container_name: &str) -> bool {
+fn is_container_running(container_name: &str) -> Result<bool, Box<dyn std::error::Error>> {
     // Run the `docker ps` command and capture the output
     let output = Command::new("docker")
         .args(["ps", "--format", "{{.Names}}"])
-        .output()
+        .output()?;
-        .expect("Failed to execute command");
 
     // Convert the output to a string
     let output_str = String::from_utf8_lossy(&output.stdout);
@@ -15,35 +17,60 @@ pub fn is_container_running(container_name: &str) -> bool {
     // Check if the container name is in the list of running containers
     let running: bool = output_str.lines().any(|line| line.trim() == container_name);
 
-    if running {
+    Ok(running)
-        println!("Container '{}' is running already.", container_name);
-    }
-    running
 }
 
-pub fn start_docker_compose(service_name: &str, container_path: &str) {
+pub fn start_docker_compose(
-    // Run the `docker-compose up` command
+    service_name: &str,
-
+    container_path: &str,
+    start: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
     let base_dir: BaseDirs = BaseDirs::new().unwrap();
     let absolute = base_dir.home_dir().join(container_path);
     let compose_path = Path::new(&absolute);
 
-    // Check if the file exists before attempting to use it
+    let running: bool = is_container_running(service_name)?;
-    if compose_path.exists() {
+
-        let status = Command::new("docker-compose")
+    if running && start {
+        println!("Container running already.");
+        return Ok(());
+    }
+
+    if start && compose_path.exists() {
+        let status: ExitStatus = Command::new("docker-compose")
             .current_dir(compose_path)
             .args(["up", "-d"])
-            .status()
+            .status()?;
-            .expect("Failed to execute command");
 
-        // Check if the command was successful
         if status.success() {
             println!(
                 "Docker Compose service '{}' started successfully.",
                 service_name
             );
         } else {
-            eprintln!("Failed to start Docker Compose service '{}'.", service_name);
+            return Err(
+                format!("Failed to start Docker Compose service '{}'.", service_name).into(),
+            );
         }
     }
+
+    if !start && compose_path.exists() {
+        let status: ExitStatus = Command::new("docker-compose")
+            .current_dir(compose_path)
+            .args(["down"])
+            .status()?;
+
+        if status.success() {
+            println!(
+                "Docker Compose service '{}' stopped successfully.",
+                service_name
+            );
+        } else {
+            return Err(
+                format!("Failed to stop Docker Compose service '{}'.", service_name).into(),
+            );
+        }
+    }
+
+    Ok(())
 }

src/env/config.rs

@@ -9,6 +9,7 @@ const DOCKER_DIR: &str = "DOCKER_DIR";
 pub struct DevToolsConf {
     pub container_service: String,
     pub container_dir: String,
+    pub current_directory: PathBuf,
 }
 pub fn load_config() -> Result<DevToolsConf, Box<dyn std::error::Error>> {
     let base_dir: BaseDirs = match BaseDirs::new() {
@@ -33,10 +34,12 @@ pub fn load_config() -> Result<DevToolsConf, Box<dyn std::error::Error>> {
     let container_service: String =
         env::var(DOCKER_SERVICE).map_err(|_| format!("{} missing in env file.", DOCKER_SERVICE))?;
     let container_dir: String =
-        env::var("DOCKER_DIR").map_err(|_| format!("{} missing in env file.", DOCKER_DIR))?;
+        env::var(DOCKER_DIR).map_err(|_| format!("{} missing in env file.", DOCKER_DIR))?;
+    let current_directory: PathBuf = env::current_dir()?;
 
     Ok(DevToolsConf {
         container_service,
         container_dir,
+        current_directory,
     })
 }

src/main.rs

@@ -1,15 +1,23 @@
-use container::docker::{is_container_running, start_docker_compose};
+use container::docker::start_docker_compose;
 use env::config::{load_config, DevToolsConf};
 
 mod container;
 mod env;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let config: DevToolsConf = load_config()?;
+    let args: Vec<_> = std::env::args().collect();
-    let is_running: bool = is_container_running(&config.container_service);
+    if args.len() < 2 {
-    if !is_running {
+        eprintln!("Up or down is a required argument");
-        start_docker_compose(&config.container_service, &config.container_dir);
+        std::process::exit(1);
     }
+    let config: DevToolsConf = load_config()?;
+    let start: bool = args[1] == "up";
 
+    start_docker_compose(&config.container_service, &config.container_dir, start)?;
+
+    println!(
+        "Current directory: {}",
+        config.current_directory.as_path().to_str().unwrap()
+    );
     Ok(())
 }