FEAT: list, get, start, restart, stop docker container

Author: BryanFRD

Cargo.lock

@@ -4,9 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-actix-web = "4.9.0"
+axum = "0.8.1"
 bollard = "0.18.1"
 tokio = { version = "1.43.0", features = ["full"] }
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.138"
-actix-cors = "0.7.0"

Cargo.toml

@@ -0,0 +1,94 @@
+use axum::{extract::Path, http::StatusCode, response::IntoResponse, Json};
+use serde_json::json;
+use bollard::Docker;
+
+use crate::errors::error_status::ErrorStatus;
+
+fn get_docker_client() -> Result<Docker, ErrorStatus> {
+  Docker::connect_with_local_defaults()
+    .map_err(|_| ErrorStatus::new(StatusCode::INTERNAL_SERVER_ERROR, format!("Error connecting to Docker")))
+}
+
+pub async fn get_containers() -> impl IntoResponse {
+  let options = Some(bollard::container::ListContainersOptions::<String> {
+    all: true,
+    ..Default::default()
+  });
+  
+  let docker = get_docker_client();
+  
+  let container = match docker {
+    Ok(docker) => {
+      match docker.list_containers(options).await {
+        Ok(containers) => containers,
+        Err(_) => return ErrorStatus::new(StatusCode::INTERNAL_SERVER_ERROR, "Error listing containers".to_string()).into_response()
+      }
+    },
+    Err(error) => return error.into_response()
+  };
+  
+  let response = json!({"containers": container});
+  (StatusCode::OK, Json(response)).into_response()
+}
+
+pub async fn get_container(Path(id): Path<String>) -> impl IntoResponse {
+  let docker = get_docker_client();
+  
+  let container = match docker {
+    Ok(docker) => {
+      match docker.inspect_container(&id, None).await {
+        Ok(container) => container,
+        Err(_) => return ErrorStatus::new(StatusCode::INTERNAL_SERVER_ERROR, "Error inspecting container".to_string()).into_response()
+      }
+    },
+    Err(error) => return error.into_response()
+  };
+  
+  let response = json!({"container": container});
+  (StatusCode::OK, Json(response)).into_response()
+}
+
+pub async fn start_container(Path(id): Path<String>) -> impl IntoResponse {
+  let docker = get_docker_client();
+  
+  match docker {
+    Ok(docker) => {
+      match docker.start_container(&id, None::<bollard::container::StartContainerOptions<String>>).await {
+        Ok(_) => (StatusCode::OK, Json(json!({"message": "Container started"}))).into_response(),
+        Err(err) => {
+          println!("Error starting container {}", err);
+          ErrorStatus::new(StatusCode::INTERNAL_SERVER_ERROR, "Error starting container".to_string())
+        }.into_response()
+      }
+    },
+    Err(error) => error.into_response()
+  }
+}
+
+pub async fn stop_container(Path(id): Path<String>) -> impl IntoResponse {
+  let docker = get_docker_client();
+  
+  match docker {
+    Ok(docker) => {
+      match docker.stop_container(&id, None::<bollard::container::StopContainerOptions>).await {
+        Ok(_) => (StatusCode::OK, Json(json!({"message": "Container stopped"}))).into_response(),
+        Err(_) => ErrorStatus::new(StatusCode::INTERNAL_SERVER_ERROR, "Error stopping container".to_string()).into_response()
+      }
+    },
+    Err(error) => error.into_response()
+  }
+}
+
+pub async fn restart_container(Path(id): Path<String>) -> impl IntoResponse {
+  let docker = get_docker_client();
+  
+  match docker {
+    Ok(docker) => {
+      match docker.restart_container(&id, None::<bollard::container::RestartContainerOptions>).await {
+        Ok(_) => (StatusCode::OK, Json(json!({"message": "Container restarted"}))).into_response(),
+        Err(_) => ErrorStatus::new(StatusCode::INTERNAL_SERVER_ERROR, "Error restarting container".to_string()).into_response()
+      }
+    },
+    Err(error) => error.into_response()
+  }
+}

src/controllers/docker.rs

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

src/controllers/mod.rs

@@ -0,0 +1,29 @@
+use std::fmt;
+
+use axum::{body::Body, http::StatusCode, response::{IntoResponse, Response}, Json};
+use serde_json::json;
+
+#[derive(Debug)]
+pub struct ErrorStatus {
+  pub status: StatusCode,
+  pub message: String,
+}
+
+impl ErrorStatus {
+  pub fn new(status: StatusCode, message: String) -> Self {
+    Self { status, message }
+  }
+}
+
+impl fmt::Display for ErrorStatus {
+  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    write!(f, "Error {}: {}", self.status.as_str(), self.message)
+  }
+}
+
+impl IntoResponse for ErrorStatus {
+  fn into_response(self) -> Response<Body> {
+      let body = json!({"error": self.message});
+      (self.status, Json(body)).into_response()
+  }
+}

src/errors/error_status.rs

@@ -0,0 +1 @@
+pub mod error_status;

src/errors/mod.rs

@@ -1,36 +1,13 @@
-use std::sync::Arc;
+mod routes;
+mod controllers;
+mod errors;
 
-use actix_cors::Cors;
-use actix_web::{web, App, HttpResponse, HttpServer, Responder};
-use bollard::Docker;
+use routes::setup_routes;
 
-async fn list_containers(docker: web::Data<Arc<Docker>>) -> impl Responder {
-    match docker.list_containers::<String>(None).await {
-        Ok(containers) => HttpResponse::Ok().json(containers),
-        Err(e) => HttpResponse::InternalServerError().body(format!("Error listing containers: {}", e)),   
-    }
-}
-
-#[actix_web::main]
-async fn main() -> std::io::Result<()> {
-    let docker = Docker::connect_with_local_defaults().unwrap();
-    let docker = Arc::new(docker);
+#[tokio::main]
+async fn main() {
+    let app = setup_routes();
 
-    HttpServer::new(move || {
-        App::new()
-            .wrap(Cors::default()
-                .allow_any_origin()
-                .allow_any_method()
-                .allow_any_header()
-                .max_age(3600)
-                .send_wildcard())
-            .wrap(actix_web::middleware::Logger::default())
-            .wrap(actix_web::middleware::NormalizePath::default())
-            .wrap(actix_web::middleware::Compress::default())
-            .app_data(web::Data::new(docker.clone()))
-            .route("/containers", web::get().to(list_containers))
-    })
-    .bind("0.0.0.0:8181")?
-    .run()
-    .await
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
 }

src/main.rs

@@ -0,0 +1,12 @@
+use axum::{Router, routing::get};
+
+use crate::controllers::docker;
+
+pub fn create_routes() -> Router {
+    Router::new()
+        .route("/", get(docker::get_containers))
+        .route("/{id}", get(docker::get_container))
+        .route("/start/{id}", get(docker::start_container))
+        .route("/stop/{id}", get(docker::stop_container))
+        .route("/restart/{id}", get(docker::restart_container))
+}

src/routes/docker.rs

@@ -0,0 +1,8 @@
+use axum::Router;
+
+mod docker;
+
+pub fn setup_routes() -> Router {
+    Router::new()
+        .nest("/docker", docker::create_routes())
+}