added debugging for docker image

WatcherAgent/src/serverclientcomm.rs

@@ -1,9 +1,10 @@
 use crate::models::{ServerMessage};
 
 use std::error::Error;
+use std::num::NonZero;
 
 use bollard::Docker;
-use bollard::query_parameters::{CreateImageOptions, RestartContainerOptions, InspectContainerOptions};
+use bollard::query_parameters::{CreateImageOptions, RestartContainerOptions, InspectContainerOptions, ListContainersOptions};
 use futures_util::StreamExt;
 
 pub async fn handle_server_message(docker: &Docker, msg: ServerMessage) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -75,20 +76,28 @@ pub async fn update_docker_image(docker: &Docker, image: &str) -> Result<(), Box
 }
 
 pub async fn get_current_image(docker: &Docker) -> Result<Option<String>, Box<dyn Error + Send + Sync>> {
+    // First, let's debug the environment
+    debug_docker_environment(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) => {
-            content
-                .lines()
-                .find_map(|line| {
-                    // Look for any line that might contain container information
-                    if line.contains("docker") || line.contains("crio") || line.contains("containerd") || line.contains("kubepods") {
-                        // Extract the container ID from the line
-                        extract_container_id(line)
-                    } else {
-                        None
+            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);
@@ -96,121 +105,122 @@ pub async fn get_current_image(docker: &Docker) -> Result<Option<String>, Box<dy
         }
     };
 
-    // Debug: Print what we found
-    println!("Container ID search result: {:?}", container_id);
-
     let container_id = match container_id {
         Some(id) if !id.is_empty() => {
-            println!("Found container ID: '{}'", id);
+            println!("Using container ID: '{}'", id);
             id
         }
         _ => {
-            // Debug the cgroup file content
-            if let Ok(content) = std::fs::read_to_string("/proc/self/cgroup") {
-                eprintln!("Cgroup file content for debugging:");
-                for (i, line) in content.lines().enumerate() {
-                    eprintln!("Line {}: {}", i, line);
-                }
-            }
             eprintln!("Could not find valid container ID in cgroup");
             return Ok(None);
         }
     };
 
-    // Clean up the container ID - remove any non-hex characters
-    let clean_container_id: String = container_id
-        .chars()
-        .filter(|c| c.is_ascii_hexdigit())
-        .collect();
-
-    // Validate the container ID (should be 64 characters for full ID, but short ID might work too)
-    if clean_container_id.is_empty() {
-        eprintln!("Container ID contains no hex characters: '{}'", container_id);
-        return Ok(None);
-    }
-
-    println!("Using container ID: '{}' (cleaned: '{}')", container_id, clean_container_id);
-
-    // Try with both the original and cleaned ID
-    let ids_to_try = vec![&clean_container_id, &container_id];
+    // Try to inspect the container
+    println!("Attempting to inspect container with ID: '{}'", container_id);
     
-    for id in ids_to_try {
-        println!("Attempting to inspect container with ID: '{}'", id);
-        
-        match docker.inspect_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));
-                    }
+    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");
-                return Ok(Some("unknown".to_string()));
-            }
-            Err(e) => {
-                eprintln!("Error inspecting container with ID '{}': {}", id, e);
-                // Continue to try the next ID
             }
+            eprintln!("Container inspected but no image found in config");
+            Ok(Some("unknown".to_string()))
+        }
+        Err(e) => {
+            eprintln!("Error inspecting container: {}", e);
+            Ok(None)
         }
     }
-
-    eprintln!("All attempts to inspect container failed");
-    Ok(None)
 }
 
 fn extract_container_id(line: &str) -> Option<String> {
-    let parts: Vec<&str> = line.split('/').collect();
-    
-    if let Some(last_part) = parts.last() {
+    // Split by slashes and take the last part
+    if let Some(last_part) = line.split('/').last() {
         let last_part = last_part.trim();
         
-        println!("Processing cgroup line part: '{}'", last_part);
+        // Remove common suffixes
+        let clean_id = last_part
+            .trim_end_matches(".scope")
+            .trim_start_matches("docker-")
+            .trim_start_matches("crio-")
+            .trim_start_matches("containerd-");
         
-        // Common patterns for container IDs in cgroups:
-        
-        // Pattern 1: Full container ID (64-character hex)
-        if last_part.len() == 64 && last_part.chars().all(|c| c.is_ascii_hexdigit()) {
-            println!("Found full container ID: {}", last_part);
-            return Some(last_part.to_string());
+        // Check if it looks like a container ID (hex characters)
+        if clean_id.chars().all(|c| c.is_ascii_hexdigit()) && clean_id.len() >= 12 {
+            return Some(clean_id.to_string());
         }
         
-        // Pattern 2: docker-<short_id>.scope
-        if last_part.starts_with("docker-") && last_part.ends_with(".scope") {
-            let id = last_part
-                .trim_start_matches("docker-")
-                .trim_end_matches(".scope")
-                .to_string();
-            println!("Found docker scope ID: {}", id);
-            return Some(id);
-        }
-        
-        // Pattern 3: <short_id> (12-character hex or similar)
-        if last_part.chars().all(|c| c.is_ascii_hexdigit()) && last_part.len() >= 12 {
-            println!("Found hex ID: {}", last_part);
-            return Some(last_part.to_string());
-        }
-        
-        // Pattern 4: Try to extract ID from any string that looks like it contains a hex ID
-        if let Some(caps) = regex::Regex::new(r"[a-fA-F0-9]{12,64}")
-            .ok()
-            .and_then(|re| re.find(last_part))
-        {
-            let id = caps.as_str().to_string();
-            println!("Extracted ID via regex: {}", id);
-            return Some(id);
-        }
-        
-        // Pattern 5: If nothing else matches, try the last part as-is
-        if !last_part.is_empty() {
-            println!("Using last part as ID: {}", last_part);
-            return Some(last_part.to_string());
+        // If it's not pure hex, try to extract hex sequence
+        let hex_part: String = clean_id.chars()
+            .take_while(|c| c.is_ascii_hexdigit())
+            .collect();
+            
+        if hex_part.len() >= 12 {
+            return Some(hex_part);
         }
     }
     
     None
 }
 
+// Add this function to debug the Docker connection and environment
+async fn debug_docker_environment(docker: &Docker) {
+    println!("=== DOCKER ENVIRONMENT DEBUG ===");
+    
+    // Test basic Docker connection
+    match docker.version().await {
+        Ok(version) => {
+            println!("Docker version: {:?}", version);
+        }
+        Err(e) => {
+            eprintln!("Failed to get Docker version: {}", e);
+        }
+    }
+    
+    // List containers to see what's available - CORRECTED
+    let options = Some(ListContainersOptions {
+        all: true, // include stopped containers
+        ..Default::default()
+    });
+    
+    match docker.list_containers(options).await {
+        Ok(containers) => {
+            println!("Available containers ({}):", containers.len());
+            for container in containers {
+                if let Some(id) = container.id {
+                    let short_id = if id.len() > 12 { &id[..12] } else { &id };
+                    println!("  - ID: {}, Image: {:?}", short_id, container.image);
+                    
+                    // Also print the names for easier identification
+                    if let Some(names) = container.names {
+                        println!("    Names: {:?}", names);
+                    }
+                }
+            }
+        }
+        Err(e) => {
+            eprintln!("Failed to list containers: {}", e);
+        }
+    }
+    
+    // Check if we're actually running in a container
+    if let Ok(content) = std::fs::read_to_string("/proc/self/cgroup") {
+        println!("Cgroup contents:");
+        println!("{}", content);
+    }
+    
+    // Check other container indicators
+    if std::path::Path::new("/.dockerenv").exists() {
+        println!("/.dockerenv exists - running in Docker container");
+    } else {
+        println!("/.dockerenv does not exist");
+    }
+}
+
 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);