Create dedicated network collector with physical/virtual interface grouping

Move network collection from NixOS collector to dedicated NetworkCollector. Add link status detection for physical interfaces (up/down). Group interfaces by physical/virtual, show status icons for physical NICs only. Down interfaces show as Inactive instead of Critical.

Version bump to 0.1.165

Cargo.lock

@@ -279,7 +279,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.164"
+version = "0.1.165"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.164"
+version = "0.1.165"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -324,7 +324,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.164"
+version = "0.1.165"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.164"
+version = "0.1.165"
 edition = "2021"
 
 [dependencies]

agent/src/agent.rs

@@ -12,6 +12,7 @@ use crate::collectors::{
     cpu::CpuCollector,
     disk::DiskCollector,
     memory::MemoryCollector,
+    network::NetworkCollector,
     nixos::NixOSCollector,
     systemd::SystemdCollector,
 };
@@ -77,7 +78,11 @@ impl Agent {
         if config.collectors.backup.enabled {
             collectors.push(Box::new(BackupCollector::new()));
         }
-        
+
+        if config.collectors.network.enabled {
+            collectors.push(Box::new(NetworkCollector::new(config.collectors.network.clone())));
+        }
+
         if config.collectors.nixos.enabled {
             collectors.push(Box::new(NixOSCollector::new(config.collectors.nixos.clone())));
         }

agent/src/collectors/mod.rs

@@ -7,6 +7,7 @@ pub mod cpu;
 pub mod disk;
 pub mod error;
 pub mod memory;
+pub mod network;
 pub mod nixos;
 pub mod systemd;
 

agent/src/collectors/network.rs

@@ -0,0 +1,137 @@
+use async_trait::async_trait;
+use cm_dashboard_shared::{AgentData, NetworkInterfaceData, Status};
+use std::process::Command;
+use tracing::debug;
+
+use super::{Collector, CollectorError};
+use crate::config::NetworkConfig;
+
+/// Network interface collector with physical/virtual classification and link status
+pub struct NetworkCollector {
+    _config: NetworkConfig,
+}
+
+impl NetworkCollector {
+    pub fn new(config: NetworkConfig) -> Self {
+        Self { _config: config }
+    }
+
+    /// Check if interface is physical (not virtual)
+    fn is_physical_interface(name: &str) -> bool {
+        // Physical interface patterns
+        matches!(
+            &name[..],
+            s if s.starts_with("eth")
+                || s.starts_with("ens")
+                || s.starts_with("enp")
+                || s.starts_with("wlan")
+                || s.starts_with("wlp")
+                || s.starts_with("eno")
+                || s.starts_with("enx")
+        )
+    }
+
+    /// Get link status for an interface
+    fn get_link_status(interface: &str) -> Status {
+        let operstate_path = format!("/sys/class/net/{}/operstate", interface);
+
+        match std::fs::read_to_string(&operstate_path) {
+            Ok(state) => {
+                let state = state.trim();
+                match state {
+                    "up" => Status::Ok,
+                    "down" => Status::Inactive,
+                    "unknown" => Status::Warning,
+                    _ => Status::Unknown,
+                }
+            }
+            Err(_) => Status::Unknown,
+        }
+    }
+
+    /// Collect network interfaces using ip command
+    async fn collect_interfaces(&self) -> Vec<NetworkInterfaceData> {
+        let mut interfaces = Vec::new();
+
+        match Command::new("ip").args(["-j", "addr"]).output() {
+            Ok(output) if output.status.success() => {
+                let json_str = String::from_utf8_lossy(&output.stdout);
+
+                if let Ok(json_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
+                    if let Some(ifaces) = json_data.as_array() {
+                        for iface in ifaces {
+                            let name = iface["ifname"].as_str().unwrap_or("").to_string();
+
+                            // Skip loopback and empty names
+                            if name.is_empty() || name == "lo" {
+                                continue;
+                            }
+
+                            let mut ipv4_addresses = Vec::new();
+                            let mut ipv6_addresses = Vec::new();
+
+                            // Extract IP addresses
+                            if let Some(addr_info) = iface["addr_info"].as_array() {
+                                for addr in addr_info {
+                                    if let Some(family) = addr["family"].as_str() {
+                                        if let Some(local) = addr["local"].as_str() {
+                                            match family {
+                                                "inet" => ipv4_addresses.push(local.to_string()),
+                                                "inet6" => {
+                                                    // Skip link-local IPv6 addresses (fe80::)
+                                                    if !local.starts_with("fe80:") {
+                                                        ipv6_addresses.push(local.to_string());
+                                                    }
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Determine if physical and get status
+                            let is_physical = Self::is_physical_interface(&name);
+                            let link_status = if is_physical {
+                                Self::get_link_status(&name)
+                            } else {
+                                Status::Unknown  // Virtual interfaces don't have meaningful link status
+                            };
+
+                            interfaces.push(NetworkInterfaceData {
+                                name,
+                                ipv4_addresses,
+                                ipv6_addresses,
+                                is_physical,
+                                link_status,
+                                parent_interface: None,  // TODO: Implement virtual interface parent detection
+                            });
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                debug!("Failed to execute ip command: {}", e);
+            }
+            Ok(output) => {
+                debug!("ip command failed with status: {}", output.status);
+            }
+        }
+
+        interfaces
+    }
+}
+
+#[async_trait]
+impl Collector for NetworkCollector {
+    async fn collect_structured(&self, agent_data: &mut AgentData) -> Result<(), CollectorError> {
+        debug!("Collecting network interface data");
+
+        // Collect all network interfaces
+        let interfaces = self.collect_interfaces().await;
+
+        agent_data.system.network.interfaces = interfaces;
+
+        Ok(())
+    }
+}

agent/src/collectors/nixos.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use cm_dashboard_shared::{AgentData, NetworkInterfaceData};
+use cm_dashboard_shared::AgentData;
 use std::fs;
 use std::process::Command;
 use tracing::debug;
@@ -32,9 +32,6 @@ impl NixOSCollector {
         // Set NixOS build/generation information
         agent_data.build_version = self.get_nixos_generation().await;
 
-        // Collect network interfaces
-        agent_data.system.network.interfaces = self.get_network_interfaces().await;
-
         // Set current timestamp
         agent_data.timestamp = chrono::Utc::now().timestamp() as u64;
 
@@ -104,72 +101,6 @@ impl NixOSCollector {
             }
         }
     }
-
-    /// Get network interfaces and their IP addresses
-    async fn get_network_interfaces(&self) -> Vec<NetworkInterfaceData> {
-        let mut interfaces = Vec::new();
-
-        // Use ip command with JSON output for easier parsing
-        match Command::new("ip").args(["-j", "addr"]).output() {
-            Ok(output) if output.status.success() => {
-                let json_str = String::from_utf8_lossy(&output.stdout);
-
-                // Parse JSON output
-                if let Ok(json_data) = serde_json::from_str::<serde_json::Value>(&json_str) {
-                    if let Some(ifaces) = json_data.as_array() {
-                        for iface in ifaces {
-                            let name = iface["ifname"].as_str().unwrap_or("").to_string();
-
-                            // Skip loopback and empty names
-                            if name.is_empty() || name == "lo" {
-                                continue;
-                            }
-
-                            let mut ipv4_addresses = Vec::new();
-                            let mut ipv6_addresses = Vec::new();
-
-                            // Extract IP addresses
-                            if let Some(addr_info) = iface["addr_info"].as_array() {
-                                for addr in addr_info {
-                                    if let Some(family) = addr["family"].as_str() {
-                                        if let Some(local) = addr["local"].as_str() {
-                                            match family {
-                                                "inet" => ipv4_addresses.push(local.to_string()),
-                                                "inet6" => {
-                                                    // Skip link-local IPv6 addresses (fe80::)
-                                                    if !local.starts_with("fe80:") {
-                                                        ipv6_addresses.push(local.to_string());
-                                                    }
-                                                }
-                                                _ => {}
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-
-                            // Only add interfaces that have at least one IP address
-                            if !ipv4_addresses.is_empty() || !ipv6_addresses.is_empty() {
-                                interfaces.push(NetworkInterfaceData {
-                                    name,
-                                    ipv4_addresses,
-                                    ipv6_addresses,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                debug!("Failed to execute ip command: {}", e);
-            }
-            Ok(output) => {
-                debug!("ip command failed with status: {}", output.status);
-            }
-        }
-
-        interfaces
-    }
 }
 
 #[async_trait]

dashboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.164"
+version = "0.1.165"
 edition = "2021"
 
 [dependencies]

dashboard/src/ui/widgets/system.rs

@@ -616,7 +616,7 @@ impl SystemWidget {
         result.join(", ")
     }
 
-    /// Render network section for display
+    /// Render network section for display with physical/virtual grouping
     fn render_network(&self) -> Vec<Line<'_>> {
         let mut lines = Vec::new();
 
@@ -624,11 +624,16 @@ impl SystemWidget {
             return lines;
         }
 
-        for (i, interface) in self.network_interfaces.iter().enumerate() {
+        // Separate physical and virtual interfaces
-            let is_last = i == self.network_interfaces.len() - 1;
+        let physical: Vec<_> = self.network_interfaces.iter().filter(|i| i.is_physical).collect();
+        let virtual_interfaces: Vec<_> = self.network_interfaces.iter().filter(|i| !i.is_physical).collect();
+
+        // Render physical interfaces first
+        for (i, interface) in physical.iter().enumerate() {
+            let is_last = i == physical.len() - 1 && virtual_interfaces.is_empty();
             let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
 
-            // Show interface name
+            // Show interface name with IPs
             let mut interface_text = format!("{}: ", interface.name);
 
             // Add compressed IPv4 addresses
@@ -644,6 +649,39 @@ impl SystemWidget {
                 interface_text.push_str(&interface.ipv6_addresses.join(", "));
             }
 
+            // Physical interfaces show status icon
+            let mut spans = vec![
+                Span::styled(tree_symbol, Typography::tree()),
+            ];
+            spans.extend(StatusIcons::create_status_spans(
+                interface.link_status.clone(),
+                &interface_text
+            ));
+            lines.push(Line::from(spans));
+        }
+
+        // Render virtual interfaces
+        for (i, interface) in virtual_interfaces.iter().enumerate() {
+            let is_last = i == virtual_interfaces.len() - 1;
+            let tree_symbol = if is_last { "  └─ " } else { "  ├─ " };
+
+            // Show interface name with IPs
+            let mut interface_text = format!("{}: ", interface.name);
+
+            // Add compressed IPv4 addresses
+            if !interface.ipv4_addresses.is_empty() {
+                interface_text.push_str(&Self::compress_ipv4_addresses(&interface.ipv4_addresses));
+            }
+
+            // Add IPv6 addresses (no compression for now)
+            if !interface.ipv6_addresses.is_empty() {
+                if !interface.ipv4_addresses.is_empty() {
+                    interface_text.push_str(", ");
+                }
+                interface_text.push_str(&interface.ipv6_addresses.join(", "));
+            }
+
+            // Virtual interfaces don't show status icon
             lines.push(Line::from(vec![
                 Span::styled(tree_symbol, Typography::tree()),
                 Span::styled(interface_text, Typography::secondary()),

shared/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.164"
+version = "0.1.165"
 edition = "2021"
 
 [dependencies]

shared/src/agent_data.rs

@@ -34,6 +34,9 @@ pub struct NetworkInterfaceData {
     pub name: String,
     pub ipv4_addresses: Vec<String>,
     pub ipv6_addresses: Vec<String>,
+    pub is_physical: bool,
+    pub link_status: Status,
+    pub parent_interface: Option<String>,
 }
 
 /// CPU monitoring data