Mikhail ChusavitinandClaude Sonnet 5
9b2c654182
The audit tool that ingests Reanimator exports treats any per-component field
change between imports as a component replacement. Importing an xFusion BMC dump
and an easy_bee BEE-SP bundle for one server produced large spurious diffs.
xfusion:
- parseMemInfo tolerates a stray 0x0A inside the binary SPD "bom number" column
(it was splitting a DIMM record in two and emitting a phantom "slot s" module)
- DIMM slot from the "dimm name" column ("DIMM071"), mainboard "location" dropped
- GPU slot = BDF (Reanimator contract)
- NIC emitted per PCI function from netcard_info.txt (BDF + per-port MAC, shared
card serial) instead of one card-level adapter with the wrong BDF, which had
been colliding with a GPU and vanishing in dedup
- NIC manufacturer left blank when it is the system OEM so the exporter resolves
the silicon vendor from pci.ids
- "(U6216)" chip designator stripped from firmware versions
easy_bee:
- PSU bay numbers rebased 0-indexed -> 1-indexed; bare single-letter PSU
"firmware" (a leaked FRU version) cleared
- board.part_number taken from the bundle's ipmitool-fru.txt chassis
"Product Part Number" to match the BMC value
exporter (cross-vendor):
- canonicalMemorySlot: drop dmidecode "(J)" channel tag, Memory111 -> DIMM111
- canonicalGPUModel: NVIDIA DC GPUs reduce to the bare chip token
- canonicalStorageMediaAndInterface: NVMe is a bus not a medium
- manufacturerFromStorageModel: fill blank drive vendor from the model prefix
- isRemovableUSBStorageDevice: drop live-CD boot sticks
- isOnboardControllerPCIeDevice: drop SATA/NVMe/MegaRAID/PCIe-switch controller
functions that only an lspci scan reports (keep add-in cards with an identity)
For the reference server every physical component now appears in both exports
keyed identically; residual diffs are one-sided enrichment only.
Refs ADL-061, ADL-062.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VFy4m7cVv4cqp25jJh2gSB
367 lines
13 KiB
Go
367 lines
13 KiB
Go
package xfusion
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.mchus.pro/mchus/logpile/internal/models"
|
|
"git.mchus.pro/mchus/logpile/internal/parser"
|
|
)
|
|
|
|
// loadTestArchive extracts the given archive path for use in tests.
|
|
// Skips the test if the file is not found (CI environments without testdata).
|
|
func loadTestArchive(t *testing.T, path string) []parser.ExtractedFile {
|
|
t.Helper()
|
|
files, err := parser.ExtractArchive(path)
|
|
if err != nil {
|
|
t.Skipf("cannot load test archive %s: %v", path, err)
|
|
}
|
|
return files
|
|
}
|
|
|
|
func TestDetect_G5500V7(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
score := p.Detect(files)
|
|
if score < 80 {
|
|
t.Fatalf("expected Detect score >= 80, got %d", score)
|
|
}
|
|
}
|
|
|
|
func TestDetect_ServerFileExportMarkers(t *testing.T) {
|
|
p := &Parser{}
|
|
score := p.Detect([]parser.ExtractedFile{
|
|
{Path: "dump_info/RTOSDump/versioninfo/app_revision.txt", Content: []byte("Product Name: G5500 V7")},
|
|
{Path: "dump_info/LogDump/netcard/netcard_info.txt", Content: []byte("2026-02-04 03:54:06 UTC")},
|
|
{Path: "dump_info/AppDump/card_manage/card_info", Content: []byte("OCP Card Info")},
|
|
})
|
|
if score < 70 {
|
|
t.Fatalf("expected Detect score >= 70 for xFusion file export markers, got %d", score)
|
|
}
|
|
}
|
|
|
|
func TestDetect_Negative(t *testing.T) {
|
|
p := &Parser{}
|
|
score := p.Detect([]parser.ExtractedFile{
|
|
{Path: "logs/messages.txt", Content: []byte("plain text")},
|
|
{Path: "inventory.json", Content: []byte(`{"vendor":"other"}`)},
|
|
})
|
|
if score != 0 {
|
|
t.Fatalf("expected Detect score 0 for non-xFusion input, got %d", score)
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_BoardInfo(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if result.Hardware == nil {
|
|
t.Fatal("Hardware is nil")
|
|
}
|
|
board := result.Hardware.BoardInfo
|
|
if board.SerialNumber != "210619KUGGXGS2000015" {
|
|
t.Errorf("BoardInfo.SerialNumber = %q, want 210619KUGGXGS2000015", board.SerialNumber)
|
|
}
|
|
if board.ProductName != "G5500 V7" {
|
|
t.Errorf("BoardInfo.ProductName = %q, want G5500 V7", board.ProductName)
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_CPUs(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Hardware.CPUs) != 2 {
|
|
t.Fatalf("expected 2 CPUs, got %d", len(result.Hardware.CPUs))
|
|
}
|
|
cpu1 := result.Hardware.CPUs[0]
|
|
if cpu1.Cores != 32 {
|
|
t.Errorf("CPU1 cores = %d, want 32", cpu1.Cores)
|
|
}
|
|
if cpu1.Threads != 64 {
|
|
t.Errorf("CPU1 threads = %d, want 64", cpu1.Threads)
|
|
}
|
|
if cpu1.SerialNumber == "" {
|
|
t.Error("CPU1 SerialNumber is empty")
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_Memory(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
// Only 2 DIMMs are populated (rest are "NO DIMM")
|
|
if len(result.Hardware.Memory) != 2 {
|
|
t.Fatalf("expected 2 populated DIMMs, got %d", len(result.Hardware.Memory))
|
|
}
|
|
dimm := result.Hardware.Memory[0]
|
|
if dimm.SizeMB != 65536 {
|
|
t.Errorf("DIMM0 SizeMB = %d, want 65536", dimm.SizeMB)
|
|
}
|
|
if dimm.Type != "DDR5" {
|
|
t.Errorf("DIMM0 Type = %q, want DDR5", dimm.Type)
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_GPUs(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Hardware.GPUs) != 8 {
|
|
t.Fatalf("expected 8 GPUs, got %d", len(result.Hardware.GPUs))
|
|
}
|
|
for _, gpu := range result.Hardware.GPUs {
|
|
if gpu.SerialNumber == "" {
|
|
t.Errorf("GPU slot %s has empty SerialNumber", gpu.Slot)
|
|
}
|
|
if gpu.Model == "" {
|
|
t.Errorf("GPU slot %s has empty Model", gpu.Slot)
|
|
}
|
|
if gpu.Firmware == "" {
|
|
t.Errorf("GPU slot %s has empty Firmware", gpu.Slot)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_NICs(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Hardware.NetworkCards) < 1 {
|
|
t.Fatal("expected at least 1 NIC (OCP CX6), got 0")
|
|
}
|
|
nic := result.Hardware.NetworkCards[0]
|
|
if nic.SerialNumber == "" {
|
|
t.Errorf("NIC SerialNumber is empty")
|
|
}
|
|
}
|
|
|
|
func TestParse_ServerFileExport_NetworkAdaptersAndFirmware(t *testing.T) {
|
|
p := &Parser{}
|
|
files := []parser.ExtractedFile{
|
|
{
|
|
Path: "dump_info/AppDump/card_manage/card_info",
|
|
Content: []byte(strings.TrimSpace(`
|
|
Pcie Card Info
|
|
Slot | Vender Id | Device Id | Sub Vender Id | Sub Device Id | Segment Number | Bus Number | Device Number | Function Number | Card Desc | Board Id | PCB Version | CPLD Version | Sub Card Bom Id | PartNum | SerialNumber | OriginalPartNum
|
|
1 | 0x15b3 | 0x101f | 0x1f24 | 0x2011 | 0x00 | 0x27 | 0x00 | 0x00 | MT2894 Family [ConnectX-6 Lx] | N/A | N/A | N/A | N/A | 0302Y238 | 02Y238X6RC000058 |
|
|
|
|
OCP Card Info
|
|
Slot | Vender Id | Device Id | Sub Vender Id | Sub Device Id | Segment Number | Bus Number | Device Number | Function Number | Card Desc | Board Id | PCB Version | CPLD Version | Sub Card Bom Id | PartNum | SerialNumber | OriginalPartNum
|
|
1 | 0x15b3 | 0x101f | 0x1f24 | 0x2011 | 0x00 | 0x27 | 0x00 | 0x00 | MT2894 Family [ConnectX-6 Lx] | N/A | N/A | N/A | N/A | 0302Y238 | 02Y238X6RC000058 |
|
|
`)),
|
|
},
|
|
{
|
|
Path: "dump_info/LogDump/netcard/netcard_info.txt",
|
|
Content: []byte(strings.TrimSpace(`
|
|
2026-02-04 03:54:06 UTC
|
|
ProductName :XC385
|
|
Manufacture :XFUSION
|
|
FirmwareVersion :26.39.2048
|
|
SlotId :1
|
|
Port0 BDF:0000:27:00.0
|
|
MacAddr:44:1A:4C:16:E8:03
|
|
ActualMac:44:1A:4C:16:E8:03
|
|
Port1 BDF:0000:27:00.1
|
|
MacAddr:00:00:00:00:00:00
|
|
ActualMac:44:1A:4C:16:E8:04
|
|
`)),
|
|
},
|
|
{
|
|
Path: "dump_info/RTOSDump/versioninfo/app_revision.txt",
|
|
Content: []byte(strings.TrimSpace(`
|
|
------------------- iBMC INFO -------------------
|
|
Active iBMC Version: (U68)3.08.05.85
|
|
Active iBMC Built: 16:46:26 Jan 4 2026
|
|
SDK Version: 13.16.30.16
|
|
SDK Built: 07:55:18 Dec 12 2025
|
|
Active BIOS Version: (U6216)01.02.08.17
|
|
Active BIOS Built: 00:00:00 Jan 05 2026
|
|
Product Name: G5500 V7
|
|
`)),
|
|
},
|
|
}
|
|
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if result.Protocol != "ipmi" || result.SourceType != models.SourceTypeArchive {
|
|
t.Fatalf("unexpected source metadata: protocol=%q source_type=%q", result.Protocol, result.SourceType)
|
|
}
|
|
if result.Hardware == nil {
|
|
t.Fatal("Hardware is nil")
|
|
}
|
|
// One adapter per PCI function, keyed by that port's BDF, matching an
|
|
// OS-level lspci view. Ports share the card's serial and firmware.
|
|
if len(result.Hardware.NetworkAdapters) != 2 {
|
|
t.Fatalf("expected 2 network adapters (one per port), got %d", len(result.Hardware.NetworkAdapters))
|
|
}
|
|
byBDF := map[string]models.NetworkAdapter{}
|
|
for _, a := range result.Hardware.NetworkAdapters {
|
|
byBDF[a.BDF] = a
|
|
if a.Firmware != "26.39.2048" {
|
|
t.Fatalf("adapter %s firmware = %q, want 26.39.2048", a.BDF, a.Firmware)
|
|
}
|
|
if a.SerialNumber != "02Y238X6RC000058" {
|
|
t.Fatalf("adapter %s serial = %q, want 02Y238X6RC000058", a.BDF, a.SerialNumber)
|
|
}
|
|
}
|
|
if got := byBDF["0000:27:00.0"].MACAddresses; len(got) != 1 || got[0] != "44:1A:4C:16:E8:03" {
|
|
t.Fatalf("port 0 MACs = %#v", got)
|
|
}
|
|
if got := byBDF["0000:27:00.1"].MACAddresses; len(got) != 1 || got[0] != "44:1A:4C:16:E8:04" {
|
|
t.Fatalf("port 1 MACs = %#v", got)
|
|
}
|
|
|
|
fwByDevice := make(map[string]models.FirmwareInfo)
|
|
for _, fw := range result.Hardware.Firmware {
|
|
fwByDevice[fw.DeviceName] = fw
|
|
}
|
|
if fwByDevice["iBMC"].Version != "3.08.05.85" {
|
|
t.Fatalf("expected iBMC firmware (chip designator stripped) from app_revision.txt, got %#v", fwByDevice["iBMC"])
|
|
}
|
|
if fwByDevice["BIOS"].Version != "01.02.08.17" {
|
|
t.Fatalf("expected BIOS firmware (chip designator stripped) from app_revision.txt, got %#v", fwByDevice["BIOS"])
|
|
}
|
|
if result.Hardware.BoardInfo.ProductName != "G5500 V7" {
|
|
t.Fatalf("expected board product fallback from app_revision.txt, got %q", result.Hardware.BoardInfo.ProductName)
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_PSUs(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Hardware.PowerSupply) != 4 {
|
|
t.Fatalf("expected 4 PSUs, got %d", len(result.Hardware.PowerSupply))
|
|
}
|
|
for _, psu := range result.Hardware.PowerSupply {
|
|
if psu.WattageW != 3000 {
|
|
t.Errorf("PSU slot %s wattage = %d, want 3000", psu.Slot, psu.WattageW)
|
|
}
|
|
if psu.SerialNumber == "" {
|
|
t.Errorf("PSU slot %s has empty SerialNumber", psu.Slot)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_Storage(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Hardware.Storage) != 2 {
|
|
t.Fatalf("expected 2 storage devices, got %d", len(result.Hardware.Storage))
|
|
}
|
|
for _, disk := range result.Hardware.Storage {
|
|
if disk.SerialNumber == "" {
|
|
t.Errorf("disk slot %s has empty SerialNumber", disk.Slot)
|
|
}
|
|
if disk.Model == "" {
|
|
t.Errorf("disk slot %s has empty Model", disk.Slot)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_Sensors(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Sensors) < 20 {
|
|
t.Fatalf("expected at least 20 sensors, got %d", len(result.Sensors))
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_Events(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.Events) < 5 {
|
|
t.Fatalf("expected at least 5 events, got %d", len(result.Events))
|
|
}
|
|
// All events should have real timestamps (not epoch 0)
|
|
for _, ev := range result.Events {
|
|
if ev.Timestamp.Year() <= 1970 {
|
|
t.Errorf("event has epoch timestamp: %v %s", ev.Timestamp, ev.Description)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParse_G5500V7_FRU(t *testing.T) {
|
|
files := loadTestArchive(t, "../../../../example/G5500V7_210619KUGGXGS2000015_20260318-1128.tar.gz")
|
|
p := &Parser{}
|
|
result, err := p.Parse(files)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
if len(result.FRU) < 3 {
|
|
t.Fatalf("expected at least 3 FRU entries, got %d", len(result.FRU))
|
|
}
|
|
// Check mainboard FRU serial
|
|
found := false
|
|
for _, f := range result.FRU {
|
|
if f.SerialNumber == "210619KUGGXGS2000015" {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Error("mainboard serial 210619KUGGXGS2000015 not found in FRU")
|
|
}
|
|
}
|
|
|
|
// TestParseMemInfo_EmbeddedNewlineInBOM guards against the BMC copying a raw SPD
|
|
// "bom number" field containing a 0x0A byte, which splits a DIMM record across
|
|
// two physical lines. The row must be rejoined, not turned into a phantom DIMM.
|
|
func TestParseMemInfo_EmbeddedNewlineInBOM(t *testing.T) {
|
|
const header = "slot(col 1), dimm location(col 2), dimm name(col 3),manufacturer(col 4), size(col 5), speed(col 6), current speed(col 7), memory type(col 8), SN(col 9), minimum voltage(col 10), rank(col 11), bit width(col 12), memory technology(col 13), bom number(col 14), part number(col 15),remaining service life(col 16), firmware version(col 17), medium temp(col 18), controller temp(col 19), volatile capacity(col 20), persistent capacity(col 21), health(col 22)\n"
|
|
good := "Memory160 , mainboard, DIMM160, Samsung, 65536 MB, 5600 MT/s, 4400 MT/s, DDR5, 13E79B2E, 1100 mV, 2 rank, 64 bit, Synchronous| Registered (Buffered), \x01\x02, M321R8GA0EB2-CWMXH, Unknown, N/A, Unknown, Unknown, Unknown, Unknown, OK\n"
|
|
// Memory170: BOM field carries a stray newline mid-record.
|
|
split := "Memory170 , mainboard, DIMM170, Samsung, 65536 MB, 5600 MT/s, 4400 MT/s, DDR5, 13E79D42, 1100 mV, 2 rank, 64 bit, Synchronous| Registered (Buffered), \x9d7h!\x8f\n" +
|
|
"s, M321R8GA0EB2-CWMXH, Unknown, N/A, Unknown, Unknown, Unknown, Unknown, OK\n"
|
|
|
|
dimms := parseMemInfo([]byte(header + good + split))
|
|
if len(dimms) != 2 {
|
|
t.Fatalf("expected 2 DIMMs, got %d: %+v", len(dimms), dimms)
|
|
}
|
|
m170 := dimms[1]
|
|
if m170.Slot != "DIMM170" {
|
|
t.Errorf("slot = %q, want DIMM170", m170.Slot)
|
|
}
|
|
if m170.SerialNumber != "13E79D42" {
|
|
t.Errorf("serial = %q, want 13E79D42", m170.SerialNumber)
|
|
}
|
|
if m170.PartNumber != "M321R8GA0EB2-CWMXH" {
|
|
t.Errorf("part number = %q, want M321R8GA0EB2-CWMXH", m170.PartNumber)
|
|
}
|
|
if m170.SizeMB != 65536 || m170.Type != "DDR5" || m170.CurrentSpeedMHz != 4400 {
|
|
t.Errorf("m170 fields not recovered: %+v", m170)
|
|
}
|
|
}
|