FEAT: Docker socket

Author: BryanFRD

Cargo.lock

@@ -11,3 +11,7 @@ serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.138"
 tower-http = { version = "0.6.2", features = ["cors"] }
 tower = "0.5.2"
+tokio-tungstenite = "0.26.1"
+futures = "0.3.31"
+futures-util = "0.3.31"
+socketioxide = "0.16.1"

Cargo.toml

@@ -1,22 +1,29 @@
 mod routes;
 mod controllers;
 mod errors;
+mod sockets;
+mod services;
 
 use axum::http::{HeaderValue, Method};
 use routes::setup_routes;
 use tower_http::cors::{AllowOrigin, CorsLayer};
 
 #[tokio::main]
-async fn main() {    
+async fn main() {
     let cors = CorsLayer::new()
         .allow_methods(vec![Method::GET, Method::POST, Method::PUT, Method::DELETE])
         .allow_origin(AllowOrigin::list([
             HeaderValue::from_str("https://admin.bryan-ferrando.fr").unwrap(),
             HeaderValue::from_str("http://localhost:5173").unwrap()
         ]));
 
-    let app = setup_routes().layer(cors);
+    let app = setup_routes()
+        .layer(sockets::create_websocket_layer())
+        .layer(cors);
 
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    
+    
+    
     axum::serve(listener, app).await.unwrap();
 }

src/main.rs

@@ -5,5 +5,4 @@ mod docker;
 pub fn setup_routes() -> Router {
     Router::new()
         .nest("/docker", docker::create_routes())
-        
 }

src/routes/mod.rs

@@ -0,0 +1,39 @@
+use serde_json::json;
+use bollard::{container::ListContainersOptions, errors::Error, secret::ContainerSummary, system::Version, Docker};
+
+pub fn get_docker_client() -> Result<Docker, Error> {
+    Docker::connect_with_socket_defaults()
+}
+
+pub async fn get_version() -> Result<Version, Error> {
+    let docker = get_docker_client();
+    
+    match docker {
+        Ok(docker) => {
+            match docker.version().await {
+                Ok(version) => Ok(version),
+                Err(error) => Err(error)
+            }
+        },
+        Err(error) => Err(error)
+    }
+}
+
+pub async fn get_containers() -> Result<Vec<ContainerSummary>, Error> {
+    let options = Some(bollard::container::ListContainersOptions::<String> {
+        all: true,
+        ..Default::default()
+    });
+    
+    let docker = get_docker_client();
+    
+    match docker {
+        Ok(docker) => {
+            match docker.list_containers(options).await {
+                Ok(containers) => Ok(containers),
+                Err(error) => Err(error)
+            }
+        },
+        Err(error) => Err(error)
+    }
+}

src/services/docker.rs

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

src/services/mod.rs

@@ -0,0 +1,23 @@
+use socketioxide::{extract::SocketRef, layer::SocketIoLayer, SocketIo};
+
+use crate::services::docker;
+
+pub fn create_websocket_layer() -> SocketIoLayer {
+    let (socket_layer, io) = SocketIo::new_layer();
+    
+    io.ns("/", |socket: SocketRef| async move {
+        println!("Client connected : {}", socket.id);
+        
+        socket.on("docker:containers", |socket: SocketRef| async move {
+            let containers = docker::get_containers().await.unwrap_or_else(|_| vec![]);
+            
+            let _ = socket.emit("docker:containers", &containers);
+        });
+        
+        socket.on_disconnect(|socket: SocketRef| async move {
+            println!("Client disconnected : {}", socket.id);
+        });
+    });
+    
+    socket_layer
+}