From 1cc85bfa14ca408271599e51565eb4e0ff421bdb Mon Sep 17 00:00:00 2001 From: donpat1to Date: Sun, 28 Sep 2025 01:00:26 +0200 Subject: [PATCH] added debugging for docker image --- WatcherAgent/src/serverclientcomm.rs | 204 ++++++++++++++------------- 1 file changed, 107 insertions(+), 97 deletions(-) diff --git a/WatcherAgent/src/serverclientcomm.rs b/WatcherAgent/src/serverclientcomm.rs index c802011..d5933c9 100644 --- a/WatcherAgent/src/serverclientcomm.rs +++ b/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> { @@ -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, Box> { + // 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, Box { - 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::).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::).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 { - 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-.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: (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> { if let Ok(container_id) = std::env::var("HOSTNAME") { println!("Restarting container {}", container_id);