redfish: MSI support, fix zero dates, BMC MAC, Assembly FRU, crawler cleanup

- Add MSI CG480-S5063 (H100 SXM5) support: - collectGPUsFromProcessors: find GPUs via Processors/ProcessorType=GPU, resolve serials from Chassis/<GpuId> - looksLikeGPU: skip Description="Display Device" PCIe sidecars - isVirtualStorageDrive: filter AMI virtual USB drives (0-byte) - enrichNICMACsFromNetworkDeviceFunctions: pull MACs for MSI NICs - parseCPUs: filter by ProcessorType, parse Socket, L1/L2/L3 from ProcessorMemory - parseMemory: Location.PartLocation.ServiceLabel slot fallback - shouldCrawlPath: block /SubProcessors subtrees - Fix status_checked_at/status_changed_at serializing as 0001-01-01: change all StatusCheckedAt/StatusChangedAt fields to *time.Time - Redfish crawler cleanup: - Block non-inventory branches: AccountService, CertificateService, EventService, Registries, SessionService, TaskService, manager config paths, OperatingConfigs, BootOptions, HostPostCode, Bios/Settings, OEM KVM paths - Add Assembly to critical endpoints (FRU data) - Remove BootOptions from priority seeds - collectBMCMAC: read BMC MAC from Managers/*/EthernetInterfaces - collectAssemblyFRU: extract FRU serial/part from Chassis/*/Assembly - Firmware: remove NetworkProtocol noise, fix SecureBoot field, filter BMCImageN redundant backup slots Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-03-04 08:12:17 +03:00
parent 21ea129933
commit 8d80048117
8 changed files with 430 additions and 54 deletions
@@ -72,6 +72,7 @@ func ReplayRedfishFromRawPayloads(rawPayloads map[string]any, emit ProgressFn) (
 	psus := r.collectPSUs(chassisPaths)
 	pcieDevices := r.collectPCIeDevices(systemPaths, chassisPaths)
 	gpus := r.collectGPUs(systemPaths, chassisPaths)
+	gpus = r.collectGPUsFromProcessors(systemPaths, chassisPaths, gpus)
 	nics := r.collectNICs(chassisPaths)
 	r.enrichNICsFromNetworkInterfaces(&nics, systemPaths)
 	thresholdSensors := r.collectThresholdSensors(chassisPaths)
@@ -86,13 +87,15 @@ func ReplayRedfishFromRawPayloads(rawPayloads map[string]any, emit ProgressFn) (
 	firmware = dedupeFirmwareInfo(append(firmware, r.collectFirmwareInventory()...))
 	boardInfo := parseBoardInfoWithFallback(systemDoc, chassisDoc, fruDoc)
 	applyBoardInfoFallbackFromDocs(&boardInfo, boardFallbackDocs)
+	boardInfo.BMCMACAddress = r.collectBMCMAC(managerPaths)
+	assemblyFRU := r.collectAssemblyFRU(chassisPaths)
 	collectedAt, sourceTimezone := inferRedfishCollectionTime(managerDoc, rawPayloads)

 	result := &models.AnalysisResult{
 		CollectedAt: collectedAt,
 		SourceTimezone: sourceTimezone,
 		Events:      append(append(append(make([]models.Event, 0, len(discreteEvents)+len(healthEvents)+len(driveFetchWarningEvents)+1), healthEvents...), discreteEvents...), driveFetchWarningEvents...),
-		FRU:         make([]models.FRUInfo, 0),
+		FRU:         assemblyFRU,
 		Sensors:     dedupeSensorReadings(append(append(thresholdSensors, thermalSensors...), powerSensors...)),
 		RawPayloads: cloneRawPayloads(rawPayloads),
 		Hardware: &models.HardwareConfig{
@@ -274,7 +277,12 @@ func (r redfishSnapshotReader) collectFirmwareInventory() []models.FirmwareInfo
 			asString(doc["Name"]),
 			asString(doc["Id"]),
 		)
-		if strings.TrimSpace(name) == "" {
+		name = strings.TrimSpace(name)
+		if name == "" {
+			continue
+		}
+		// BMCImageN entries are redundant backup slot labels; skip them.
+		if strings.HasPrefix(strings.ToLower(name), "bmcimage") {
 			continue
 		}
 		out = append(out, models.FirmwareInfo{DeviceName: name, Version: version})
@@ -977,7 +985,9 @@ func (r redfishSnapshotReader) collectStorage(systemPath string) []models.Storag
 				driveDocs, err := r.getCollectionMembers(driveCollectionPath)
 				if err == nil {
 					for _, driveDoc := range driveDocs {
-						out = append(out, parseDrive(driveDoc))
+						if !isVirtualStorageDrive(driveDoc) {
+							out = append(out, parseDrive(driveDoc))
+						}
 					}
 					if len(driveDocs) == 0 {
 						for _, driveDoc := range r.probeDirectDiskBayChildren(driveCollectionPath) {
@@ -1002,7 +1012,9 @@ func (r redfishSnapshotReader) collectStorage(systemPath string) []models.Storag
 				if err != nil {
 					continue
 				}
-				out = append(out, parseDrive(driveDoc))
+				if !isVirtualStorageDrive(driveDoc) {
+					out = append(out, parseDrive(driveDoc))
+				}
 			}
 			continue
 		}
@@ -1154,6 +1166,10 @@ func (r redfishSnapshotReader) collectNICs(chassisPaths []string) []models.Netwo
 				functionDocs := r.getLinkedPCIeFunctions(pcieDoc)
 				enrichNICFromPCIe(&nic, pcieDoc, functionDocs)
 			}
+			// Collect MACs from NetworkDeviceFunctions when not found via PCIe path.
+			if len(nic.MACAddresses) == 0 {
+				r.enrichNICMACsFromNetworkDeviceFunctions(&nic, doc)
+			}
 			nics = append(nics, nic)
 		}
 	}
@@ -1268,3 +1284,237 @@ func stringsTrimTrailingSlash(s string) string {
 	}
 	return s
 }
+
+// collectBMCMAC returns the MAC address of the first active BMC management
+// interface found in Managers/*/EthernetInterfaces. Returns empty string if
+// no MAC is available.
+func (r redfishSnapshotReader) collectBMCMAC(managerPaths []string) string {
+	for _, managerPath := range managerPaths {
+		members, err := r.getCollectionMembers(joinPath(managerPath, "/EthernetInterfaces"))
+		if err != nil || len(members) == 0 {
+			continue
+		}
+		for _, doc := range members {
+			mac := strings.TrimSpace(firstNonEmpty(
+				asString(doc["PermanentMACAddress"]),
+				asString(doc["MACAddress"]),
+			))
+			if mac == "" || strings.EqualFold(mac, "00:00:00:00:00:00") {
+				continue
+			}
+			return strings.ToUpper(mac)
+		}
+	}
+	return ""
+}
+
+// collectAssemblyFRU reads Chassis/*/Assembly documents and returns FRU entries
+// for subcomponents (backplanes, PSUs, DIMMs, etc.) that carry meaningful
+// serial or part numbers. Entries already present in dedicated collections
+// (PSUs, DIMMs) are included here as well so that all FRU data is available
+// in one place; deduplication by serial is performed.
+func (r redfishSnapshotReader) collectAssemblyFRU(chassisPaths []string) []models.FRUInfo {
+	seen := make(map[string]struct{})
+	var out []models.FRUInfo
+
+	add := func(fru models.FRUInfo) {
+		key := strings.ToUpper(strings.TrimSpace(fru.SerialNumber))
+		if key == "" {
+			key = strings.ToUpper(strings.TrimSpace(fru.Description + "|" + fru.PartNumber))
+		}
+		if key == "" || key == "|" {
+			return
+		}
+		if _, ok := seen[key]; ok {
+			return
+		}
+		seen[key] = struct{}{}
+		out = append(out, fru)
+	}
+
+	for _, chassisPath := range chassisPaths {
+		doc, err := r.getJSON(joinPath(chassisPath, "/Assembly"))
+		if err != nil || len(doc) == 0 {
+			continue
+		}
+		assemblies, _ := doc["Assemblies"].([]interface{})
+		for _, aAny := range assemblies {
+			a, ok := aAny.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			name := strings.TrimSpace(firstNonEmpty(asString(a["Name"]), asString(a["Description"])))
+			model := strings.TrimSpace(asString(a["Model"]))
+			partNumber := strings.TrimSpace(asString(a["PartNumber"]))
+			serial := extractAssemblySerial(a)
+
+			if serial == "" && partNumber == "" {
+				continue
+			}
+			add(models.FRUInfo{
+				Description:  name,
+				ProductName:  model,
+				SerialNumber: serial,
+				PartNumber:   partNumber,
+			})
+		}
+	}
+	return out
+}
+
+// extractAssemblySerial tries to find a serial number in an Assembly entry.
+// Standard Redfish Assembly has no top-level SerialNumber; vendors put it in Oem.
+func extractAssemblySerial(a map[string]interface{}) string {
+	// Some implementations expose it at top level.
+	if s := strings.TrimSpace(asString(a["SerialNumber"])); s != "" {
+		return s
+	}
+	// Dig into Oem for vendor-specific structures (e.g. Huawei COMMONb).
+	oem, _ := a["Oem"].(map[string]interface{})
+	for _, v := range oem {
+		subtree, ok := v.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		for _, v2 := range subtree {
+			node, ok := v2.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if s := strings.TrimSpace(asString(node["SerialNumber"])); s != "" {
+				return s
+			}
+		}
+	}
+	return ""
+}
+
+// enrichNICMACsFromNetworkDeviceFunctions reads the NetworkDeviceFunctions
+// collection linked from a NetworkAdapter document and populates the NIC's
+// MACAddresses from each function's Ethernet.PermanentMACAddress / MACAddress.
+// Called when PCIe-path enrichment does not produce any MACs.
+func (r redfishSnapshotReader) enrichNICMACsFromNetworkDeviceFunctions(nic *models.NetworkAdapter, adapterDoc map[string]interface{}) {
+	ndfCol, ok := adapterDoc["NetworkDeviceFunctions"].(map[string]interface{})
+	if !ok {
+		return
+	}
+	colPath := asString(ndfCol["@odata.id"])
+	if colPath == "" {
+		return
+	}
+	funcDocs, err := r.getCollectionMembers(colPath)
+	if err != nil || len(funcDocs) == 0 {
+		return
+	}
+	for _, fn := range funcDocs {
+		eth, _ := fn["Ethernet"].(map[string]interface{})
+		if eth == nil {
+			continue
+		}
+		mac := strings.TrimSpace(firstNonEmpty(
+			asString(eth["PermanentMACAddress"]),
+			asString(eth["MACAddress"]),
+		))
+		if mac == "" {
+			continue
+		}
+		nic.MACAddresses = dedupeStrings(append(nic.MACAddresses, strings.ToUpper(mac)))
+	}
+	if len(funcDocs) > 0 && nic.PortCount == 0 {
+		nic.PortCount = sanitizeNetworkPortCount(len(funcDocs))
+	}
+}
+
+// collectGPUsFromProcessors finds GPUs that some BMCs (e.g. MSI) expose as
+// Processor entries with ProcessorType=GPU rather than as PCIe devices.
+// It supplements the existing gpus slice (already found via PCIe path),
+// skipping entries already present by UUID or SerialNumber.
+// Serial numbers are looked up from Chassis members named after each GPU Id.
+func (r redfishSnapshotReader) collectGPUsFromProcessors(systemPaths, chassisPaths []string, existing []models.GPU) []models.GPU {
+	// Build a lookup: chassis member ID → chassis doc (for serial numbers).
+	chassisByID := make(map[string]map[string]interface{})
+	for _, cp := range chassisPaths {
+		doc, err := r.getJSON(cp)
+		if err != nil || len(doc) == 0 {
+			continue
+		}
+		id := strings.TrimSpace(asString(doc["Id"]))
+		if id != "" {
+			chassisByID[strings.ToUpper(id)] = doc
+		}
+	}
+
+	// Build dedup sets from existing GPUs.
+	seenUUID := make(map[string]struct{})
+	seenSerial := make(map[string]struct{})
+	for _, g := range existing {
+		if u := strings.ToUpper(strings.TrimSpace(g.UUID)); u != "" {
+			seenUUID[u] = struct{}{}
+		}
+		if s := strings.ToUpper(strings.TrimSpace(g.SerialNumber)); s != "" {
+			seenSerial[s] = struct{}{}
+		}
+	}
+
+	out := append([]models.GPU{}, existing...)
+	idx := len(existing) + 1
+
+	for _, systemPath := range systemPaths {
+		procDocs, err := r.getCollectionMembers(joinPath(systemPath, "/Processors"))
+		if err != nil {
+			continue
+		}
+		for _, doc := range procDocs {
+			if !strings.EqualFold(strings.TrimSpace(asString(doc["ProcessorType"])), "GPU") {
+				continue
+			}
+
+			// Resolve serial from Chassis/<Id>.
+			gpuID := strings.TrimSpace(asString(doc["Id"]))
+			serial := ""
+			if chassisDoc, ok := chassisByID[strings.ToUpper(gpuID)]; ok {
+				serial = strings.TrimSpace(asString(chassisDoc["SerialNumber"]))
+			}
+
+			uuid := strings.TrimSpace(asString(doc["UUID"]))
+			uuidKey := strings.ToUpper(uuid)
+			serialKey := strings.ToUpper(serial)
+
+			if uuidKey != "" {
+				if _, dup := seenUUID[uuidKey]; dup {
+					continue
+				}
+				seenUUID[uuidKey] = struct{}{}
+			}
+			if serialKey != "" {
+				if _, dup := seenSerial[serialKey]; dup {
+					continue
+				}
+				seenSerial[serialKey] = struct{}{}
+			}
+
+			slotLabel := firstNonEmpty(
+				redfishLocationLabel(doc["Location"]),
+				redfishLocationLabel(doc["PhysicalLocation"]),
+			)
+			if slotLabel == "" && gpuID != "" {
+				slotLabel = gpuID
+			}
+			if slotLabel == "" {
+				slotLabel = fmt.Sprintf("GPU%d", idx)
+			}
+
+			out = append(out, models.GPU{
+				Slot:         slotLabel,
+				Model:        firstNonEmpty(asString(doc["Model"]), asString(doc["Name"])),
+				Manufacturer: asString(doc["Manufacturer"]),
+				PartNumber:   asString(doc["PartNumber"]),
+				SerialNumber: serial,
+				UUID:         uuid,
+				Status:       mapStatus(doc["Status"]),
+			})
+			idx++
+		}
+	}
+	return out
+}