added container broadcasting

WatcherAgent/src/api.rs

@@ -12,10 +12,12 @@
 /// These functions are called from the main agent loop and background tasks. All network operations are asynchronous and robust to transient failures.
 use std::time::Duration;
 
+use crate::docker::container;
 use crate::docker::serverclientcomm::handle_server_message;
 use crate::hardware::HardwareInfo;
 use crate::models::{
-    Acknowledgment, HeartbeatDto, IdResponse, MetricDto, RegistrationDto, ServerMessage, DockerMetricDto
+    Acknowledgment, DockerMetricDto, DockerRegistrationDto, HeartbeatDto, IdResponse, MetricDto,
+    RegistrationDto, ServerMessage,
 };
 
 use anyhow::Result;
@@ -151,6 +153,46 @@ async fn get_server_id_by_ip(
     }
 }
 
+pub async fn broadcast_docker_containers(
+    base_url: &str,
+    server_id: u16,
+    container_dto: &mut DockerRegistrationDto,
+) -> Result<(u16, String), Box<dyn Error + Send + Sync>> {
+    // First get local IP
+    println!("Preparing to broadcast docker containers...");
+    // Create HTTP client for registration
+    let client = Client::builder()
+        .danger_accept_invalid_certs(true)
+        .build()?;
+
+    // Prepare registration data
+    let container_dto = container_dto;
+    container_dto.server_id = server_id;
+
+    // Try to register (will retry on failure)
+    loop {
+        println!("Attempting to broadcast containers...");
+        let url = format!("{}/monitoring/service-discovery", base_url);
+        match client.post(&url).json(&container_dto).send().await {
+            Ok(resp) if resp.status().is_success() => {
+                println!("✅ Successfully broadcasted docker container.");
+            }
+            Ok(resp) => {
+                let status = resp.status();
+                let text = resp.text().await.unwrap_or_default();
+                println!(
+                    "⚠️ Broadcasting failed ({}): {} (will retry in 10 seconds)",
+                    status, text
+                );
+            }
+            Err(err) => {
+                println!("⚠️ Broadcasting failed: {} (will retry in 10 seconds)", err);
+            }
+        }
+        sleep(Duration::from_secs(10)).await;
+    }
+}
+
 /// Periodically sends heartbeat signals to the backend server to indicate agent liveness.
 ///
 /// This function runs in a background task and will retry on network errors.
@@ -359,7 +401,3 @@ pub async fn send_docker_metrics(
 
     Ok(())
 }
-
-pub async fn broadcast_docker_containers() {
-    // Placeholder for future implementation
-}

WatcherAgent/src/docker/container.rs

@@ -4,7 +4,7 @@
 //!
 use crate::docker::stats;
 use crate::docker::stats::{ContainerCpuInfo, ContainerNetworkInfo};
-use crate::models::{DockerRegistrationDto, DockerMetricDto, DockerContainer};
+use crate::models::DockerContainer;
 
 use bollard::query_parameters::{
     CreateImageOptions, ListContainersOptions, RestartContainerOptions,
@@ -178,14 +178,15 @@ pub async fn get_network_stats(
         Ok(net_info)
     } else {
         // Return default network info if not found
+        println!("No network info found for container {}", container_id);
         Ok(ContainerNetworkInfo {
-            container_id: container_id.to_string(),
+            container_id: Some(container_id.to_string()),
-            rx_bytes: 0,
+            rx_bytes: None,
-            tx_bytes: 0,
+            tx_bytes: None,
-            rx_packets: 0,
+            rx_packets: None,
-            tx_packets: 0,
+            tx_packets: None,
-            rx_errors: 0,
+            rx_errors: None,
-            tx_errors: 0,
+            tx_errors: None,
         })
     }
 }
@@ -201,12 +202,13 @@ pub async fn get_cpu_stats(
         Ok(cpu_info)
     } else {
         // Return default CPU info if not found
+        println!("No CPU info found for container {}", container_id);
         Ok(ContainerCpuInfo {
-            container_id: container_id.to_string(),
+            container_id: Some(container_id.to_string()),
-            cpu_usage_percent: 0.0,
+            cpu_usage_percent: None,
-            system_cpu_usage: 0,
+            system_cpu_usage: None,
-            container_cpu_usage: 0,
+            container_cpu_usage: None,
-            online_cpus: 1,
+            online_cpus: None,
         })
     }
 }

WatcherAgent/src/docker/mod.rs

@@ -11,8 +11,11 @@ pub mod container;
 pub mod serverclientcomm;
 pub mod stats;
 
-use crate::models::{DockerRegistrationDto, DockerMetricDto, DockerContainer, DockerContainerInfo};
+use crate::models::{
-use bollard::{query_parameters::InspectContainerOptions, Docker};
+    DockerCollectMetricDto, DockerContainer, DockerContainerCpuDto, DockerContainerInfo,
+    DockerContainerNetworkDto, DockerContainerRamDto, DockerMetricDto, DockerRegistrationDto,
+};
+use bollard::Docker;
 use std::error::Error;
 
 /// Main Docker manager that holds the Docker client and provides all operations
@@ -60,14 +63,20 @@ impl DockerManager {
                 id: container.id,
                 image: container.image,
                 name: container.name,
-
             }))
     }
 
     /// Gets the current client version (image name) if running in Docker
     pub async fn get_client_version(&self) -> String {
         match self.get_client_container().await {
-            Ok(Some(container)) => container.image.clone().unwrap().split(':').next().unwrap_or("unknown").to_string(),
+            Ok(Some(container)) => container
+                .image
+                .clone()
+                .unwrap()
+                .split(':')
+                .next()
+                .unwrap_or("unknown")
+                .to_string(),
             Ok(None) => {
                 println!("Warning: No WatcherAgent container found");
                 "unknown".to_string()
@@ -118,26 +127,24 @@ impl DockerManager {
     }
 
     /// Collects Docker metrics for all containers
-    pub async fn collect_metrics(
+    pub async fn collect_metrics(&self) -> Result<DockerMetricDto, Box<dyn Error + Send + Sync>> {
-        &self,
-    ) -> Result<DockerMetricDto, Box<dyn Error + Send + Sync>> {
         let containers = self.get_containers().await?;
         let (cpu_stats, net_stats, mem_stats) = stats::get_container_stats(&self.docker).await?;
 
-        let container_infos: Vec<_> = containers
+        let container_infos_total: Vec<_> = containers
             .into_iter()
             .map(|container| {
                 let cpu = cpu_stats
                     .iter()
-                    .find(|c| c.container_id == container.id)
+                    .find(|c| c.container_id == Some(container.id.clone()))
                     .cloned();
                 let network = net_stats
                     .iter()
-                    .find(|n| n.container_id == container.id)
+                    .find(|n| n.container_id == Some(container.id.clone()))
                     .cloned();
                 let ram = mem_stats
                     .iter()
-                    .find(|m| m.container_id == container.id)
+                    .find(|m| m.container_id == Some(container.id.clone()))
                     .cloned();
 
                 DockerContainerInfo {
@@ -150,6 +157,43 @@ impl DockerManager {
             })
             .collect();
 
+        let container_infos: Vec<DockerCollectMetricDto> = container_infos_total
+            .into_iter()
+            .map(|info| DockerCollectMetricDto {
+                id: Some(info.container.unwrap().id).unwrap_or("".to_string()),
+                cpu: info
+                    .cpu
+                    .unwrap()
+                    .cpu_usage_percent
+                    .map(|load| DockerContainerCpuDto {
+                        cpu_load: Some(load),
+                    })
+                    .unwrap_or(DockerContainerCpuDto { cpu_load: None }),
+                ram: info
+                    .ram
+                    .unwrap()
+                    .memory_usage_percent
+                    .map(|load| DockerContainerRamDto {
+                        cpu_load: Some(load),
+                    })
+                    .unwrap_or(DockerContainerRamDto { cpu_load: None }),
+                network: DockerContainerNetworkDto {
+                    net_in: info
+                        .network
+                        .as_ref()
+                        .unwrap()
+                        .rx_bytes
+                        .map(|bytes| bytes as f64)
+                        .or(Some(0.0)),
+                    net_out: info
+                        .network
+                        .unwrap()
+                        .tx_bytes
+                        .map(|bytes| bytes as f64)
+                        .or(Some(0.0)),
+                },
+            })
+            .collect();
         let dto = DockerMetricDto {
             server_id: 0,
             containers: serde_json::to_string(&container_infos)?,
@@ -157,6 +201,19 @@ impl DockerManager {
 
         Ok(dto)
     }
+
+    pub async fn create_registration_dto(
+        &self,
+    ) -> Result<DockerRegistrationDto, Box<dyn Error + Send + Sync>> {
+        let containers = self.get_containers().await?;
+        let dto = DockerRegistrationDto {
+            server_id: 0,
+            //container_count,
+            containers: serde_json::to_string(&containers)?,
+        };
+
+        Ok(dto)
+    }
 }
 
 // Keep these as utility functions if needed, but they should use DockerManager internally

WatcherAgent/src/docker/serverclientcomm.rs

@@ -5,7 +5,7 @@
 use crate::models::ServerMessage;
 
 use super::container::{restart_container, update_docker_image};
-use bollard::query_parameters::{CreateImageOptions, RestartContainerOptions};
+//use bollard::query_parameters::{CreateImageOptions, RestartContainerOptions};
 use bollard::Docker;
 use std::error::Error;
 
@@ -40,7 +40,7 @@ pub async fn handle_server_message(
             if let Some(image_name) = msg.data.get("image").and_then(|v| v.as_str()) {
                 println!("Received restart command for image: {}", image_name);
                 // Call your update_docker_image function here
-                update_docker_image(docker, image_name).await?;
+                restart_container(docker, image_name).await?;
                 Ok(())
             } else {
                 Err("Missing image name in update message".into())

WatcherAgent/src/docker/stats/cpu.rs

@@ -70,11 +70,11 @@ pub async fn get_single_container_cpu_stats(
                 };
 
                 return Ok(Some(ContainerCpuInfo {
-                    container_id: container_id.to_string(),
+                    container_id: Some(container_id.to_string()),
-                    cpu_usage_percent: cpu_percent,
+                    cpu_usage_percent: Some(cpu_percent),
-                    system_cpu_usage: cpu_stats.system_cpu_usage.unwrap_or(0),
+                    system_cpu_usage: Some(cpu_stats.system_cpu_usage.unwrap_or(0)),
-                    container_cpu_usage: cpu_usage.total_usage.unwrap_or(0),
+                    container_cpu_usage: Some(cpu_usage.total_usage.unwrap_or(0)),
-                    online_cpus,
+                    online_cpus: Some(online_cpus),
                 }));
             }
         }
@@ -91,6 +91,9 @@ pub async fn get_average_cpu_usage(docker: &Docker) -> Result<f64, Box<dyn Error
         return Ok(0.0);
     }
 
-    let total_cpu: f64 = cpu_infos.iter().map(|cpu| cpu.cpu_usage_percent).sum();
+    let total_cpu: f64 = cpu_infos
+        .iter()
+        .map(|cpu| cpu.cpu_usage_percent.unwrap())
+        .sum();
     Ok(total_cpu / cpu_infos.len() as f64)
-}
+}

WatcherAgent/src/docker/stats/mod.rs

@@ -6,30 +6,30 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ContainerCpuInfo {
-    pub container_id: String,
+    pub container_id: Option<String>,
-    pub cpu_usage_percent: f64,
+    pub cpu_usage_percent: Option<f64>,
-    pub system_cpu_usage: u64,
+    pub system_cpu_usage: Option<u64>,
-    pub container_cpu_usage: u64,
+    pub container_cpu_usage: Option<u64>,
-    pub online_cpus: u32,
+    pub online_cpus: Option<u32>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ContainerNetworkInfo {
-    pub container_id: String,
+    pub container_id: Option<String>,
-    pub rx_bytes: u64,
+    pub rx_bytes: Option<u64>,
-    pub tx_bytes: u64,
+    pub tx_bytes: Option<u64>,
-    pub rx_packets: u64,
+    pub rx_packets: Option<u64>,
-    pub tx_packets: u64,
+    pub tx_packets: Option<u64>,
-    pub rx_errors: u64,
+    pub rx_errors: Option<u64>,
-    pub tx_errors: u64,
+    pub tx_errors: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ContainerMemoryInfo {
-    pub container_id: String,
+    pub container_id: Option<String>,
-    pub memory_usage: u64,
+    pub memory_usage: Option<u64>,
-    pub memory_limit: u64,
+    pub memory_limit: Option<u64>,
-    pub memory_usage_percent: f64,
+    pub memory_usage_percent: Option<f64>,
 }
 
 use bollard::Docker;
@@ -38,7 +38,14 @@ use std::error::Error;
 /// Get container statistics for all containers using an existing Docker client
 pub async fn get_container_stats(
     docker: &Docker,
-) -> Result<(Vec<ContainerCpuInfo>, Vec<ContainerNetworkInfo>, Vec<ContainerMemoryInfo>), Box<dyn Error + Send + Sync>> {
+) -> Result<
+    (
+        Vec<ContainerCpuInfo>,
+        Vec<ContainerNetworkInfo>,
+        Vec<ContainerMemoryInfo>,
+    ),
+    Box<dyn Error + Send + Sync>,
+> {
     let cpu_infos = cpu::get_all_containers_cpu_stats(docker).await?;
     let net_infos = network::get_all_containers_network_stats(docker).await?;
     let mem_infos = ram::get_all_containers_memory_stats(docker).await?;
@@ -50,8 +57,14 @@ pub async fn get_container_stats(
 pub async fn get_single_container_stats(
     docker: &Docker,
     container_id: &str,
-) -> Result<(Option<ContainerCpuInfo>, Option<ContainerNetworkInfo>, Option<ContainerMemoryInfo>), Box<dyn Error + Send + Sync>>
+) -> Result<
-{
+    (
+        Option<ContainerCpuInfo>,
+        Option<ContainerNetworkInfo>,
+        Option<ContainerMemoryInfo>,
+    ),
+    Box<dyn Error + Send + Sync>,
+> {
     let cpu_info = cpu::get_single_container_cpu_stats(docker, container_id).await?;
     let net_info = network::get_single_container_network_stats(docker, container_id).await?;
     let mem_info = ram::get_single_container_memory_stats(docker, container_id).await?;
@@ -74,4 +87,4 @@ pub async fn get_average_cpu_usage(docker: &Docker) -> Result<f64, Box<dyn Error
 /// Get total memory usage across all containers
 pub async fn get_total_memory_usage(docker: &Docker) -> Result<u64, Box<dyn Error + Send + Sync>> {
     ram::get_total_memory_usage(docker).await
-}
+}

WatcherAgent/src/docker/stats/network.rs

@@ -51,13 +51,13 @@ pub async fn get_single_container_network_stats(
             // Take the first network interface (usually eth0)
             if let Some((_name, net)) = networks.into_iter().next() {
                 return Ok(Some(ContainerNetworkInfo {
-                    container_id: container_id.to_string(),
+                    container_id: Some(container_id.to_string()),
-                    rx_bytes: net.rx_bytes.unwrap(),
+                    rx_bytes: net.rx_bytes,
-                    tx_bytes: net.tx_bytes.unwrap(),
+                    tx_bytes: net.tx_bytes,
-                    rx_packets: net.rx_packets.unwrap(),
+                    rx_packets: net.rx_packets,
-                    tx_packets: net.tx_packets.unwrap(),
+                    tx_packets: net.tx_packets,
-                    rx_errors: net.rx_errors.unwrap(),
+                    rx_errors: net.rx_errors,
-                    tx_errors: net.tx_errors.unwrap(),
+                    tx_errors: net.tx_errors,
                 }));
             }
         }
@@ -72,8 +72,8 @@ pub async fn get_total_network_stats(
 ) -> Result<(u64, u64), Box<dyn Error + Send + Sync>> {
     let net_infos = get_all_containers_network_stats(docker).await?;
 
-    let total_rx: u64 = net_infos.iter().map(|net| net.rx_bytes).sum();
+    let total_rx: u64 = net_infos.iter().map(|net| net.rx_bytes.unwrap()).sum();
-    let total_tx: u64 = net_infos.iter().map(|net| net.tx_bytes).sum();
+    let total_tx: u64 = net_infos.iter().map(|net| net.tx_bytes.unwrap()).sum();
 
     Ok((total_rx, total_tx))
-}
+}

WatcherAgent/src/docker/stats/ram.rs

@@ -58,10 +58,10 @@ pub async fn get_single_container_memory_stats(
             };
 
             return Ok(Some(ContainerMemoryInfo {
-                container_id: container_id.to_string(),
+                container_id: Some(container_id.to_string()),
-                memory_usage,
+                memory_usage: Some(memory_usage),
-                memory_limit,
+                memory_limit: Some(memory_limit),
-                memory_usage_percent,
+                memory_usage_percent: Some(memory_usage_percent),
             }));
         }
     }
@@ -72,6 +72,6 @@ pub async fn get_single_container_memory_stats(
 /// Get total memory usage across all containers
 pub async fn get_total_memory_usage(docker: &Docker) -> Result<u64, Box<dyn Error + Send + Sync>> {
     let mem_infos = get_all_containers_memory_stats(docker).await?;
-    let total_memory: u64 = mem_infos.iter().map(|mem| mem.memory_usage).sum();
+    let total_memory: u64 = mem_infos.iter().map(|mem| mem.memory_usage.unwrap()).sum();
     Ok(total_memory)
-}
+}

WatcherAgent/src/main.rs

@@ -94,7 +94,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         Ok((id, ip)) => {
             println!("Registered with server. ID: {}, IP: {}", id, ip);
             (id, ip)
-        },
+        }
         Err(e) => {
             eprintln!("Fehler bei der Registrierung am Server: {e}");
             return Err(e);
@@ -112,6 +112,19 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     };
     println!("Client Version: {}", client_version);
 
+    // Prepare Docker registration DTO
+    let container_dto = if let Some(ref docker_manager) = docker_manager {
+        docker_manager.create_registration_dto().await?
+    } else {
+        models::DockerRegistrationDto {
+            server_id: 0,
+            //container_count: 0, --- IGNORE ---
+            containers: "[]".to_string(),
+        }
+    };
+    let _ =
+        api::broadcast_docker_containers(server_url, server_id, &mut container_dto.clone()).await?;
+
     // Start background tasks
     // Start server listening for commands (only if Docker is available)
     let listening_handle = if let Some(ref docker_manager) = docker_manager {

WatcherAgent/src/metrics.rs

@@ -10,10 +10,9 @@
 /// ## Usage
 /// The [`Collector`] struct is instantiated in the main loop and runs as a background task, continuously collecting and reporting metrics.
 use std::error::Error;
-use std::sync::Arc;
 use std::time::Duration;
 
-use crate::{api, docker};
+use crate::api;
 use crate::docker::DockerManager;
 //use crate::docker::DockerInfo;
 use crate::hardware::network::NetworkMonitor;
@@ -129,10 +128,7 @@ impl Collector {
     /// NOTE: This is a compilation-safe stub. Implement the Docker collection using your
     /// DockerManager API and container helpers when available.
     pub async fn docker_collect(&self) -> Result<DockerMetricDto, Box<dyn Error + Send + Sync>> {
-        let metrics = self
+        let metrics = self.docker_manager.collect_metrics().await?;
-            .docker_manager
-            .collect_metrics()
-            .await?;
         Ok(DockerMetricDto {
             server_id: self.server_id,
             containers: metrics.containers,

WatcherAgent/src/models.rs

@@ -189,26 +189,28 @@ pub struct Acknowledgment {
 pub struct DockerRegistrationDto {
     /// Unique server identifier (integer)
     pub server_id: u16,
+    /// Number of currently running containers
+    //      pub container_count: usize, --- IGNORE ---
     /// json stringified array of DockerContainer
-    /// 
+    ///
     /// ## Json Example
     /// json format: [{"id":"234dsf234","image":"nginx:latest","name":"webserver"},...]
-    /// 
+    ///
     /// ## Fields
     /// id: unique container ID (first 12 hex digits)
     /// image: docker image name
     /// name: container name
-    pub containers: String // Vec<DockerContainer>,
+    pub containers: String, // Vec<DockerContainer>,
 }
 
 #[derive(Debug, Serialize, Clone)]
 pub struct DockerMetricDto {
     pub server_id: u16,
     /// json stringified array of DockerContainer
-    /// 
+    ///
     /// ## Json Example
     /// json format: [{"id":"234dsf234","status":"running","image":"nginx:latest","name":"webserver","network":{"net_in":1024,"net_out":2048},"cpu":{"cpu_load":12.5},"ram":{"ram_load":10.0}},...]
-    /// 
+    ///
     /// ## Fields
     /// id: unique container ID (first 12 hex digits)
     /// status: "running";"stopped";others
@@ -217,7 +219,33 @@ pub struct DockerMetricDto {
     /// network: network stats
     /// cpu: cpu stats
     /// ram: ram stats
-    pub containers: String // Vec<DockerContainerInfo>,
+    pub containers: String, // Vec<DockerContainerInfo>,
+}
+
+#[derive(Debug, Serialize, Clone)]
+
+pub struct DockerCollectMetricDto {
+    pub id: String,
+    pub cpu: DockerContainerCpuDto,
+    pub ram: DockerContainerRamDto,
+    pub network: DockerContainerNetworkDto,
+}
+
+#[derive(Debug, Serialize, Clone)]
+pub struct DockerContainerCpuDto {
+    pub cpu_load: Option<f64>,
+}
+
+#[derive(Debug, Serialize, Clone)]
+pub struct DockerContainerRamDto {
+    pub cpu_load: Option<f64>,
+}
+
+#[derive(Debug, Serialize, Clone)]
+
+pub struct DockerContainerNetworkDto {
+    pub net_in: Option<f64>,
+    pub net_out: Option<f64>,
 }
 
 #[derive(Debug, Serialize, Clone)]
@@ -234,4 +262,4 @@ pub struct DockerContainer {
     pub id: String,
     pub image: Option<String>,
     pub name: Option<String>,
-}
+}