modulized everthing

WatcherAgent/src/hardware/disk.rs

@@ -0,0 +1,113 @@
+use anyhow::Result;
+use sysinfo::{Components, Disks, System};
+
+#[derive(Debug)]
+pub struct DiskInfo {
+    pub total: Option<f64>,
+    pub used: Option<f64>,
+    pub free: Option<f64>,
+}
+
+pub async fn get_disk_info() -> Result<DiskInfo> {
+    let disks = Disks::new_with_refreshed_list();
+    let mut total = 0;
+    let mut used = 0;
+
+    for disk in disks.list() {
+        if disk.total_space() > 100 * 1024 * 1024 {
+            // > 100MB
+            total += disk.total_space();
+            used += disk.total_space() - disk.available_space();
+        }
+    }
+
+    Ok(DiskInfo {
+        total: Some(total as f64),
+        used: Some(used as f64),
+        free: Some((total - used) as f64),
+    })
+}
+
+pub fn get_disk_usage() -> (f64, f64, f64) {
+    let mut sys = System::new();
+    sys.refresh_all();
+    //sys.refresh_disks_list();
+
+    let mut total_size = 0u64;
+    let mut total_used = 0u64;
+    let mut count = 0;
+
+    let disks = Disks::new_with_refreshed_list();
+    for disk in disks.list() {
+        // Ignoriere CD-ROMs und kleine Systempartitionen
+        println!(
+            "Disk_Name: {:?}, Disk_Kind: {}, Total: {}, Available: {}",
+            disk.name(),
+            disk.kind(),
+            disk.total_space(),
+            disk.available_space()
+        );
+        if disk.total_space() > 100 * 1024 * 1024 {
+            // > 100MB
+            total_size += disk.total_space();
+            total_used += disk.total_space() - disk.available_space();
+            count += 1;
+        }
+    }
+    let components = Components::new_with_refreshed_list();
+    for component in &components {
+        if let Some(temperature) = component.temperature() {
+            println!(
+                "Component_Label: {}, Temperature: {}°C",
+                component.label(),
+                temperature
+            );
+        }
+    }
+
+    // Berechnungen
+    let size_b = if count > 0 {
+        total_size as f64 // in Bytes
+    } else {
+        // Fallback: Versuche df unter Linux
+        println!("Fallback: Using 'df' command to get disk info.");
+        #[cfg(target_os = "linux")]
+        {
+            use std::process::Command;
+            if let Ok(output) = Command::new("df")
+                .arg("-B1")
+                .arg("--output=size,used")
+                .output()
+            {
+                let stdout = String::from_utf8_lossy(&output.stdout);
+                for line in stdout.lines().skip(1) {
+                    let parts: Vec<&str> = line.split_whitespace().collect();
+                    if parts.len() == 2 {
+                        if let (Ok(size), Ok(used)) =
+                            (parts[0].parse::<u64>(), parts[1].parse::<u64>())
+                        {
+                            total_size += size;
+                            total_used += used;
+                            count += 1;
+                        }
+                    }
+                }
+                total_size as f64 // in Bytes
+            } else {
+                0.0
+            }
+        }
+        #[cfg(not(target_os = "linux"))]
+        {
+            0.0
+        }
+    };
+
+    let usage = if total_size > 0 {
+        (total_used as f64 / total_size as f64) * 100.0
+    } else {
+        0.0
+    };
+
+    (size_b, usage, 0.0) // Disk-Temp bleibt 0.0 ohne spezielle Hardware
+}