fixed returns

WatcherAgent/src/hardware/cpu.rs

@@ -53,7 +53,7 @@ pub async fn get_cpu_temp() -> Result<f64, Box<dyn Error>> {
                         .and_then(|s| s.split_whitespace().next())
                     {
                         if let Ok(temp) = temp_str.replace("°C", "").parse::<f32>() {
-                            return Some(temp);
+                            return Ok(temp);
                         }
                     }
                 }
@@ -63,7 +63,7 @@ pub async fn get_cpu_temp() -> Result<f64, Box<dyn Error>> {
         // 2. Sysfs (Intel/AMD)
         if let Ok(content) = fs::read_to_string("/sys/class/thermal/thermal_zone0/temp") {
             if let Ok(temp) = content.trim().parse::<f32>() {
-                return Some(temp / 1000.0);
+                return Ok(temp / 1000.0);
             }
         }
 
@@ -78,16 +78,14 @@ pub async fn get_cpu_temp() -> Result<f64, Box<dyn Error>> {
                 for path in paths.flatten() {
                     if let Ok(content) = fs::read_to_string(&path) {
                         if let Ok(temp) = content.trim().parse::<f32>() {
-                            return Some(temp / 1000.0);
+                            return Ok(temp / 1000.0);
                         }
                     }
                 }
             }
         }
 
-        Err(anyhow::anyhow!(
+        Err(anyhow::anyhow!("Could not find CPU temperature using sensors or sysfs").into())
-            "Could not find CPU temperature using sensors or sysfs"
-        ))
     }
 
     #[cfg(target_os = "windows")]

WatcherAgent/src/hardware/disk.rs

@@ -1,5 +1,8 @@
+use std::error::Error;
+
 use anyhow::Result;
-use sysinfo::{Components, Disks, System};
+use sysinfo::DiskUsage;
+use sysinfo::{Component, Components, Disk, Disks, System};
 
 #[derive(Debug)]
 pub struct DiskInfo {
@@ -10,6 +13,14 @@ pub struct DiskInfo {
 
 pub async fn get_disk_info() -> Result<DiskInfo> {
     let disks = Disks::new_with_refreshed_list();
+    let disk_types = [
+        sysinfo::DiskKind::HDD,
+        sysinfo::DiskKind::SSD,
+        sysinfo::DiskKind::Unknown(0),
+    ];
+
+    let (_, _, _, _) = get_disk_utitlization().unwrap();
+
     let mut total = 0;
     let mut used = 0;
 
@@ -28,28 +39,31 @@ pub async fn get_disk_info() -> Result<DiskInfo> {
     })
 }
 
-pub fn get_disk_usage() -> (f64, f64, f64) {
+pub fn get_disk_utitlization() -> Result<(f64, f64, f64, f64), Box<dyn Error>> {
     let mut sys = System::new();
     sys.refresh_all();
-    //sys.refresh_disks_list();
+    let mut count = 0;
 
     let mut total_size = 0u64;
     let mut total_used = 0u64;
-    let mut count = 0;
+    let mut total_available = 0u64;
 
     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()
+            disk.available_space(),
         );
+        println!("[{:?}] {:?}", disk.name(), disk.mount_point());
         if disk.total_space() > 100 * 1024 * 1024 {
             // > 100MB
             total_size += disk.total_space();
+            total_available += disk.available_space();
             total_used += disk.total_space() - disk.available_space();
             count += 1;
         }
@@ -66,7 +80,7 @@ pub fn get_disk_usage() -> (f64, f64, f64) {
     }
 
     // Berechnungen
-    let size_b = if count > 0 {
+    let total_size = if count > 0 {
         total_size as f64 // in Bytes
     } else {
         // Fallback: Versuche df unter Linux
@@ -103,11 +117,41 @@ pub fn get_disk_usage() -> (f64, f64, f64) {
         }
     };
 
-    let usage = if total_size > 0 {
+    let usage = if total_size > 0.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
+    Ok((
+        total_size,
+        total_used as f64,
+        total_available as f64,
+        usage as f64,
+    )) // Disk-Temp bleibt 0.0 ohne spezielle Hardware
+}
+
+pub fn get_disk_temp_for_component(component: &Component) -> Option<f64> {
+    if let Some(temp) = component.temperature() {
+        Some(temp as f64)
+    } else {
+        None
+    }
+}
+
+pub fn get_disk_load_for_disk(disk: &Disk) -> Result<(f64, f64, f64, f64), Box<dyn Error>> {
+    let usage: DiskUsage = disk.usage();
+
+    // Assuming DiskUsage has these methods:
+    let total_written_bytes = usage.total_written_bytes as f64;
+    let written_bytes = usage.written_bytes as f64;
+    let total_read_bytes = usage.total_read_bytes as f64;
+    let read_bytes = usage.read_bytes as f64;
+
+    Ok((
+        total_written_bytes,
+        written_bytes,
+        total_read_bytes,
+        read_bytes,
+    ))
 }