rPing: enhance device monitoring by adding status updates and new devices; streamline ping logic and improve error handling

karthik558 · karthik558 · commit 2f5b61733c92 · 2025-03-16T19:58:54.000+05:30
diff --git a/devices.json b/devices.json
@@ -1,12 +1,4 @@
 [
-  {
-    "name": "Firewall",
-    "ip": "192.168.1.1",
-    "category": "Firewall",
-    "sensors": [
-      "Ping"
-    ]
-  },
   {
     "name": "Google DNS",
     "ip": "8.8.8.8",
@@ -29,14 +21,6 @@
     ],
     "http_path": "http://google.com"
   },
-  {
-    "name": "Network Switch",
-    "ip": "192.168.0.100",
-    "category": "Network Equipment",
-    "sensors": [
-      "Ping"
-    ]
-  },
   {
     "name": "Antivirus Server",
     "ip": "8.8.4.4",
@@ -47,5 +31,59 @@
       "Https"
     ],
     "http_path": "https://google.in"
+  },
+  {
+    "name": "Google DNS [1]",
+    "ip": "4.2.2.2",
+    "category": "DNS Server",
+    "sensors": [
+      "Ping",
+      "Http"
+    ],
+    "http_path": "https://google.com"
+  },
+  {
+    "name": "Adguard Server [1]",
+    "ip": "94.140.15.16",
+    "category": "DNS Server",
+    "sensors": [
+      "Ping",
+      "Http"
+    ],
+    "http_path": "https://google.com"
+  },
+  {
+    "name": "Adguard Server [2]",
+    "ip": "94.140.14.15",
+    "category": "DNS Server",
+    "sensors": [
+      "Ping",
+      "Http"
+    ],
+    "http_path": "https://google.com"
+  },
+  {
+    "name": "Cisco Virtual Controller",
+    "ip": "8.8.8.8",
+    "category": "Access Point",
+    "sensors": [
+      "Ping"
+    ]
+  },
+  {
+    "name": "NAS",
+    "ip": "8.8.4.4",
+    "category": "Storage Server",
+    "sensors": [
+      "Ping"
+    ]
+  },
+  {
+    "name": "CCTV Server",
+    "ip": "8.8.8.8",
+    "category": "CCTV",
+    "sensors": [
+      "Ping"
+    ]
   }
 ]
diff --git a/src/main.rs b/src/main.rs
@@ -8,7 +8,7 @@ use rocket::{get, post, delete, routes, State, response::Redirect, catch, catche
 use rocket::serde::json::Json;
 use rocket::fs::{NamedFile, FileServer, relative};
 use models::{Device as ModelDevice, SensorType};
-use log::{info, error, debug};
+use log::{info, error};
 use sensors::{monitor_ping, monitor_http};
 use std::fs::{self, OpenOptions};
 use std::io::{Read, Write};
@@ -60,17 +60,34 @@ async fn process_logs(start_date_parsed: Option<NaiveDate>, end_date_parsed: Opt
 // Define a struct to track device status.
 #[derive(Debug, Clone)]
 struct DeviceStatus {
-    failed_attempts: u32,
-    last_status: bool,
+    ping_status: Option<bool>,
+    http_status: Option<bool>,
+    bandwidth_usage: Option<f64>,
+    last_update: DateTime<Local>,
+    changed_at: DateTime<Local>,
 }
 
 impl DeviceStatus {
     fn new() -> Self {
-        DeviceStatus {
-            failed_attempts: 0,
-            last_status: true, // Assume initially up
+        let now = Local::now();
+        Self {
+            ping_status: None,
+            http_status: None,
+            bandwidth_usage: None,
+            last_update: now,
+            changed_at: now,
         }
     }
+
+    fn update_ping(&mut self, new_status: bool) -> bool {
+        let changed = self.ping_status != Some(new_status);
+        if changed {
+            self.ping_status = Some(new_status);
+            self.changed_at = Local::now();
+        }
+        self.last_update = Local::now();
+        changed
+    }
 }
 
 // Use the new DeviceStatus struct in the type alias.
@@ -567,82 +584,107 @@ async fn main() {
     let status_map_clone = device_status_map.clone();
 
     tokio::spawn(async move {
+        let mut device_statuses: HashMap<String, DeviceStatus> = HashMap::new();
+        
         loop {
             let devices_to_monitor: Vec<ModelDevice> = {
                 let locked = devices_clone.lock().await;
                 locked.clone()
             };
 
+            let mut status_changed = false;
+
             for dev in devices_to_monitor {
-                let mut updated_dev = dev.clone();
+                let status = device_statuses.entry(dev.ip.clone())
+                    .or_insert_with(DeviceStatus::new);
                 
-                // Always perform ping check regardless of sensor configuration
-                match monitor_ping(&updated_dev.ip).await {
-                    true => {
-                        debug!("Ping successful for {} ({})", updated_dev.name, updated_dev.ip);
-                        updated_dev.ping_status = Some(true);
-                    },
-                    false => {
-                        error!("Ping failed for {} ({})", updated_dev.name, updated_dev.ip);
-                        updated_dev.ping_status = Some(false);
-                    }
-                }
-
-                // HTTP and bandwidth checks only if configured
-                if updated_dev.sensors.contains(&SensorType::Http) || updated_dev.sensors.contains(&SensorType::Https) {
-                    if let Some(ref url) = updated_dev.http_path {
-                        updated_dev.http_status = Some(monitor_http(url).await);
-                        updated_dev.bandwidth_usage = Some(rand::thread_rng().gen_range(10.0..1000.0));
-                    }
+                // First check ping
+                let ping_result = monitor_ping(&dev.ip).await;
+                if status.update_ping(ping_result) {
+                    status_changed = true;
                 }
 
                 // Update device in shared state
                 let mut devices_locked = devices_clone.lock().await;
-                if let Some(existing_dev) = devices_locked.iter_mut().find(|d| d.ip == updated_dev.ip) {
-                    existing_dev.ping_status = updated_dev.ping_status;
-                    existing_dev.http_status = updated_dev.http_status;
-                    existing_dev.bandwidth_usage = updated_dev.bandwidth_usage;
-                }
-            }
-
-            // Write to log file
-            if let Ok(mut file) = OpenOptions::new().append(true).create(true).open(LOG_FILE) {
-                let now: DateTime<Local> = Local::now();
-                let timestamp = now.format("%Y-%m-%d %H:%M:%S").to_string();
-                let today = now.format("%Y-%m-%d").to_string();
-
-                // Write header if needed
-                if last_log_date != today {
-                    if let Err(e) = writeln!(file, "// {}", today) {
-                        error!("Failed to write log header: {}", e);
+                if let Some(device) = devices_locked.iter_mut().find(|d| d.ip == dev.ip) {
+                    device.ping_status = status.ping_status;
+                    
+                    // Check HTTP and bandwidth if configured and ping is successful
+                    if device.ping_status == Some(true) {
+                        if device.sensors.contains(&SensorType::Http) || 
+                           device.sensors.contains(&SensorType::Https) {
+                            if let Some(ref url) = device.http_path {
+                                match monitor_http(url).await {
+                                    true => {
+                                        device.http_status = Some(true);
+                                        // Simulate bandwidth measurement only for successful HTTP connections
+                                        device.bandwidth_usage = Some(rand::thread_rng().gen_range(10.0..1000.0));
+                                        status_changed = true;
+                                    },
+                                    false => {
+                                        device.http_status = Some(false);
+                                        device.bandwidth_usage = None;
+                                        status_changed = true;
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        // If ping fails, mark HTTP as down and clear bandwidth
+                        if device.sensors.contains(&SensorType::Http) || 
+                           device.sensors.contains(&SensorType::Https) {
+                            device.http_status = Some(false);
+                            device.bandwidth_usage = None;
+                            status_changed = true;
+                        }
                     }
-                    last_log_date = today;
                 }
+            }
 
-                // Log each device status
-                let devices_locked = devices_clone.lock().await;
-                for dev in devices_locked.iter() {
-                    let log_entry = format!(
-                        "{} - {} ({}): Ping: {}, HTTP: {}, Bandwidth: {}\n",
-                        timestamp,
-                        dev.name,
-                        dev.ip,
-                        dev.ping_status.map_or("N/A", |s| if s { "OK" } else { "FAIL" }),
-                        dev.http_status.map_or("N/A", |s| if s { "OK" } else { "FAIL" }),
-                        dev.bandwidth_usage.map_or("N/A".to_string(), |b| format!("{:.2} Mbps", b))
-                    );
-
-                    if let Err(e) = file.write_all(log_entry.as_bytes()) {
-                        error!("Failed to write log entry: {}", e);
+            // Write to log file when status changes
+            if status_changed {
+                if let Ok(mut file) = OpenOptions::new().append(true).create(true).open(LOG_FILE) {
+                    let now = Local::now();
+                    let devices_locked = devices_clone.lock().await;
+                    
+                    for dev in devices_locked.iter() {
+                        let status = device_statuses.get(&dev.ip)
+                            .cloned()
+                            .unwrap_or_else(DeviceStatus::new);
+                        
+                        // Format HTTP status and bandwidth based on sensor configuration
+                        let http_status = if dev.sensors.contains(&SensorType::Http) || 
+                                           dev.sensors.contains(&SensorType::Https) {
+                            dev.http_status.map_or("FAIL", |s| if s { "OK" } else { "FAIL" })
+                        } else {
+                            "N/A"
+                        };
+                        
+                        let bandwidth = if (dev.sensors.contains(&SensorType::Http) || 
+                                         dev.sensors.contains(&SensorType::Https)) && 
+                                         dev.http_status == Some(true) {
+                            dev.bandwidth_usage.map_or("N/A".to_string(), |b| format!("{:.2} Mbps", b))
+                        } else {
+                            "N/A".to_string()
+                        };
+                        
+                        let log_entry = format!(
+                            "{} - {} ({}): Ping: {}, HTTP: {}, Bandwidth: {}\n",
+                            now.format("%Y-%m-%d %H:%M:%S"),
+                            dev.name,
+                            dev.ip,
+                            status.ping_status.map_or("N/A", |s| if s { "OK" } else { "FAIL" }),
+                            http_status,
+                            bandwidth
+                        );
+                        
+                        if let Err(e) = file.write_all(log_entry.as_bytes()) {
+                            error!("Failed to write log entry: {}", e);
+                        }
                     }
                 }
-                
-                if let Err(e) = file.flush() {
-                    error!("Failed to flush log file: {}", e);
-                }
             }
 
-            // Wait before next monitoring cycle
             sleep(Duration::from_secs(5)).await;
         }
     });
diff --git a/src/sensors.rs b/src/sensors.rs
@@ -4,70 +4,57 @@ use reqwest;
 use tokio::time::{sleep, Duration};
 
 pub async fn monitor_ping(ip: &str) -> bool {
-    debug!("Attempting to ping {} (10 requests)", ip);
+    debug!("Pinging {}", ip);
     
     let mut success_count = 0;
-    
-    // Send 10 ping requests
-    for attempt in 1..=10 {
-        debug!("Ping attempt {} of 10 for {}", attempt, ip);
-        
+    let attempts = 3; // Try 3 times before deciding status
+
+    for i in 1..=attempts {
         let output = if cfg!(target_os = "macos") || cfg!(target_os = "linux") {
             Command::new("ping")
                 .arg("-c")
                 .arg("1")
-                .arg("-W")
-                .arg("2")
+                .arg("-t")  // Use -t for macOS timeout
+                .arg("2")   // 2 second timeout
                 .arg(ip)
                 .output()
         } else {
             Command::new("ping")
                 .arg("-n")
                 .arg("1")
+                .arg("-w")
+                .arg("2000")
                 .arg(ip)
                 .output()
         };
 
         match output {
             Ok(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout);
-                let stderr = String::from_utf8_lossy(&output.stderr);
-                
-                debug!("Ping stdout: {}", stdout);
-                if !stderr.is_empty() {
-                    debug!("Ping stderr: {}", stderr);
-                }
-
-                let ping_success = if cfg!(target_os = "macos") || cfg!(target_os = "linux") {
-                    output.status.success() && !stdout.contains("100.0% packet loss")
-                } else {
-                    output.status.success() && stdout.contains("bytes=")
-                };
-
-                if ping_success {
+                if output.status.success() {
                     success_count += 1;
+                    debug!("Ping attempt {} successful for {}", i, ip);
+                } else {
+                    debug!("Ping attempt {} failed for {}", i, ip);
                 }
             }
             Err(e) => {
-                error!("Error executing ping command for {}: {}", ip, e);
+                error!("Ping attempt {} error for {}: {}", i, ip, e);
             }
         }
 
-        // Add a small delay between pings to prevent flooding
+        // Short delay between attempts
         sleep(Duration::from_millis(200)).await;
     }
 
-    // Calculate success rate (consider up if 70% or more pings successful)
-    let success_rate = (success_count as f32 / 10.0) * 100.0;
-    let is_up = success_rate >= 70.0;
-
-    if is_up {
-        info!("Device {} is UP ({}% success rate)", ip, success_rate);
+    // Consider it up if more than 50% attempts succeeded
+    let status = success_count > attempts / 2;
+    if status {
+        info!("Ping UP for {} ({}/{} successful)", ip, success_count, attempts);
     } else {
-        error!("Device {} is DOWN ({}% success rate)", ip, success_rate);
+        error!("Ping DOWN for {} ({}/{} failed)", ip, attempts - success_count, attempts);
     }
-
-    is_up
+    
+    status
 }
 
 pub async fn monitor_http(url: &str) -> bool {
diff --git a/static/script.js b/static/script.js
