From 66428863e617b60974ca140008a8afee90b5fd9d Mon Sep 17 00:00:00 2001 From: donpat1to Date: Sun, 5 Oct 2025 15:21:24 +0200 Subject: [PATCH] moved stats into own folder --- WatcherAgent/src/docker/container.rs | 8 +- WatcherAgent/src/docker/mod.rs | 76 +-------- WatcherAgent/src/docker/stats.rs | 206 ----------------------- WatcherAgent/src/docker/stats/cpu.rs | 96 +++++++++++ WatcherAgent/src/docker/stats/mod.rs | 77 +++++++++ WatcherAgent/src/docker/stats/network.rs | 79 +++++++++ WatcherAgent/src/docker/stats/ram.rs | 77 +++++++++ WatcherAgent/src/metrics.rs | 55 ++++++ WatcherAgent/src/models.rs | 20 +-- 9 files changed, 404 insertions(+), 290 deletions(-) delete mode 100644 WatcherAgent/src/docker/stats.rs diff --git a/WatcherAgent/src/docker/container.rs b/WatcherAgent/src/docker/container.rs index 7356ebf..9cb360c 100644 --- a/WatcherAgent/src/docker/container.rs +++ b/WatcherAgent/src/docker/container.rs @@ -53,8 +53,8 @@ pub async fn get_available_containers(docker: &Docker) -> Vec { Some(DockerContainer { id: short_id.to_string(), - image, - name: name, + image: Some(image), + name: Some(name), }) }) .collect() @@ -172,7 +172,7 @@ pub async fn get_network_stats( docker: &Docker, container_id: &str, ) -> Result> { - let (_, net_info) = stats::get_single_container_stats(docker, container_id).await?; + let (_, net_info, _) = stats::get_single_container_stats(docker, container_id).await?; if let Some(net_info) = net_info { Ok(net_info) @@ -195,7 +195,7 @@ pub async fn get_cpu_stats( docker: &Docker, container_id: &str, ) -> Result> { - let (cpu_info, _) = stats::get_single_container_stats(docker, container_id).await?; + let (cpu_info, _, _) = stats::get_single_container_stats(docker, container_id).await?; if let Some(cpu_info) = cpu_info { Ok(cpu_info) diff --git a/WatcherAgent/src/docker/mod.rs b/WatcherAgent/src/docker/mod.rs index dad86c1..e652a4c 100644 --- a/WatcherAgent/src/docker/mod.rs +++ b/WatcherAgent/src/docker/mod.rs @@ -55,18 +55,19 @@ impl DockerManager { Ok(containers .into_iter() - .find(|c| c.image.contains(client_image)) + .find(|c| c.clone().image.unwrap().contains(client_image)) .map(|container| DockerContainer { 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.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() @@ -102,60 +103,7 @@ impl DockerManager { .collect()) } - /// Gets container metrics for all containers - pub async fn get_container_metrics( - &self, - ) -> Result, Box> { - let containers = container::get_available_containers(&self.docker).await; - let mut metrics = Vec::new(); - - for container in containers { - // Get network stats (you'll need to implement this in container.rs) - let network_stats = container::get_network_stats(&self.docker, &container.id).await?; - // Get CPU stats (you'll need to implement this in container.rs) - let cpu_stats = container::get_cpu_stats(&self.docker, &container.id).await?; - - // Get current status by inspecting the container - let status = match self - .docker - .inspect_container(&container.id, None::) - .await - { - Ok(container_info) => { - // Extract status from container state and convert to string - container_info - .state - .and_then(|state| state.status) - .map(|status_enum| { - match status_enum { - bollard::models::ContainerStateStatusEnum::CREATED => "created", - bollard::models::ContainerStateStatusEnum::RUNNING => "running", - bollard::models::ContainerStateStatusEnum::PAUSED => "paused", - bollard::models::ContainerStateStatusEnum::RESTARTING => { - "restarting" - } - bollard::models::ContainerStateStatusEnum::REMOVING => "removing", - bollard::models::ContainerStateStatusEnum::EXITED => "exited", - bollard::models::ContainerStateStatusEnum::DEAD => "dead", - bollard::secret::ContainerStateStatusEnum::EMPTY => todo!(), - } - .to_string() - }) - .unwrap_or_else(|| "unknown".to_string()) - } - Err(_) => "unknown".to_string(), - }; - - metrics.push(DockerContainerMetricDto { - server_id: container.id, - status: status, - network: network_stats, - cpu: cpu_stats, - }); - } - - Ok(metrics) - } + /// Gets the number of running containers pub async fn get_container_count(&self) -> Result> { @@ -170,18 +118,6 @@ impl DockerManager { ) -> Result<(), Box> { container::restart_container(&self.docker, container_id).await } - - /// Gets total network statistics across all containers - pub async fn get_total_network_stats( - &self, - ) -> Result<(u64, u64), Box> { - let metrics = self.get_container_metrics().await?; - - let net_in_total: u64 = metrics.iter().map(|m| m.network.rx_bytes).sum(); - let net_out_total: u64 = metrics.iter().map(|m| m.network.tx_bytes).sum(); - - Ok((net_in_total, net_out_total)) - } } // Keep these as utility functions if needed, but they should use DockerManager internally @@ -193,11 +129,11 @@ impl DockerContainer { /// Returns the image name pub fn image(&self) -> &str { - &self.image + &self.image.as_deref().unwrap_or("unknown") } /// Returns the container name pub fn name(&self) -> &str { - &self.name + &self.name.as_deref().unwrap_or("unknown") } } diff --git a/WatcherAgent/src/docker/stats.rs b/WatcherAgent/src/docker/stats.rs deleted file mode 100644 index ed87640..0000000 --- a/WatcherAgent/src/docker/stats.rs +++ /dev/null @@ -1,206 +0,0 @@ -use bollard::query_parameters::{ListContainersOptions, StatsOptions}; -use bollard::Docker; -use futures_util::stream::TryStreamExt; -use serde::{Deserialize, Serialize}; -use std::error::Error; - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct ContainerCpuInfo { - pub container_id: String, - pub cpu_usage_percent: f64, - pub system_cpu_usage: u64, - pub container_cpu_usage: u64, - pub online_cpus: u32, -} - -#[derive(Debug, Serialize, Deserialize, Clone)] -pub struct ContainerNetworkInfo { - pub container_id: String, - pub rx_bytes: u64, - pub tx_bytes: u64, - pub rx_packets: u64, - pub tx_packets: u64, - pub rx_errors: u64, - pub tx_errors: u64, -} - -/// Get container statistics for all containers using an existing Docker client -pub async fn get_container_stats( - docker: &Docker, -) -> Result<(Vec, Vec), Box> { - let containers = docker - .list_containers(Some(ListContainersOptions { - all: true, - ..Default::default() - })) - .await?; - - let mut cpu_infos = Vec::new(); - let mut net_infos = Vec::new(); - - for container in containers { - let id = container.id.unwrap_or_default(); - - // Skip if no ID - if id.is_empty() { - continue; - } - - let mut stats_stream = docker.stats( - &id, - Some(StatsOptions { - stream: false, - one_shot: true, - }), - ); - - if let Some(stats) = stats_stream.try_next().await? { - // CPU Info - if let (Some(cpu_stats), Some(precpu_stats)) = (&stats.cpu_stats, &stats.precpu_stats) { - if let (Some(cpu_usage), Some(pre_cpu_usage)) = - (&cpu_stats.cpu_usage, &precpu_stats.cpu_usage) - { - let cpu_delta = cpu_usage - .total_usage - .unwrap_or(0) - .saturating_sub(pre_cpu_usage.total_usage.unwrap_or(0)); - - let system_delta = cpu_stats - .system_cpu_usage - .unwrap_or(0) - .saturating_sub(precpu_stats.system_cpu_usage.unwrap_or(0)); - - let online_cpus = cpu_stats.online_cpus.unwrap_or(1); - - let cpu_percent = if system_delta > 0 && online_cpus > 0 { - (cpu_delta as f64 / system_delta as f64) * online_cpus as f64 * 100.0 - } else { - 0.0 - }; - - cpu_infos.push(ContainerCpuInfo { - container_id: id.clone(), - cpu_usage_percent: cpu_percent, - system_cpu_usage: cpu_stats.system_cpu_usage.unwrap_or(0), - container_cpu_usage: cpu_usage.total_usage.unwrap_or(0), - online_cpus, - }); - } - } - - // Network Info - if let Some(networks) = stats.networks { - for (_name, net) in networks { - net_infos.push(ContainerNetworkInfo { - container_id: id.clone(), - rx_bytes: net.rx_bytes.unwrap(), - tx_bytes: net.tx_bytes.unwrap(), - rx_packets: net.rx_packets.unwrap(), - tx_packets: net.tx_packets.unwrap(), - rx_errors: net.rx_errors.unwrap(), - tx_errors: net.tx_errors.unwrap(), - }); - } - } - } - } - - Ok((cpu_infos, net_infos)) -} - -/// Get container statistics for a specific container -pub async fn get_single_container_stats( - docker: &Docker, - container_id: &str, -) -> Result<(Option, Option), Box> -{ - let mut stats_stream = docker.stats( - container_id, - Some(StatsOptions { - stream: false, - one_shot: true, - }), - ); - - if let Some(stats) = stats_stream.try_next().await? { - let mut cpu_info = None; - let mut net_info = None; - - // CPU Info - if let (Some(cpu_stats), Some(precpu_stats)) = (&stats.cpu_stats, &stats.precpu_stats) { - if let (Some(cpu_usage), Some(pre_cpu_usage)) = - (&cpu_stats.cpu_usage, &precpu_stats.cpu_usage) - { - let cpu_delta = cpu_usage - .total_usage - .unwrap_or(0) - .saturating_sub(pre_cpu_usage.total_usage.unwrap_or(0)); - - let system_delta = cpu_stats - .system_cpu_usage - .unwrap_or(0) - .saturating_sub(precpu_stats.system_cpu_usage.unwrap_or(0)); - - let online_cpus = cpu_stats.online_cpus.unwrap_or(1); - - let cpu_percent = if system_delta > 0 && online_cpus > 0 { - (cpu_delta as f64 / system_delta as f64) * online_cpus as f64 * 100.0 - } else { - 0.0 - }; - - cpu_info = Some(ContainerCpuInfo { - container_id: container_id.to_string(), - cpu_usage_percent: cpu_percent, - system_cpu_usage: cpu_stats.system_cpu_usage.unwrap_or(0), - container_cpu_usage: cpu_usage.total_usage.unwrap_or(0), - online_cpus, - }); - } - } - - // Network Info - if let Some(networks) = stats.networks { - // Take the first network interface (usually eth0) - if let Some((_name, net)) = networks.into_iter().next() { - net_info = Some(ContainerNetworkInfo { - container_id: container_id.to_string(), - rx_bytes: net.rx_bytes.unwrap(), - tx_bytes: net.tx_bytes.unwrap(), - rx_packets: net.rx_packets.unwrap(), - tx_packets: net.tx_packets.unwrap(), - rx_errors: net.rx_errors.unwrap(), - tx_errors: net.tx_errors.unwrap(), - }); - } - } - - Ok((cpu_info, net_info)) - } else { - Ok((None, None)) - } -} - -/// Get total network statistics across all containers -pub async fn get_total_network_stats( - docker: &Docker, -) -> Result<(u64, u64), Box> { - let (_, net_infos) = get_container_stats(docker).await?; - - let total_rx: u64 = net_infos.iter().map(|net| net.rx_bytes).sum(); - let total_tx: u64 = net_infos.iter().map(|net| net.tx_bytes).sum(); - - Ok((total_rx, total_tx)) -} - -/// Get average CPU usage across all containers -pub async fn get_average_cpu_usage(docker: &Docker) -> Result> { - let (cpu_infos, _) = get_container_stats(docker).await?; - - if cpu_infos.is_empty() { - return Ok(0.0); - } - - let total_cpu: f64 = cpu_infos.iter().map(|cpu| cpu.cpu_usage_percent).sum(); - Ok(total_cpu / cpu_infos.len() as f64) -} diff --git a/WatcherAgent/src/docker/stats/cpu.rs b/WatcherAgent/src/docker/stats/cpu.rs index e69de29..f25b1f6 100644 --- a/WatcherAgent/src/docker/stats/cpu.rs +++ b/WatcherAgent/src/docker/stats/cpu.rs @@ -0,0 +1,96 @@ +use super::ContainerCpuInfo; +use bollard::query_parameters::{ListContainersOptions, StatsOptions}; +use bollard::Docker; +use futures_util::stream::TryStreamExt; +use std::error::Error; + +/// Get CPU statistics for all containers +pub async fn get_all_containers_cpu_stats( + docker: &Docker, +) -> Result, Box> { + let containers = docker + .list_containers(Some(ListContainersOptions { + all: true, + ..Default::default() + })) + .await?; + + let mut cpu_infos = Vec::new(); + + for container in containers { + let id = container.id.unwrap_or_default(); + + // Skip if no ID + if id.is_empty() { + continue; + } + + if let Some(cpu_info) = get_single_container_cpu_stats(docker, &id).await? { + cpu_infos.push(cpu_info); + } + } + + Ok(cpu_infos) +} + +/// Get CPU statistics for a specific container +pub async fn get_single_container_cpu_stats( + docker: &Docker, + container_id: &str, +) -> Result, Box> { + let mut stats_stream = docker.stats( + container_id, + Some(StatsOptions { + stream: false, + one_shot: true, + }), + ); + + if let Some(stats) = stats_stream.try_next().await? { + if let (Some(cpu_stats), Some(precpu_stats)) = (&stats.cpu_stats, &stats.precpu_stats) { + if let (Some(cpu_usage), Some(pre_cpu_usage)) = + (&cpu_stats.cpu_usage, &precpu_stats.cpu_usage) + { + let cpu_delta = cpu_usage + .total_usage + .unwrap_or(0) + .saturating_sub(pre_cpu_usage.total_usage.unwrap_or(0)); + + let system_delta = cpu_stats + .system_cpu_usage + .unwrap_or(0) + .saturating_sub(precpu_stats.system_cpu_usage.unwrap_or(0)); + + let online_cpus = cpu_stats.online_cpus.unwrap_or(1); + + let cpu_percent = if system_delta > 0 && online_cpus > 0 { + (cpu_delta as f64 / system_delta as f64) * online_cpus as f64 * 100.0 + } else { + 0.0 + }; + + return Ok(Some(ContainerCpuInfo { + container_id: container_id.to_string(), + cpu_usage_percent: cpu_percent, + system_cpu_usage: cpu_stats.system_cpu_usage.unwrap_or(0), + container_cpu_usage: cpu_usage.total_usage.unwrap_or(0), + online_cpus, + })); + } + } + } + + Ok(None) +} + +/// Get average CPU usage across all containers +pub async fn get_average_cpu_usage(docker: &Docker) -> Result> { + let cpu_infos = get_all_containers_cpu_stats(docker).await?; + + if cpu_infos.is_empty() { + return Ok(0.0); + } + + let total_cpu: f64 = cpu_infos.iter().map(|cpu| cpu.cpu_usage_percent).sum(); + Ok(total_cpu / cpu_infos.len() as f64) +} \ No newline at end of file diff --git a/WatcherAgent/src/docker/stats/mod.rs b/WatcherAgent/src/docker/stats/mod.rs index e69de29..6b4dd33 100644 --- a/WatcherAgent/src/docker/stats/mod.rs +++ b/WatcherAgent/src/docker/stats/mod.rs @@ -0,0 +1,77 @@ +pub mod cpu; +pub mod network; +pub mod ram; + +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct ContainerCpuInfo { + pub container_id: String, + pub cpu_usage_percent: f64, + pub system_cpu_usage: u64, + pub container_cpu_usage: u64, + pub online_cpus: u32, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct ContainerNetworkInfo { + pub container_id: String, + pub rx_bytes: u64, + pub tx_bytes: u64, + pub rx_packets: u64, + pub tx_packets: u64, + pub rx_errors: u64, + pub tx_errors: u64, +} + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct ContainerMemoryInfo { + pub container_id: String, + pub memory_usage: u64, + pub memory_limit: u64, + pub memory_usage_percent: f64, +} + +use bollard::Docker; +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, Vec, Vec), Box> { + 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?; + + Ok((cpu_infos, net_infos, mem_infos)) +} + +/// Get container statistics for a specific container +pub async fn get_single_container_stats( + docker: &Docker, + container_id: &str, +) -> Result<(Option, Option, Option), Box> +{ + 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?; + + Ok((cpu_info, net_info, mem_info)) +} + +/// Get total network statistics across all containers +pub async fn get_total_network_stats( + docker: &Docker, +) -> Result<(u64, u64), Box> { + network::get_total_network_stats(docker).await +} + +/// Get average CPU usage across all containers +pub async fn get_average_cpu_usage(docker: &Docker) -> Result> { + cpu::get_average_cpu_usage(docker).await +} + +/// Get total memory usage across all containers +pub async fn get_total_memory_usage(docker: &Docker) -> Result> { + ram::get_total_memory_usage(docker).await +} \ No newline at end of file diff --git a/WatcherAgent/src/docker/stats/network.rs b/WatcherAgent/src/docker/stats/network.rs index e69de29..d49c918 100644 --- a/WatcherAgent/src/docker/stats/network.rs +++ b/WatcherAgent/src/docker/stats/network.rs @@ -0,0 +1,79 @@ +use super::ContainerNetworkInfo; +use bollard::query_parameters::{ListContainersOptions, StatsOptions}; +use bollard::Docker; +use futures_util::stream::TryStreamExt; +use std::error::Error; + +/// Get network statistics for all containers +pub async fn get_all_containers_network_stats( + docker: &Docker, +) -> Result, Box> { + let containers = docker + .list_containers(Some(ListContainersOptions { + all: true, + ..Default::default() + })) + .await?; + + let mut net_infos = Vec::new(); + + for container in containers { + let id = container.id.unwrap_or_default(); + + // Skip if no ID + if id.is_empty() { + continue; + } + + if let Some(net_info) = get_single_container_network_stats(docker, &id).await? { + net_infos.push(net_info); + } + } + + Ok(net_infos) +} + +/// Get network statistics for a specific container +pub async fn get_single_container_network_stats( + docker: &Docker, + container_id: &str, +) -> Result, Box> { + let mut stats_stream = docker.stats( + container_id, + Some(StatsOptions { + stream: false, + one_shot: true, + }), + ); + + if let Some(stats) = stats_stream.try_next().await? { + if let Some(networks) = stats.networks { + // 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(), + rx_bytes: net.rx_bytes.unwrap(), + tx_bytes: net.tx_bytes.unwrap(), + rx_packets: net.rx_packets.unwrap(), + tx_packets: net.tx_packets.unwrap(), + rx_errors: net.rx_errors.unwrap(), + tx_errors: net.tx_errors.unwrap(), + })); + } + } + } + + Ok(None) +} + +/// Get total network statistics across all containers +pub async fn get_total_network_stats( + docker: &Docker, +) -> Result<(u64, u64), Box> { + 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_tx: u64 = net_infos.iter().map(|net| net.tx_bytes).sum(); + + Ok((total_rx, total_tx)) +} \ No newline at end of file diff --git a/WatcherAgent/src/docker/stats/ram.rs b/WatcherAgent/src/docker/stats/ram.rs index e69de29..b6624ee 100644 --- a/WatcherAgent/src/docker/stats/ram.rs +++ b/WatcherAgent/src/docker/stats/ram.rs @@ -0,0 +1,77 @@ +use super::ContainerMemoryInfo; +use bollard::query_parameters::{ListContainersOptions, StatsOptions}; +use bollard::Docker; +use futures_util::stream::TryStreamExt; +use std::error::Error; + +/// Get memory statistics for all containers +pub async fn get_all_containers_memory_stats( + docker: &Docker, +) -> Result, Box> { + let containers = docker + .list_containers(Some(ListContainersOptions { + all: true, + ..Default::default() + })) + .await?; + + let mut mem_infos = Vec::new(); + + for container in containers { + let id = container.id.unwrap_or_default(); + + // Skip if no ID + if id.is_empty() { + continue; + } + + if let Some(mem_info) = get_single_container_memory_stats(docker, &id).await? { + mem_infos.push(mem_info); + } + } + + Ok(mem_infos) +} + +/// Get memory statistics for a specific container +pub async fn get_single_container_memory_stats( + docker: &Docker, + container_id: &str, +) -> Result, Box> { + let mut stats_stream = docker.stats( + container_id, + Some(StatsOptions { + stream: false, + one_shot: true, + }), + ); + + if let Some(stats) = stats_stream.try_next().await? { + if let Some(memory_stats) = &stats.memory_stats { + let memory_usage = memory_stats.usage.unwrap_or(0); + let memory_limit = memory_stats.limit.unwrap_or(1); // Avoid division by zero + + let memory_usage_percent = if memory_limit > 0 { + (memory_usage as f64 / memory_limit as f64) * 100.0 + } else { + 0.0 + }; + + return Ok(Some(ContainerMemoryInfo { + container_id: container_id.to_string(), + memory_usage, + memory_limit, + memory_usage_percent, + })); + } + } + + Ok(None) +} + +/// Get total memory usage across all containers +pub async fn get_total_memory_usage(docker: &Docker) -> Result> { + let mem_infos = get_all_containers_memory_stats(docker).await?; + let total_memory: u64 = mem_infos.iter().map(|mem| mem.memory_usage).sum(); + Ok(total_memory) +} \ No newline at end of file diff --git a/WatcherAgent/src/metrics.rs b/WatcherAgent/src/metrics.rs index 22d8beb..bf6dfc3 100644 --- a/WatcherAgent/src/metrics.rs +++ b/WatcherAgent/src/metrics.rs @@ -112,4 +112,59 @@ impl Collector { net_tx: hardware.network.tx_rate.unwrap_or_default(), }) } + + /// Gets container metrics for all containers + pub async fn docker_collect( + &self, + ) -> Result, Box> { + let containers = container::get_available_containers(&self.docker).await; + let mut metrics = Vec::new(); + + for container in containers { + // Get network stats (you'll need to implement this in container.rs) + let network_stats = container::get_network_stats(&self.docker, &container.id).await?; + // Get CPU stats (you'll need to implement this in container.rs) + let cpu_stats = container::get_cpu_stats(&self.docker, &container.id).await?; + + // Get current status by inspecting the container + let status = match self + .docker + .inspect_container(&container.id, None::) + .await + { + Ok(container_info) => { + // Extract status from container state and convert to string + container_info + .state + .and_then(|state| state.status) + .map(|status_enum| { + match status_enum { + bollard::models::ContainerStateStatusEnum::CREATED => "created", + bollard::models::ContainerStateStatusEnum::RUNNING => "running", + bollard::models::ContainerStateStatusEnum::PAUSED => "paused", + bollard::models::ContainerStateStatusEnum::RESTARTING => { + "restarting" + } + bollard::models::ContainerStateStatusEnum::REMOVING => "removing", + bollard::models::ContainerStateStatusEnum::EXITED => "exited", + bollard::models::ContainerStateStatusEnum::DEAD => "dead", + bollard::secret::ContainerStateStatusEnum::EMPTY => todo!(), + } + .to_string() + }) + .unwrap_or_else(|| "unknown".to_string()) + } + Err(_) => "unknown".to_string(), + }; + + metrics.push(DockerContainerMetricDto { + server_id: container.id, + status: status, + network: network_stats, + cpu: cpu_stats, + }); + } + + Ok(metrics) + } } diff --git a/WatcherAgent/src/models.rs b/WatcherAgent/src/models.rs index 516a10a..a8c1aa3 100644 --- a/WatcherAgent/src/models.rs +++ b/WatcherAgent/src/models.rs @@ -221,17 +221,17 @@ pub struct DockerMetricDto { } #[derive(Debug, Serialize, Clone)] -pub struct DockerContainer { - pub id: String, - pub status: String, // "running";"stopped";others - pub image: String, - pub name: String, - pub network: stats::ContainerNetworkInfo, - pub cpu: stats::ContainerCpuInfo, - //pub ram: stats::ContainerRamInfo, +pub struct DockerContainerInfo { + pub container: Option, + pub status: Option, // "running";"stopped";others + pub network: Option, + pub cpu: Option, + pub ram: Option, } #[derive(Debug, Serialize, Clone)] -pub struct Docker { - pub containers: Vec, +pub struct DockerContainer { + pub id: String, + pub image: Option, + pub name: Option, } \ No newline at end of file