added listing all running containers

WatcherAgent/src/docker/serverclientcomm.rs

@@ -0,0 +1,152 @@
+use crate::models::ServerMessage;
+use crate::docker::container::{extract_container_id, get_available_container};
+
+use std::error::Error;
+use bollard::Docker;
+use bollard::query_parameters::{CreateImageOptions, RestartContainerOptions, InspectContainerOptions};
+use futures_util::StreamExt;
+
+pub async fn handle_server_message(docker: &Docker, msg: ServerMessage) -> Result<(), Box<dyn Error + Send + Sync>> {
+    let msg = msg.clone();
+    println!("Handling server message: {:?}", msg);
+
+    // Handle different message types
+    match msg.message_type.as_str() {
+        "update_image" => {
+            if let Some(image_name) = msg.data.get("image").and_then(|v| v.as_str()) {
+                println!("Received update command for image: {}", image_name);
+                // Call your update_docker_image function here
+                update_docker_image(docker, image_name).await?;
+                Ok(())
+            } else {
+                Err("Missing image name in update message".into())
+            }
+        }
+        "restart_container" => {
+            println!("Received restart container command");
+            // Call your restart_container function here
+            restart_container(docker).await?;
+            Ok(())
+        }
+        "stop_agent" => {
+            println!("Received stop agent command");
+            // Implement graceful shutdown
+            std::process::exit(0);
+        }
+        _ => {
+            eprintln!("Unknown message type: {}", msg.message_type);
+            Err(format!("Unknown message type: {}", msg.message_type).into())
+        }
+    }
+}
+
+pub async fn update_docker_image(docker: &Docker, image: &str) -> Result<(), Box<dyn Error + Send + Sync>> {
+    println!("Updating to {}", image);
+
+    // 1. Pull new image
+    let mut stream = docker.create_image(
+        Some(CreateImageOptions {
+            from_image: Some(image.to_string()),
+            ..Default::default()
+        }),
+        None,
+        None,
+    );
+
+    // Use the stream with proper trait bounds
+    while let Some(result) = StreamExt::next(&mut stream).await {
+        match result {
+            Ok(progress) => {
+                if let Some(status) = progress.status {
+                    println!("Pull status: {}", status);
+                }
+            }
+            Err(e) => {
+                eprintln!("Error pulling image: {}", e);
+                break;
+            }
+        }
+    }
+
+    // 2. Restart the current container
+    let _ = restart_container(docker).await;
+
+    Ok(())
+}
+
+pub async fn get_current_image(docker: &Docker) -> Result<Option<String>, Box<dyn Error + Send + Sync>> {
+    // First, let's debug the environment
+    get_available_container(docker).await;
+    
+    // Get the current container ID from /proc/self/cgroup
+    let container_id = match std::fs::read_to_string("/proc/self/cgroup") {
+        Ok(content) => {
+            let mut found_id = None;
+            println!("Searching cgroup for container ID...");
+            
+            for line in content.lines() {
+                println!("Checking line: {}", line);
+                
+                // Look for container runtime indicators
+                if line.contains("docker") || line.contains("crio") || line.contains("containerd") {
+                    if let Some(id) = extract_container_id(line) {
+                        println!("Found potential container ID: {}", id);
+                        found_id = Some(id);
+                        break;
+                    }
+                }
+            }
+            found_id
+        }
+        Err(e) => {
+            eprintln!("Error reading cgroup file: {}", e);
+            return Ok(None);
+        }
+    };
+
+    let container_id = match container_id {
+        Some(id) if !id.is_empty() => {
+            println!("Using container ID: '{}'", id);
+            id
+        }
+        _ => {
+            eprintln!("Could not find valid container ID in cgroup");
+            return Ok(None);
+        }
+    };
+
+    // Try to inspect the container
+    println!("Attempting to inspect container with ID: '{}'", container_id);
+    
+    match docker.inspect_container(&container_id, None::<InspectContainerOptions>).await {
+        Ok(container_info) => {
+            if let Some(config) = container_info.config {
+                if let Some(image) = config.image {
+                    println!("Successfully found image: {}", image);
+                    return Ok(Some(image));
+                }
+            }
+            eprintln!("Container inspected but no image found in config");
+            Ok(Some("unknown".to_string()))
+        }
+        Err(e) => {
+            eprintln!("Error inspecting container: {}", e);
+            Ok(None)
+        }
+    }
+}
+
+pub async fn restart_container(docker: &Docker) -> Result<(), Box<dyn Error + Send + Sync>> {
+    if let Ok(container_id) = std::env::var("HOSTNAME") {
+        println!("Restarting container {}", container_id);
+        if let Err(e) = docker.restart_container(&container_id, Some(RestartContainerOptions { signal: None, t: Some(0) }))
+            .await
+        {
+            eprintln!("Failed to restart container: {}", e);
+        }
+    } else {
+        eprintln!("No container ID found (HOSTNAME not set?)");
+    }
+
+    Ok(())
+}