-
Run All Tests
-
-
Cycles
-
▶ Run All
+
Validate Profile
+
+
+
Cycles
+
Diag level Level 1 — Quick Level 2 — Standard Level 3 — Extended Level 4 — Full
+
+
+
Runs validate modules sequentially with the selected cycle count. NVIDIA dcgmi diag uses the selected diag level from this profile.
+
Validate one by one
+
+
+
+
-` + renderSATCard("nvidia", "NVIDIA GPU", `
Diag Level Level 1 — Quick Level 2 — Standard Level 3 — Extended Level 4 — Full
Targeted Stress (dcgmi diag targeted_stress)
Official DCGM `+"targeted_stress"+` stays in Validate as a controlled diagnostic load, not a max-burn recipe.
`) +
- renderSATCard("memory", "Memory", "") +
- renderSATCard("storage", "Storage", "") +
- renderSATCard("cpu", "CPU", `
Duration (seconds)
`) +
- renderSATCard("amd", "AMD GPU", `
-MEM Integrity
-MEM Bandwidth
-
-
Additional AMD memory diagnostics: RVS MEM for integrity and BABEL + rocm-bandwidth-test for memory/interconnect bandwidth.
`) +
+` + renderSATCard("cpu", "CPU", "runSAT('cpu')", "", renderValidateCardBody(
+ inv.CPU,
+ `Collects CPU inventory and temperatures, then runs a bounded CPU stress pass.`,
+ `
lscpu,
sensors,
stress-ng`,
+ `Duration is taken from Validate Profile diag level: Level 1 = 60s, Level 2 = 5m, Level 3 = 1h, Level 4 = 1h.`,
+ )) +
+ renderSATCard("memory", "Memory", "runSAT('memory')", "", renderValidateCardBody(
+ inv.Memory,
+ `Runs a short RAM validation pass and records memory state around the test.`,
+ `
free,
memtester`,
+ `No extra settings.`,
+ )) +
+ renderSATCard("storage", "Storage", "runSAT('storage')", "", renderValidateCardBody(
+ inv.Storage,
+ `Scans all storage devices and runs the matching health or self-test path for each device type.`,
+ `
lsblk; NVMe:
nvme; SATA/SAS:
smartctl`,
+ `No extra settings.`,
+ )) +
+ `
+
+
+` + renderSATCard("nvidia", "NVIDIA GPU", "runSAT('nvidia')", "", renderValidateCardBody(
+ inv.NVIDIA,
+ `Runs NVIDIA diagnostics and board inventory checks.`,
+ `nvidia-smi, dmidecode, dcgmi diag`,
+ `Diag level is taken from Validate Profile.`,
+ )) +
+ renderSATCard("nvidia-targeted-stress", "NVIDIA GPU Targeted Stress", "runSAT('nvidia-targeted-stress')", "", renderValidateCardBody(
+ inv.NVIDIA,
+ `Runs a controlled NVIDIA DCGM load in Validate to check stability under moderate stress.`,
+ `dcgmi diag targeted_stress`,
+ `Uses the fixed DCGM targeted stress recipe.`,
+ )) +
+ `
+
+` + renderSATCard("amd", "AMD GPU", "runAMDValidateSet()", "", renderValidateCardBody(
+ inv.AMD,
+ `Runs the selected AMD checks only. GPU Validate collects inventory; MEM Integrity uses the RVS MEM module; MEM Bandwidth uses rocm-bandwidth-test and the RVS BABEL module.`,
+ `GPU Validate:
rocm-smi,
dmidecode; MEM Integrity:
rvs mem; MEM Bandwidth:
rocm-bandwidth-test,
rvs babel`,
+ `
GPU Validate MEM Integrity MEM Bandwidth
`,
+ )) +
`
+
`
}
-func renderSATCard(id, label, extra string) string {
- return fmt.Sprintf(`
`,
- label, extra, id, id)
+func loadValidateInventory(opts HandlerOptions) validateInventory {
+ unknown := "Audit snapshot not loaded."
+ out := validateInventory{
+ CPU: unknown,
+ Memory: unknown,
+ Storage: unknown,
+ NVIDIA: unknown,
+ AMD: unknown,
+ }
+ data, err := loadSnapshot(opts.AuditPath)
+ if err != nil {
+ return out
+ }
+ var snap schema.HardwareIngestRequest
+ if err := json.Unmarshal(data, &snap); err != nil {
+ return out
+ }
+
+ cpuCounts := map[string]int{}
+ cpuTotal := 0
+ for _, cpu := range snap.Hardware.CPUs {
+ if cpu.Present != nil && !*cpu.Present {
+ continue
+ }
+ cpuTotal++
+ addValidateModel(cpuCounts, validateFirstNonEmpty(validateTrimPtr(cpu.Model), validateTrimPtr(cpu.Manufacturer), "unknown"))
+ }
+
+ memCounts := map[string]int{}
+ memTotal := 0
+ for _, dimm := range snap.Hardware.Memory {
+ if dimm.Present != nil && !*dimm.Present {
+ continue
+ }
+ memTotal++
+ addValidateModel(memCounts, validateFirstNonEmpty(validateTrimPtr(dimm.PartNumber), validateTrimPtr(dimm.Type), validateTrimPtr(dimm.Manufacturer), "unknown"))
+ }
+
+ storageCounts := map[string]int{}
+ storageTotal := 0
+ for _, dev := range snap.Hardware.Storage {
+ if dev.Present != nil && !*dev.Present {
+ continue
+ }
+ storageTotal++
+ addValidateModel(storageCounts, validateFirstNonEmpty(validateTrimPtr(dev.Model), validateTrimPtr(dev.Manufacturer), "unknown"))
+ }
+
+ nvidiaCounts := map[string]int{}
+ nvidiaTotal := 0
+ amdCounts := map[string]int{}
+ amdTotal := 0
+ for _, dev := range snap.Hardware.PCIeDevices {
+ if dev.Present != nil && !*dev.Present {
+ continue
+ }
+ if validateIsVendorGPU(dev, "nvidia") {
+ nvidiaTotal++
+ addValidateModel(nvidiaCounts, validateFirstNonEmpty(validateTrimPtr(dev.Model), validateTrimPtr(dev.Manufacturer), "unknown"))
+ }
+ if validateIsVendorGPU(dev, "amd") {
+ amdTotal++
+ addValidateModel(amdCounts, validateFirstNonEmpty(validateTrimPtr(dev.Model), validateTrimPtr(dev.Manufacturer), "unknown"))
+ }
+ }
+
+ out.CPU = formatValidateDeviceSummary(cpuTotal, cpuCounts, "CPU")
+ out.Memory = formatValidateDeviceSummary(memTotal, memCounts, "module")
+ out.Storage = formatValidateDeviceSummary(storageTotal, storageCounts, "device")
+ out.NVIDIA = formatValidateDeviceSummary(nvidiaTotal, nvidiaCounts, "GPU")
+ out.AMD = formatValidateDeviceSummary(amdTotal, amdCounts, "GPU")
+ return out
+}
+
+func renderValidateCardBody(devices, description, commands, settings string) string {
+ return `
` +
+ `
` +
+ `
` +
+ `
`
+}
+
+func formatValidateDeviceSummary(total int, models map[string]int, unit string) string {
+ if total == 0 {
+ return "0 " + unit + "s detected."
+ }
+ keys := make([]string, 0, len(models))
+ for key := range models {
+ keys = append(keys, key)
+ }
+ sort.Strings(keys)
+ parts := make([]string, 0, len(keys))
+ for _, key := range keys {
+ parts = append(parts, fmt.Sprintf("%d x %s", models[key], html.EscapeString(key)))
+ }
+ label := unit
+ if total != 1 {
+ label += "s"
+ }
+ return fmt.Sprintf("%d %s: %s", total, label, strings.Join(parts, ", "))
+}
+
+func addValidateModel(counts map[string]int, name string) {
+ name = strings.TrimSpace(name)
+ if name == "" {
+ name = "unknown"
+ }
+ counts[name]++
+}
+
+func validateTrimPtr(value *string) string {
+ if value == nil {
+ return ""
+ }
+ return strings.TrimSpace(*value)
+}
+
+func validateFirstNonEmpty(values ...string) string {
+ for _, value := range values {
+ value = strings.TrimSpace(value)
+ if value != "" {
+ return value
+ }
+ }
+ return ""
+}
+
+func validateIsVendorGPU(dev schema.HardwarePCIeDevice, vendor string) bool {
+ model := strings.ToLower(validateTrimPtr(dev.Model))
+ manufacturer := strings.ToLower(validateTrimPtr(dev.Manufacturer))
+ class := strings.ToLower(validateTrimPtr(dev.DeviceClass))
+ if strings.Contains(model, "aspeed") || strings.Contains(manufacturer, "aspeed") {
+ return false
+ }
+ switch vendor {
+ case "nvidia":
+ return strings.Contains(model, "nvidia") || strings.Contains(manufacturer, "nvidia")
+ case "amd":
+ isGPUClass := class == "processingaccelerator" || class == "displaycontroller" || class == "videocontroller"
+ isAMDVendor := strings.Contains(manufacturer, "advanced micro devices") || strings.Contains(manufacturer, "amd") || strings.Contains(manufacturer, "ati")
+ isAMDModel := strings.Contains(model, "instinct") || strings.Contains(model, "radeon") || strings.Contains(model, "amd")
+ return isGPUClass && (isAMDVendor || isAMDModel)
+ default:
+ return false
+ }
+}
+
+func renderSATCard(id, label, runAction, headerActions, body string) string {
+ actions := `
Run `
+ if strings.TrimSpace(headerActions) != "" {
+ actions += headerActions
+ }
+ return fmt.Sprintf(`
`,
+ label, actions, body)
}
// ── Benchmark ─────────────────────────────────────────────────────────────────
diff --git a/audit/internal/webui/server_test.go b/audit/internal/webui/server_test.go
index 95eecb9..b534b4c 100644
--- a/audit/internal/webui/server_test.go
+++ b/audit/internal/webui/server_test.go
@@ -543,7 +543,7 @@ func TestRootShowsRunAuditButtonWhenSnapshotMissing(t *testing.T) {
t.Fatalf("status=%d", rec.Code)
}
body := rec.Body.String()
- if !strings.Contains(body, `Run Audit`) {
+ if !strings.Contains(body, `onclick="auditModalRun()">Run audit`) {
t.Fatalf("dashboard missing run audit button: %s", body)
}
if strings.Contains(body, `No audit data`) {
@@ -650,7 +650,7 @@ func TestBenchmarkPageRendersGPUSelectionControls(t *testing.T) {
}
}
-func TestValidatePageRendersNvidiaTargetedStressAction(t *testing.T) {
+func TestValidatePageRendersNvidiaTargetedStressCard(t *testing.T) {
handler := NewHandler(HandlerOptions{})
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/validate", nil))
@@ -659,9 +659,10 @@ func TestValidatePageRendersNvidiaTargetedStressAction(t *testing.T) {
}
body := rec.Body.String()
for _, needle := range []string{
- `Targeted Stress`,
+ `NVIDIA GPU Targeted Stress`,
`nvidia-targeted-stress`,
- `Official DCGM`,
+ `controlled NVIDIA DCGM load`,
+ `
dcgmi diag targeted_stress`,
} {
if !strings.Contains(body, needle) {
t.Fatalf("validate page missing %q: %s", needle, body)
@@ -845,3 +846,98 @@ func TestRuntimeHealthEndpointReturnsJSON(t *testing.T) {
t.Fatalf("body=%q want %q", strings.TrimSpace(rec.Body.String()), body)
}
}
+
+func TestDashboardRendersRuntimeHealthTable(t *testing.T) {
+ dir := t.TempDir()
+ path := filepath.Join(dir, "audit.json")
+ exportDir := filepath.Join(dir, "export")
+ if err := os.MkdirAll(exportDir, 0755); err != nil {
+ t.Fatal(err)
+ }
+ if err := os.WriteFile(path, []byte(`{"collected_at":"2026-03-15T00:00:00Z","hardware":{"board":{"serial_number":"SERIAL-1"}}}`), 0644); err != nil {
+ t.Fatal(err)
+ }
+ health := `{
+ "status":"PARTIAL",
+ "checked_at":"2026-03-16T10:00:00Z",
+ "export_dir":"/tmp/export",
+ "driver_ready":true,
+ "cuda_ready":false,
+ "network_status":"PARTIAL",
+ "issues":[
+ {"code":"dhcp_partial","description":"At least one interface did not obtain IPv4 connectivity."},
+ {"code":"cuda_runtime_not_ready","description":"CUDA runtime is not ready for GPU SAT."}
+ ],
+ "tools":[
+ {"name":"dmidecode","ok":true},
+ {"name":"nvidia-smi","ok":false}
+ ],
+ "services":[
+ {"name":"bee-web","status":"active"},
+ {"name":"bee-nvidia","status":"inactive"}
+ ]
+}`
+ if err := os.WriteFile(filepath.Join(exportDir, "runtime-health.json"), []byte(health), 0644); err != nil {
+ t.Fatal(err)
+ }
+ componentStatus := `[
+ {
+ "component_key":"cpu:all",
+ "status":"Warning",
+ "error_summary":"cpu SAT: FAILED",
+ "history":[{"at":"2026-03-16T10:00:00Z","status":"Warning","source":"sat:cpu","detail":"cpu SAT: FAILED"}]
+ },
+ {
+ "component_key":"memory:all",
+ "status":"OK",
+ "history":[{"at":"2026-03-16T10:01:00Z","status":"OK","source":"sat:memory","detail":"memory SAT: OK"}]
+ },
+ {
+ "component_key":"storage:nvme0n1",
+ "status":"Critical",
+ "error_summary":"storage SAT: FAILED",
+ "history":[{"at":"2026-03-16T10:02:00Z","status":"Critical","source":"sat:storage","detail":"storage SAT: FAILED"}]
+ },
+ {
+ "component_key":"pcie:gpu:nvidia",
+ "status":"Warning",
+ "error_summary":"nvidia SAT: FAILED",
+ "history":[{"at":"2026-03-16T10:03:00Z","status":"Warning","source":"sat:nvidia","detail":"nvidia SAT: FAILED"}]
+ }
+]`
+ if err := os.WriteFile(filepath.Join(exportDir, "component-status.json"), []byte(componentStatus), 0644); err != nil {
+ t.Fatal(err)
+ }
+
+ handler := NewHandler(HandlerOptions{AuditPath: path, ExportDir: exportDir})
+ rec := httptest.NewRecorder()
+ handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
+ if rec.Code != http.StatusOK {
+ t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+ }
+ body := rec.Body.String()
+ for _, needle := range []string{
+ `Runtime Health`,
+ `
Check Status Source Issue `,
+ `Export Directory`,
+ `Network`,
+ `NVIDIA/AMD Driver`,
+ `CUDA / ROCm`,
+ `Required Utilities`,
+ `Bee Services`,
+ `
CPU `,
+ `
Memory `,
+ `
Storage `,
+ `
GPU `,
+ `CUDA runtime is not ready for GPU SAT.`,
+ `Missing: nvidia-smi`,
+ `bee-nvidia=inactive`,
+ `cpu SAT: FAILED`,
+ `storage SAT: FAILED`,
+ `sat:nvidia`,
+ } {
+ if !strings.Contains(body, needle) {
+ t.Fatalf("dashboard missing %q: %s", needle, body)
+ }
+ }
+}