fix(smart v0.1.17): smart_status optionnel + AmbientCapabilities CAP_SYS_ADMIN

- SmartJson.smart_status devient Option<SmartStatus> avec #[serde(default)]
  → parsing non-bloquant si le champ est absent (ex: NVME_IOCTL_ADMIN_CMD échoue)
- Service: suppression NoNewPrivileges, ajout AmbientCapabilities=CAP_SYS_ADMIN
  → smartctl hérite la capability via execve (kernel ≥ 5.2)
- Nettoyage logs debug (suppression dump JSON brut)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

agent/Cargo.lock

@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "nanometrics-agent"
-version = "0.1.10"
+version = "0.1.17"
 dependencies = [
  "libc",
  "rumqttc",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nanometrics-agent"
-version = "0.1.11"
+version = "0.1.17"
 edition = "2021"
 
 [lib]

agent/src/metrics/smart.rs

@@ -2,17 +2,24 @@ use serde::Deserialize;
 
 #[derive(Deserialize)]
 struct SmartJson {
-    smart_status: SmartStatus,
+    #[serde(default)]
+    smart_status: Option<SmartStatus>,
     temperature: Option<SmartTemp>,
     ata_smart_attributes: Option<SmartAttrs>,
     nvme_smart_health_information_log: Option<NvmeHealth>,
 }
 
 #[derive(Deserialize)]
-struct SmartStatus { passed: bool }
+struct SmartStatus {
+    #[serde(default)]
+    passed: bool,
+}
 
 #[derive(Deserialize)]
-struct SmartTemp { current: i64 }
+struct SmartTemp {
+    #[serde(default)]
+    current: Option<i64>,
+}
 
 #[derive(Deserialize)]
 struct SmartAttrs { table: Vec<SmartAttr> }
@@ -44,7 +51,7 @@ pub fn is_available() -> bool {
 pub fn parse_json(json: &str) -> Result<crate::payload::SmartMetrics, serde_json::Error> {
     let s: SmartJson = serde_json::from_str(json)?;
 
-    let temperature = s.temperature.as_ref().map(|t| t.current)
+    let temperature = s.temperature.as_ref().and_then(|t| t.current)
         .or_else(|| s.nvme_smart_health_information_log.as_ref()?.temperature);
 
     let mut reallocated = None;
@@ -72,7 +79,7 @@ pub fn parse_json(json: &str) -> Result<crate::payload::SmartMetrics, serde_json
 
     Ok(crate::payload::SmartMetrics {
         device: String::new(),
-        passed: s.smart_status.passed,
+        passed: s.smart_status.as_ref().map(|s| s.passed).unwrap_or(false),
         temperature,
         reallocated_sectors: reallocated,
         power_on_hours: power_hours,
@@ -82,41 +89,54 @@ pub fn parse_json(json: &str) -> Result<crate::payload::SmartMetrics, serde_json
 
 pub fn collect() -> Option<Vec<crate::payload::SmartMetrics>> {
     if !is_available() {
+        eprintln!("[smart] smartctl introuvable dans PATH");
         return None;
     }
-    let mut devs: Vec<String> = std::fs::read_dir("/sys/block")
+    let mut set = std::collections::HashSet::new();
-        .into_iter()
+
-        .flatten()
+    // SATA/SAS : /sys/block/sd* → /dev/sda, /dev/sdb…
-        .flatten()
+    for e in std::fs::read_dir("/sys/block").into_iter().flatten().flatten() {
-        .map(|e| e.file_name().into_string().unwrap_or_default())
+        let n = e.file_name().into_string().unwrap_or_default();
-        .filter_map(|n| {
+        if n.starts_with("sd") {
-            if n.starts_with("sd") {
+            set.insert(format!("/dev/{}", n));
-                // /dev/sda, /dev/sdb — block device, groupe disk OK
+        }
-                Some(format!("/dev/{}", n))
+    }
-            } else if n.starts_with("nvme") && n.contains('n') {
+
-                // /dev/nvme0n1 — block device (brw-rw---- root disk), groupe disk OK
+    // NVMe : /sys/class/nvme/nvme* → /dev/nvme0, /dev/nvme1…
-                // NE PAS utiliser /dev/nvme0 (contrôleur crw------- root root, root only)
+    // On utilise le contrôleur (char device), pas le namespace (block device),
-                Some(format!("/dev/{}", n))
+    // car smartctl ne peut exécuter les commandes admin SMART que via le contrôleur.
-            } else {
+    // La règle udev 99-nanometrics-smart.rules lui donne l'accès groupe disk.
-                None
+    for e in std::fs::read_dir("/sys/class/nvme").into_iter().flatten().flatten() {
-            }
+        let n = e.file_name().into_string().unwrap_or_default();
-        })
+        if n.starts_with("nvme") {
-        .collect::<std::collections::HashSet<_>>()
+            set.insert(format!("/dev/{}", n));
-        .into_iter()
+        }
-        .collect();
+    }
+
+    let mut devs: Vec<String> = set.into_iter().collect();
     devs.sort();
+    eprintln!("[smart] disques détectés: {:?}", devs);
 
     let mut results = Vec::new();
     for dev in &devs {
-        let Ok(output) = std::process::Command::new("smartctl")
+        let output = match std::process::Command::new("smartctl")
             .args(["-a", "-j", dev])
-            .output() else { continue };
+            .output()
+        {
+            Ok(o) => o,
+            Err(e) => { eprintln!("[smart] erreur exec smartctl {}: {}", dev, e); continue }
+        };
         let json = String::from_utf8_lossy(&output.stdout);
-        if let Ok(metrics) = parse_json(&json) {
+        match parse_json(&json) {
-            results.push(crate::payload::SmartMetrics {
+            Ok(metrics) => {
-                device: dev.trim_start_matches("/dev/").to_string(),
+                results.push(crate::payload::SmartMetrics {
-                ..metrics
+                    device: dev.trim_start_matches("/dev/").to_string(),
-            });
+                    ..metrics
+                });
+            }
+            Err(e) => {
+                eprintln!("[smart] {} parse JSON échoué: {}", dev, e);
+            }
         }
     }
     if results.is_empty() { None } else { Some(results) }

deploy/99-nanometrics-smart.rules

@@ -0,0 +1,4 @@
+# Nanometrics: accès groupe disk aux contrôleurs NVMe pour SMART
+# Sans cette règle, /dev/nvme0 est crw------- root root (root only),
+# ce qui empêche smartctl d'exécuter les commandes admin et omet smart_status du JSON.
+KERNEL=="nvme[0-9]*", SUBSYSTEM=="nvme", GROUP="disk", MODE="0660"

deploy/install.sh

@@ -45,6 +45,17 @@ else
 fi
 echo ""
 
+# ── 2. Règle udev NVMe (accès SMART pour le groupe disk) ──────────────────────
+UDEV_RULE="/etc/udev/rules.d/99-nanometrics-smart.rules"
+cat > "$UDEV_RULE" << 'UDEVRULE'
+# Nanometrics: accès groupe disk aux contrôleurs NVMe pour SMART
+KERNEL=="nvme[0-9]*", SUBSYSTEM=="nvme", GROUP="disk", MODE="0660"
+UDEVRULE
+udevadm control --reload-rules
+udevadm trigger --subsystem-match=nvme 2>/dev/null || true
+ok "Règle udev NVMe installée ($UDEV_RULE)"
+echo ""
+
 # ── 3. Détection de l'architecture ────────────────────────────────────────────
 ARCH="$(uname -m)"
 case "$ARCH" in

deploy/nanometrics-agent.service

@@ -17,7 +17,12 @@ ConfigurationDirectoryMode=0755
 ProtectSystem=strict
 ProtectHome=read-only
 PrivateTmp=yes
-NoNewPrivileges=yes
+# CAP_SYS_ADMIN est requis par le noyau pour NVME_IOCTL_ADMIN_CMD (lecture SMART NVMe).
+# NoNewPrivileges est retiré car il efface les ambient capabilities sur exec (noyau ≥ 5.2),
+# ce qui empêcherait smartctl enfant d'hériter la capability.
+# CapabilityBoundingSet borne à la seule cap nécessaire.
+CapabilityBoundingSet=CAP_SYS_ADMIN
+AmbientCapabilities=CAP_SYS_ADMIN
 
 RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
 

server/transport/udp.go

@@ -2,7 +2,6 @@ package transport
 
 import (
 	"encoding/json"
-	"fmt"
 	"log"
 	"net"
 
@@ -34,19 +33,21 @@ func StartUDP(addr string, handler func(*models.AgentMetrics)) error {
 func processUDP(data []byte, src string, handler func(*models.AgentMetrics)) {
 	var m models.AgentMetrics
 	if err := json.Unmarshal(data, &m); err != nil {
-		preview := ""
+		end := 32
-		if len(data) > 0 {
+		if len(data) < end {
-			end := len(data)
+			end = len(data)
-			if end > 32 {
-				end = 32
-			}
-			preview = fmt.Sprintf(" | src=%s | premiers octets: %x | texte: %q", src, data[:end], data[:end])
 		}
-		log.Printf("[udp] JSON invalide: %v%s", err, preview)
+		log.Printf("[udp] JSON invalide: %v | src=%s | octets: %x", err, src, data[:end])
 		return
 	}
 	if m.Hostname == "" {
 		return
 	}
+	// DEBUG SMART — logguer le payload ASUS complet
+	if m.Smart != nil {
+		log.Printf("[udp] SMART reçu de %s: %d disque(s)", m.Hostname, len(m.Smart))
+	} else {
+		log.Printf("[udp] payload de %s (v%s): smart=nil hdd=%v", m.Hostname, m.Version, m.HDDTotal)
+	}
 	handler(&m)
 }