added periodically retrying to connect

WatcherAgent/src/main.rs

@@ -166,16 +166,22 @@ async fn get_server_id_by_ip(base_url: &str, ip: &str) -> Result<(i32, String),
                 return Ok((id_resp.id, id_resp.ip_address));
             }
             Ok(resp) if resp.status() == StatusCode::NOT_FOUND => {
-                eprintln!("❌ Server with IP {} not found in database", ip);
+                println!(
-                return Err("Server not registered in database".into());
+                    "🔄 Server with IP {} not found in database (will retry in 30 seconds)",
+                    ip
+                );
+                sleep(Duration::from_secs(30)).await;
             }
             Ok(resp) => {
-                println!("⚠️ Server responded with status: {}", resp.status());
+                println!(
-                sleep(Duration::from_secs(3)).await;
+                    "⚠️ Server responded with status: {} (will retry in 30 seconds)",
+                    resp.status()
+                );
+                sleep(Duration::from_secs(30)).await;
             }
             Err(err) => {
-                println!("❌ Request failed: {}", err);
+                println!("⚠️ Request failed: {} (will retry in 30 seconds)", err);
-                sleep(Duration::from_secs(3)).await;
+                sleep(Duration::from_secs(30)).await;
             }
         }
     }
@@ -185,18 +191,18 @@ async fn register_with_server(base_url: &str) -> Result<(i32, String), Box<dyn E
     // First get local IP
     let ip = local_ip_address::local_ip()?.to_string();
 
-    // Create HTTP client
+    // Get server ID from backend (this will retry until successful)
+    let (server_id, registered_ip) = get_server_id_by_ip(base_url, &ip).await?;
+
+    // Create HTTP client for registration
     let client = Client::builder()
         .danger_accept_invalid_certs(true)
         .build()?;
 
-    // Get server ID from backend
-    let (server_id, registered_ip) = get_server_id_by_ip(base_url, &ip).await?;
-
     // Collect hardware info
     let hardware = HardwareInfo::collect().await?;
 
-    // Send registration data
+    // Prepare registration data
     let registration = RegistrationDto {
         id: server_id,
         ip_address: registered_ip.clone(),
@@ -206,16 +212,28 @@ async fn register_with_server(base_url: &str) -> Result<(i32, String), Box<dyn E
         ram_size: hardware.ram_size,
     };
 
+    // Try to register (will retry on failure)
+    loop {
+        println!("Attempting to register with server...");
         let url = format!("{}/monitoring/register", base_url);
-    let resp = client.post(&url).json(&registration).send().await?;
+        match client.post(&url).json(&registration).send().await {
-
+            Ok(resp) if resp.status().is_success() => {
-    if resp.status().is_success() {
+                println!("✅ Successfully registered with server.");
-        println!("Successfully registered with server.");
+                return Ok((server_id, registered_ip));
-        Ok((server_id, registered_ip))
+            }
-    } else {
+            Ok(resp) => {
-        let text = resp.text().await?;
+                let status = resp.status();
-        eprintln!("Registration failed: {}", text);
+                let text = resp.text().await.unwrap_or_default();
-        Err(text.into())
+                println!(
+                    "⚠️ Registration failed ({}): {} (will retry in 30 seconds)",
+                    status, text
+                );
+            }
+            Err(err) => {
+                println!("⚠️ Registration error: {} (will retry in 30 seconds)", err);
+            }
+        }
+        sleep(Duration::from_secs(30)).await;
     }
 }