running parallel tokio tasks for heartbeat and metrics

WatcherAgent/src/main.rs

@@ -7,33 +7,66 @@ pub mod metrics;
 pub mod models;
 
 pub use crate::hardware::gpu;
-use anyhow::Result;
 use std::error::Error;
+use std::marker::Send;
+use std::marker::Sync;
+use std::result::Result;
+use tokio::task::JoinHandle;
+
+async fn flatten<T>(
+    handle: JoinHandle<Result<T, Box<dyn Error + Send + Sync>>>,
+) -> Result<T, Box<dyn Error + Send + Sync>> {
+    match handle.await {
+        Ok(Ok(result)) => Ok(result),
+        Ok(Err(err)) => Err(err),
+        Err(_err) => Err("handling failed".into()),
+    }
+}
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let server_url = "http://localhost:5000";
 
     // Registration
-    let (server_id, ip) = api::register_with_server(server_url).await?;
+    let (server_id, ip) = match api::register_with_server(server_url).await {
+        Ok((id, ip)) => (id, ip),
+        Err(e) => {
+            eprintln!("Fehler bei der Registrierung am Server: {e}");
+            return Err(e.into());
+        }
+    };
 
     // Start background tasks
     // Start heartbeat in background
     let heartbeat_handle = tokio::spawn({
         let ip = ip.clone();
-        async move {
-            if let Err(e) = api::heartbeat_loop(server_url, &ip).await {
-                eprintln!("Heartbeat loop failed: {}", e);
-            }
-        }
+        let server_url = server_url.to_string();
+        async move { api::heartbeat_loop(&server_url, &ip).await }
     });
 
-    heartbeat_handle.await?;
-
     // Main metrics loop
     println!("Starting metrics collection...");
-    let mut collector = metrics::Collector::new(server_id, ip);
-    collector.run(server_url).await?;
+    let metrics_handle = tokio::spawn({
+        let ip = ip.clone();
+        let server_url = server_url.to_string();
+        async move {
+            let mut collector = metrics::Collector::new(server_id, ip);
+            collector.run(&server_url).await
+        }
+    });
+
+    // Warte auf beide Tasks und prüfe explizit auf Fehler
+    let (heartbeat_handle, metrics_handle) =
+        tokio::try_join!(flatten(heartbeat_handle), flatten(metrics_handle))?;
+
+    match (heartbeat_handle, metrics_handle) {
+        (heartbeat, metrics) => println!(
+            "All tasks completed successfully: {:?}, {:?}.",
+            heartbeat, metrics
+        ),
+    }
+
+    println!("All tasks completed successfully.");
 
     Ok(())
 }