USB-AIO für automatische Geräteprüfung

gui/src/diagnostics.rs

@@ -0,0 +1,483 @@
+//! Read-only or temporary hardware diagnostics. Never mark a technician check PASS automatically.
+use std::{
+    fs,
+    path::Path,
+    process::{Command, Stdio},
+    thread,
+    time::{Duration, Instant},
+};
+
+fn available(tool: &str) -> bool {
+    Command::new("sh")
+        .args(["-c", "command -v \"$1\" >/dev/null 2>&1", "sh", tool])
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
+fn exec(tool: &str, args: &[&str]) -> Result<String, String> {
+    let out = Command::new("timeout")
+        .args(["--kill-after=3s", "150s", tool])
+        .args(args)
+        .output()
+        .map_err(|e| format!("{tool}: {e}"))?;
+    let log = format!(
+        "{}\n{}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    if out.status.success() {
+        Ok(log)
+    } else {
+        Err(format!("{tool} ({})\n{log}", out.status))
+    }
+}
+fn temps() -> Vec<(String, f64)> {
+    let mut values = Vec::new();
+    let Ok(chips) = fs::read_dir("/sys/class/hwmon") else {
+        return values;
+    };
+    for entry in chips.flatten() {
+        let base = entry.path();
+        let chip = fs::read_to_string(base.join("name"))
+            .unwrap_or_default()
+            .trim()
+            .to_owned();
+        let Ok(files) = fs::read_dir(&base) else {
+            continue;
+        };
+        for file in files.flatten() {
+            let name = file.file_name().to_string_lossy().to_string();
+            if !name.starts_with("temp") || !name.ends_with("_input") {
+                continue;
+            }
+            let Ok(raw) = fs::read_to_string(file.path()) else {
+                continue;
+            };
+            let Ok(milli) = raw.trim().parse::<f64>() else {
+                continue;
+            };
+            let c = milli / 1000.0;
+            if !(-20.0..=150.0).contains(&c) {
+                continue;
+            }
+            values.push((format!("{chip}:{name}"), c));
+        }
+    }
+    values
+}
+fn thermal(settings: &crate::workflow::Settings) -> (bool, String) {
+    if !available("stress-ng") {
+        return (false, "UNAVAILABLE: stress-ng fehlt im Live-System".into());
+    }
+    let baseline = temps();
+    let start = Instant::now();
+    let mut child = match Command::new("stress-ng")
+        .args([
+            "--cpu",
+            "0",
+            "--timeout",
+            &format!("{}s", settings.stress_seconds),
+            "--metrics-brief",
+        ])
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+    {
+        Ok(c) => c,
+        Err(e) => return (false, format!("stress-ng konnte nicht starten: {e}")),
+    };
+    let mut samples = 0usize;
+    let mut peak: Option<f64> = None;
+    loop {
+        for (_, t) in temps() {
+            peak = Some(peak.map_or(t, |p| p.max(t)));
+            samples += 1;
+        }
+        match child.try_wait() {
+            Ok(Some(_)) => break,
+            Ok(None) => {}
+            Err(e) => return (false, format!("Prozessprüfung fehlgeschlagen: {e}")),
+        }
+        if start.elapsed() > Duration::from_secs(settings.stress_seconds + 15) {
+            let _ = child.kill();
+            break;
+        }
+        thread::sleep(Duration::from_secs(2));
+    }
+    let output = match child.wait_with_output() {
+        Ok(o) => o,
+        Err(e) => return (false, format!("Ausgabe fehlt: {e}")),
+    };
+    let mut log = format!(
+        "Dauer: {:.0}s\nSensorwerte zu Beginn: {:?}\nMesspunkte: {}\nMaximal beobachtet: {}\n{}",
+        start.elapsed().as_secs_f64(),
+        baseline,
+        samples,
+        peak.map(|p| format!("{p:.1} °C"))
+            .unwrap_or("UNAVAILABLE".into()),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    if let Some(p) = peak {
+        log.push_str(&format!("\nPEAK_TEMPERATURE_C={p}"));
+    }
+    if let Some(p) = peak {
+        if p >= settings.max_temperature_c {
+            log.push_str(
+                "\nWARNUNG: Werkstatt-Temperaturgrenze überschritten; manuelle Prüfung nötig.",
+            );
+        }
+    }
+    if samples == 0 {
+        log.push_str("\nWARNUNG: Kein Temperatursensor auslesbar.");
+    }
+    (
+        output.status.success()
+            && samples > 0
+            && peak
+                .map(|p| p < settings.max_temperature_c)
+                .unwrap_or(false)
+            && start.elapsed() >= Duration::from_secs(settings.stress_seconds.saturating_sub(2)),
+        log,
+    )
+}
+fn stability(settings: &crate::workflow::Settings) -> (bool, String) {
+    if !available("stress-ng") {
+        return (false, "UNAVAILABLE: stress-ng fehlt".into());
+    }
+    let mem_kib = fs::read_to_string("/proc/meminfo")
+        .ok()
+        .and_then(|s| {
+            s.lines()
+                .find(|l| l.starts_with("MemAvailable:"))
+                .and_then(|l| l.split_whitespace().nth(1))
+                .and_then(|v| v.parse::<u64>().ok())
+        })
+        .unwrap_or(0);
+    // Conservatively cap test allocation; never allocate all free RAM in a live USB GUI.
+    if mem_kib < 256 * 1024 {
+        return (
+            false,
+            "Insufficient available RAM for a bounded stress test / Zu wenig freier RAM".into(),
+        );
+    }
+    let ram_mib = ((mem_kib / 1024) / 4).clamp(128, 2048);
+    let mut child = match Command::new("stress-ng")
+        .args([
+            "--cpu",
+            "0",
+            "--vm",
+            "1",
+            "--vm-bytes",
+            &format!("{ram_mib}M"),
+            "--verify",
+            "--timeout",
+            &format!("{}s", settings.stress_seconds),
+            "--metrics-brief",
+        ])
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+    {
+        Ok(c) => c,
+        Err(e) => return (false, format!("Start fehlgeschlagen: {e}")),
+    };
+    let start = Instant::now();
+    let mut peak: Option<f64> = None;
+    loop {
+        for (_, v) in temps() {
+            peak = Some(peak.map_or(v, |p| p.max(v)));
+        }
+        match child.try_wait() {
+            Ok(Some(_)) => break,
+            Ok(None) => {}
+            Err(e) => return (false, format!("Prozessfehler: {e}")),
+        }
+        if start.elapsed() > Duration::from_secs(settings.stress_seconds + 15) {
+            let _ = child.kill();
+            break;
+        }
+        thread::sleep(Duration::from_secs(2));
+    }
+    match child.wait_with_output(){Ok(o)=>(o.status.success() && peak.map(|p|p<settings.max_temperature_c).unwrap_or(true) && start.elapsed()>=Duration::from_secs(settings.stress_seconds.saturating_sub(2)),format!("CPU-/RAM-Test {:.0}s, RAM-Verbrauch ca. {} MiB, Temp-Spitze {}\nPEAK_TEMPERATURE_C={}\n{}",start.elapsed().as_secs_f64(),ram_mib,peak.map(|p|format!("{p:.1}°C")).unwrap_or("UNKNOWN".into()),peak.map(|p|p.to_string()).unwrap_or_default(),String::from_utf8_lossy(&o.stderr))),Err(e)=>(false,format!("Ausgabe fehlgeschlagen: {e}"))}
+}
+fn microphone(settings: &crate::workflow::Settings) -> (bool, String) {
+    if !available("arecord") || !available("aplay") {
+        return (
+            false,
+            "UNAVAILABLE: alsa-utils / arecord / aplay fehlen".into(),
+        );
+    }
+    let path = format!(
+        "/tmp/csr-audio-{}-{}.wav",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos()
+    );
+    let record = exec(
+        "arecord",
+        &[
+            "-q",
+            "-d",
+            &settings.recording_seconds.to_string(),
+            "-f",
+            "S16_LE",
+            "-r",
+            "16000",
+            "-c",
+            "1",
+            &path,
+        ],
+    );
+    let result = match record {
+        Err(e) => (false, format!("Mikrofonaufnahme fehlgeschlagen:\n{e}")),
+        Ok(_) => match exec("aplay", &["-q", &path]) {
+            Ok(_) => (
+                true,
+                format!(
+                    "{} Sekunden aufgenommen und abgespielt. Bitte Tonqualität bestätigen.",
+                    settings.recording_seconds
+                ),
+            ),
+            Err(e) => (false, format!("Wiedergabe fehlgeschlagen: {e}")),
+        },
+    };
+    if Path::new(&path).exists() {
+        let _ = fs::remove_file(&path);
+    }
+    result
+}
+fn camera(settings: &crate::workflow::Settings) -> (bool, String) {
+    if !Path::new("/dev/video0").exists() {
+        return (false, "UNAVAILABLE: keine Kamera unter /dev/video0".into());
+    }
+    if !available("ffplay") {
+        return (false, "UNAVAILABLE: ffplay fehlt".into());
+    }
+    let out = exec(
+        "timeout",
+        &[
+            &format!("{}s", settings.camera_seconds),
+            "ffplay",
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-f",
+            "video4linux2",
+            "-i",
+            "/dev/video0",
+        ],
+    );
+    match out {
+        Ok(s) => (
+            true,
+            format!("Vorschau beendet. Sichtprüfung erforderlich.\n{s}"),
+        ),
+        Err(s) => {
+            // timeout exits 124 after a normal 25s bounded preview.
+            if s.contains("124") {
+                (
+                    true,
+                    format!(
+                        "{} Sekunden Vorschau beendet. Sichtprüfung erforderlich.",
+                        settings.camera_seconds
+                    ),
+                )
+            } else {
+                (false, s)
+            }
+        }
+    }
+}
+fn run_legacy(tool: &str, settings: &crate::workflow::Settings) -> (bool, String) {
+    match tool {
+        "audio" => match exec("speaker-test", &["-c", "2", "-t", "wav", "-l", "1"]) {
+            Ok(s) => (
+                true,
+                format!("Linker/rechter Testkanal ausgegeben. Bitte Hörtest bestätigen.\n{s}"),
+            ),
+            Err(s) => (false, s),
+        },
+        "microphone" => microphone(settings),
+        "camera" => camera(settings),
+        "thermals" => thermal(settings),
+        "stability" => stability(settings),
+        "wifi" => {
+            let service = exec("nmcli", &["general", "status"]);
+            match service {
+                Err(s) => (false, format!("NetworkManager nicht bereit: {s}")),
+                Ok(status) => {
+                    let dev = exec("nmcli", &["device", "status"]).unwrap_or_else(|e| e);
+                    let scan = exec(
+                        "nmcli",
+                        &["-f", "IN-USE,SSID,SIGNAL", "device", "wifi", "list"],
+                    )
+                    .unwrap_or_else(|e| e);
+                    (true,format!("Status:\n{status}\nGeräte:\n{dev}\nNetze:\n{scan}\nLAN trennen und WLAN-Verbindung aktiv testen; Sichtbarkeit ist noch kein PASS."))
+                }
+            }
+        }
+        "video" => (
+            true,
+            "Kameratest bitte über Kameravorschau durchführen.".into(),
+        ),
+        _ => (false, "Unbekannter Diagnosetest".into()),
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Diagnostic {
+    pub outcome: crate::workflow::Outcome,
+    pub text: String,
+}
+pub fn run(tool: &str, settings: &crate::workflow::Settings) -> Diagnostic {
+    use crate::workflow::Outcome;
+    let required: &[&str] = match tool {
+        "audio" => &["speaker-test"],
+        "microphone" => &["arecord", "aplay"],
+        "webcam" => &["ffplay", "timeout"],
+        "thermals" | "stability" => &["stress-ng"],
+        "usb_ports" => &["lsusb"],
+        _ => &[],
+    };
+    if !available("timeout") {
+        return Diagnostic {
+            outcome: Outcome::Unavailable,
+            text: "timeout tool missing / fehlt".into(),
+        };
+    }
+    let missing: Vec<_> = required.iter().filter(|p| !available(p)).copied().collect();
+    if !missing.is_empty() {
+        return Diagnostic {
+            outcome: Outcome::Unavailable,
+            text: format!("Missing tools / Fehlende Werkzeuge: {}", missing.join(", ")),
+        };
+    }
+    if let Some(disk) = tool.strip_prefix("disk:") {
+        if !disk
+            .bytes()
+            .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
+        {
+            return Diagnostic {
+                outcome: Outcome::SetupProblem,
+                text: "Invalid disk name".into(),
+            };
+        }
+        if !available("smartctl") {
+            return Diagnostic {
+                outcome: Outcome::Unavailable,
+                text: "smartctl missing / fehlt".into(),
+            };
+        }
+        return match Command::new("timeout")
+            .args(["--kill-after=3s", "30s", "smartctl"])
+            .args(["-j", "-H", "-A", &format!("/dev/{disk}")])
+            .output()
+        {
+            Ok(o) => {
+                let v: serde_json::Value = serde_json::from_slice(&o.stdout).unwrap_or_default();
+                let outcome = match v
+                    .pointer("/smart_status/passed")
+                    .and_then(serde_json::Value::as_bool)
+                {
+                    Some(false) => Outcome::HardwareFailure,
+                    Some(true) => Outcome::NeedsReview,
+                    None => Outcome::SetupProblem,
+                };
+                Diagnostic {
+                    outcome,
+                    text: format!(
+                        "{}\n{}",
+                        String::from_utf8_lossy(&o.stdout),
+                        String::from_utf8_lossy(&o.stderr)
+                    ),
+                }
+            }
+            Err(e) => Diagnostic {
+                outcome: Outcome::SetupProblem,
+                text: e.to_string(),
+            },
+        };
+    }
+    if tool == "charging" {
+        let mut lines = Vec::new();
+        if let Ok(entries) = fs::read_dir("/sys/class/power_supply") {
+            for e in entries.flatten() {
+                let p = e.path();
+                let read = |k: &str| {
+                    fs::read_to_string(p.join(k))
+                        .unwrap_or_default()
+                        .trim()
+                        .to_owned()
+                };
+                lines.push(format!("{}: type={} status={} charge={}% online={} energy_full={} energy_full_design={} charge_full={} charge_full_design={}",e.file_name().to_string_lossy(),read("type"),read("status"),read("capacity"),read("online"),read("energy_full"),read("energy_full_design"),read("charge_full"),read("charge_full_design")));
+            }
+        }
+        return Diagnostic {
+            outcome: if lines.is_empty() {
+                Outcome::Unavailable
+            } else {
+                Outcome::NeedsReview
+            },
+            text: if lines.is_empty() {
+                "No power supply data / Keine Akkudaten".into()
+            } else {
+                lines.join("\n")
+            },
+        };
+    }
+    if tool == "usb_ports" {
+        return match exec("lsusb", &[]) {
+            Ok(text) => Diagnostic {
+                outcome: Outcome::NeedsReview,
+                text,
+            },
+            Err(text) => Diagnostic {
+                outcome: Outcome::SetupProblem,
+                text,
+            },
+        };
+    }
+    let (ok, text) = run_legacy(if tool == "webcam" { "camera" } else { tool }, settings);
+    // Command failures are setup problems, never proof of a broken component.
+    Diagnostic {
+        outcome: if text.starts_with("UNAVAILABLE")
+            || (tool == "thermals" && text.contains("Messpunkte: 0"))
+        {
+            Outcome::Unavailable
+        } else if peak_temperature(&text)
+            .map(|v| v >= settings.max_temperature_c)
+            .unwrap_or(false)
+        {
+            Outcome::NeedsReview
+        } else if ok {
+            Outcome::NeedsReview
+        } else {
+            Outcome::SetupProblem
+        },
+        text,
+    }
+}
+
+pub fn peak_temperature(text: &str) -> Option<f64> {
+    text.lines().find_map(|l| {
+        l.strip_prefix("PEAK_TEMPERATURE_C=")
+            .and_then(|s| s.parse::<f64>().ok())
+            .filter(|v| v.is_finite())
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn peak_is_machine_readable_and_finite() {
+        assert_eq!(
+            peak_temperature("log\nPEAK_TEMPERATURE_C=94.5\nend"),
+            Some(94.5)
+        );
+        assert_eq!(peak_temperature("PEAK_TEMPERATURE_C=NaN"), None);
+    }
+}