21f4e5a67e
Major improvements: - Add CSV SEL event parser for Kaytus firmware format - Add PCIe device parser with link speed/width detection - Add GPU temperature and PCIe link monitoring - Add disk backplane parser for storage bay information - Fix memory module detection (only show installed DIMMs) Parser enhancements: - Parse RESTful PCIe Device info (max/current link width/speed) - Parse GPU sensor data (core and memory temperatures) - Parse diskbackplane info (slot count, installed drives) - Parse SEL events from CSV format (selelist.csv) - Fix memory Present status logic (check mem_mod_status) Web interface improvements: - Add PCIe link degradation highlighting (red when current < max) - Add storage table with Present status and location - Update memory specification to show only installed modules with frequency - Sort events from newest to oldest - Filter out N/A serial numbers from display Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
480 lines
14 KiB
Go
480 lines
14 KiB
Go
package inspur
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.mchus.pro/mchus/logpile/internal/models"
|
|
)
|
|
|
|
// ParseComponentLog parses component.log file and extracts detailed hardware info
|
|
func ParseComponentLog(content []byte, hw *models.HardwareConfig) {
|
|
if hw == nil {
|
|
return
|
|
}
|
|
|
|
text := string(content)
|
|
|
|
// Parse RESTful Memory info (detailed memory data)
|
|
parseMemoryInfo(text, hw)
|
|
|
|
// Parse RESTful PSU info
|
|
parsePSUInfo(text, hw)
|
|
|
|
// Parse RESTful HDD info
|
|
parseHDDInfo(text, hw)
|
|
|
|
// Parse RESTful diskbackplane info
|
|
parseDiskBackplaneInfo(text, hw)
|
|
|
|
// Parse RESTful Network Adapter info
|
|
parseNetworkAdapterInfo(text, hw)
|
|
|
|
// Extract firmware from all components
|
|
extractComponentFirmware(text, hw)
|
|
}
|
|
|
|
// ParseComponentLogEvents extracts events from component.log (memory errors, etc.)
|
|
func ParseComponentLogEvents(content []byte) []models.Event {
|
|
var events []models.Event
|
|
text := string(content)
|
|
|
|
// Parse RESTful Memory info for Warning/Error status
|
|
memEvents := parseMemoryEvents(text)
|
|
events = append(events, memEvents...)
|
|
|
|
return events
|
|
}
|
|
|
|
// MemoryRESTInfo represents the RESTful Memory info structure
|
|
type MemoryRESTInfo struct {
|
|
MemModules []struct {
|
|
MemModID int `json:"mem_mod_id"`
|
|
ConfigStatus int `json:"config_status"`
|
|
MemModSlot string `json:"mem_mod_slot"`
|
|
MemModStatus int `json:"mem_mod_status"`
|
|
MemModSize int `json:"mem_mod_size"`
|
|
MemModType string `json:"mem_mod_type"`
|
|
MemModTechnology string `json:"mem_mod_technology"`
|
|
MemModFrequency int `json:"mem_mod_frequency"`
|
|
MemModCurrentFreq int `json:"mem_mod_current_frequency"`
|
|
MemModVendor string `json:"mem_mod_vendor"`
|
|
MemModPartNum string `json:"mem_mod_part_num"`
|
|
MemModSerial string `json:"mem_mod_serial_num"`
|
|
MemModRanks int `json:"mem_mod_ranks"`
|
|
Status string `json:"status"`
|
|
} `json:"mem_modules"`
|
|
TotalMemoryCount int `json:"total_memory_count"`
|
|
PresentMemoryCount int `json:"present_memory_count"`
|
|
MemTotalMemSize int `json:"mem_total_mem_size"`
|
|
}
|
|
|
|
func parseMemoryInfo(text string, hw *models.HardwareConfig) {
|
|
// Find RESTful Memory info section
|
|
re := regexp.MustCompile(`RESTful Memory info:\s*(\{[\s\S]*?\})\s*RESTful HDD`)
|
|
match := re.FindStringSubmatch(text)
|
|
if match == nil {
|
|
return
|
|
}
|
|
|
|
jsonStr := match[1]
|
|
jsonStr = strings.ReplaceAll(jsonStr, "\n", "")
|
|
|
|
var memInfo MemoryRESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &memInfo); err != nil {
|
|
return
|
|
}
|
|
|
|
// Replace memory data with detailed info from component.log
|
|
hw.Memory = nil
|
|
for _, mem := range memInfo.MemModules {
|
|
hw.Memory = append(hw.Memory, models.MemoryDIMM{
|
|
Slot: mem.MemModSlot,
|
|
Location: mem.MemModSlot,
|
|
Present: mem.MemModStatus == 1 && mem.MemModSize > 0,
|
|
SizeMB: mem.MemModSize * 1024, // Convert GB to MB
|
|
Type: mem.MemModType,
|
|
Technology: strings.TrimSpace(mem.MemModTechnology),
|
|
MaxSpeedMHz: mem.MemModFrequency,
|
|
CurrentSpeedMHz: mem.MemModCurrentFreq,
|
|
Manufacturer: mem.MemModVendor,
|
|
SerialNumber: mem.MemModSerial,
|
|
PartNumber: strings.TrimSpace(mem.MemModPartNum),
|
|
Status: mem.Status,
|
|
Ranks: mem.MemModRanks,
|
|
})
|
|
}
|
|
}
|
|
|
|
// PSURESTInfo represents the RESTful PSU info structure
|
|
type PSURESTInfo struct {
|
|
PowerSupplies []struct {
|
|
ID int `json:"id"`
|
|
Present int `json:"present"`
|
|
VendorID string `json:"vendor_id"`
|
|
Model string `json:"model"`
|
|
SerialNum string `json:"serial_num"`
|
|
PartNum string `json:"part_num"`
|
|
FwVer string `json:"fw_ver"`
|
|
InputType string `json:"input_type"`
|
|
Status string `json:"status"`
|
|
RatedPower int `json:"rated_power"`
|
|
PSInPower int `json:"ps_in_power"`
|
|
PSOutPower int `json:"ps_out_power"`
|
|
PSInVolt float64 `json:"ps_in_volt"`
|
|
PSOutVolt float64 `json:"ps_out_volt"`
|
|
PSUMaxTemp int `json:"psu_max_temperature"`
|
|
} `json:"power_supplies"`
|
|
PresentPowerReading int `json:"present_power_reading"`
|
|
}
|
|
|
|
func parsePSUInfo(text string, hw *models.HardwareConfig) {
|
|
// Find RESTful PSU info section
|
|
re := regexp.MustCompile(`RESTful PSU info:\s*(\{[\s\S]*?\})\s*RESTful Network`)
|
|
match := re.FindStringSubmatch(text)
|
|
if match == nil {
|
|
return
|
|
}
|
|
|
|
jsonStr := match[1]
|
|
jsonStr = strings.ReplaceAll(jsonStr, "\n", "")
|
|
|
|
var psuInfo PSURESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &psuInfo); err != nil {
|
|
return
|
|
}
|
|
|
|
// Clear existing PSU data and populate with RESTful data
|
|
hw.PowerSupply = nil
|
|
for _, psu := range psuInfo.PowerSupplies {
|
|
hw.PowerSupply = append(hw.PowerSupply, models.PSU{
|
|
Slot: fmt.Sprintf("PSU%d", psu.ID),
|
|
Present: psu.Present == 1,
|
|
Model: strings.TrimSpace(psu.Model),
|
|
Vendor: strings.TrimSpace(psu.VendorID),
|
|
WattageW: psu.RatedPower,
|
|
SerialNumber: strings.TrimSpace(psu.SerialNum),
|
|
PartNumber: strings.TrimSpace(psu.PartNum),
|
|
Firmware: psu.FwVer,
|
|
Status: psu.Status,
|
|
InputType: psu.InputType,
|
|
InputPowerW: psu.PSInPower,
|
|
OutputPowerW: psu.PSOutPower,
|
|
InputVoltage: psu.PSInVolt,
|
|
OutputVoltage: psu.PSOutVolt,
|
|
TemperatureC: psu.PSUMaxTemp,
|
|
})
|
|
}
|
|
}
|
|
|
|
// HDDRESTInfo represents the RESTful HDD info structure
|
|
type HDDRESTInfo []struct {
|
|
ID int `json:"id"`
|
|
Present int `json:"present"`
|
|
Enable int `json:"enable"`
|
|
SN string `json:"SN"`
|
|
Model string `json:"model"`
|
|
Capacity int `json:"capacity"`
|
|
Manufacture string `json:"manufacture"`
|
|
Firmware string `json:"firmware"`
|
|
LocationString string `json:"locationstring"`
|
|
CapableSpeed int `json:"capablespeed"`
|
|
}
|
|
|
|
func parseHDDInfo(text string, hw *models.HardwareConfig) {
|
|
// Find RESTful HDD info section
|
|
re := regexp.MustCompile(`RESTful HDD info:\s*(\[[\s\S]*?\])\s*RESTful PSU`)
|
|
match := re.FindStringSubmatch(text)
|
|
if match == nil {
|
|
return
|
|
}
|
|
|
|
jsonStr := match[1]
|
|
jsonStr = strings.ReplaceAll(jsonStr, "\n", "")
|
|
|
|
var hddInfo HDDRESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &hddInfo); err != nil {
|
|
return
|
|
}
|
|
|
|
// Update storage with detailed info (merge with existing data from asset.json)
|
|
hddMap := make(map[string]struct {
|
|
SN string
|
|
Model string
|
|
Firmware string
|
|
Mfr string
|
|
})
|
|
for _, hdd := range hddInfo {
|
|
if hdd.Present == 1 {
|
|
hddMap[hdd.LocationString] = struct {
|
|
SN string
|
|
Model string
|
|
Firmware string
|
|
Mfr string
|
|
}{
|
|
SN: strings.TrimSpace(hdd.SN),
|
|
Model: strings.TrimSpace(hdd.Model),
|
|
Firmware: strings.TrimSpace(hdd.Firmware),
|
|
Mfr: strings.TrimSpace(hdd.Manufacture),
|
|
}
|
|
}
|
|
}
|
|
|
|
// If storage is empty, populate from HDD info
|
|
if len(hw.Storage) == 0 {
|
|
for _, hdd := range hddInfo {
|
|
if hdd.Present != 1 {
|
|
continue
|
|
}
|
|
storType := "HDD"
|
|
model := strings.TrimSpace(hdd.Model)
|
|
if strings.Contains(strings.ToUpper(model), "SSD") || strings.Contains(model, "MZ7") {
|
|
storType = "SSD"
|
|
}
|
|
|
|
iface := "SATA"
|
|
if hdd.CapableSpeed == 12 {
|
|
iface = "SAS"
|
|
}
|
|
|
|
hw.Storage = append(hw.Storage, models.Storage{
|
|
Slot: hdd.LocationString,
|
|
Type: storType,
|
|
Model: model,
|
|
SizeGB: hdd.Capacity,
|
|
SerialNumber: strings.TrimSpace(hdd.SN),
|
|
Manufacturer: extractStorageManufacturer(model),
|
|
Firmware: strings.TrimSpace(hdd.Firmware),
|
|
Interface: iface,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// NetworkAdapterRESTInfo represents the RESTful Network Adapter info structure
|
|
type NetworkAdapterRESTInfo struct {
|
|
SysAdapters []struct {
|
|
ID int `json:"id"`
|
|
Name string `json:"name"`
|
|
Location string `json:"Location"`
|
|
Present int `json:"present"`
|
|
Slot int `json:"slot"`
|
|
VendorID int `json:"vendor_id"`
|
|
DeviceID int `json:"device_id"`
|
|
Vendor string `json:"vendor"`
|
|
Model string `json:"model"`
|
|
FwVer string `json:"fw_ver"`
|
|
Status string `json:"status"`
|
|
SN string `json:"sn"`
|
|
PN string `json:"pn"`
|
|
PortNum int `json:"port_num"`
|
|
PortType string `json:"port_type"`
|
|
Ports []struct {
|
|
ID int `json:"id"`
|
|
MacAddr string `json:"mac_addr"`
|
|
} `json:"ports"`
|
|
} `json:"sys_adapters"`
|
|
}
|
|
|
|
func parseNetworkAdapterInfo(text string, hw *models.HardwareConfig) {
|
|
// Find RESTful Network Adapter info section
|
|
re := regexp.MustCompile(`RESTful Network Adapter info:\s*(\{[\s\S]*?\})\s*RESTful fan`)
|
|
match := re.FindStringSubmatch(text)
|
|
if match == nil {
|
|
return
|
|
}
|
|
|
|
jsonStr := match[1]
|
|
jsonStr = strings.ReplaceAll(jsonStr, "\n", "")
|
|
|
|
var netInfo NetworkAdapterRESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &netInfo); err != nil {
|
|
return
|
|
}
|
|
|
|
hw.NetworkAdapters = nil
|
|
for _, adapter := range netInfo.SysAdapters {
|
|
var macs []string
|
|
for _, port := range adapter.Ports {
|
|
if port.MacAddr != "" {
|
|
macs = append(macs, port.MacAddr)
|
|
}
|
|
}
|
|
|
|
hw.NetworkAdapters = append(hw.NetworkAdapters, models.NetworkAdapter{
|
|
Slot: fmt.Sprintf("Slot %d", adapter.Slot),
|
|
Location: adapter.Location,
|
|
Present: adapter.Present == 1,
|
|
Model: strings.TrimSpace(adapter.Model),
|
|
Vendor: strings.TrimSpace(adapter.Vendor),
|
|
VendorID: adapter.VendorID,
|
|
DeviceID: adapter.DeviceID,
|
|
SerialNumber: strings.TrimSpace(adapter.SN),
|
|
PartNumber: strings.TrimSpace(adapter.PN),
|
|
Firmware: adapter.FwVer,
|
|
PortCount: adapter.PortNum,
|
|
PortType: adapter.PortType,
|
|
MACAddresses: macs,
|
|
Status: adapter.Status,
|
|
})
|
|
}
|
|
}
|
|
|
|
func parseMemoryEvents(text string) []models.Event {
|
|
var events []models.Event
|
|
|
|
// Find RESTful Memory info section
|
|
re := regexp.MustCompile(`RESTful Memory info:\s*(\{[\s\S]*?\})\s*RESTful HDD`)
|
|
match := re.FindStringSubmatch(text)
|
|
if match == nil {
|
|
return events
|
|
}
|
|
|
|
jsonStr := match[1]
|
|
jsonStr = strings.ReplaceAll(jsonStr, "\n", "")
|
|
|
|
var memInfo MemoryRESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &memInfo); err != nil {
|
|
return events
|
|
}
|
|
|
|
// Generate events for memory modules with Warning or Error status
|
|
for _, mem := range memInfo.MemModules {
|
|
if mem.Status == "Warning" || mem.Status == "Error" || mem.Status == "Critical" {
|
|
severity := models.SeverityWarning
|
|
if mem.Status == "Error" || mem.Status == "Critical" {
|
|
severity = models.SeverityCritical
|
|
}
|
|
|
|
description := fmt.Sprintf("Memory module %s: %s", mem.MemModSlot, mem.Status)
|
|
if mem.MemModSize == 0 {
|
|
description = fmt.Sprintf("Memory module %s not detected (capacity 0GB)", mem.MemModSlot)
|
|
}
|
|
|
|
events = append(events, models.Event{
|
|
ID: fmt.Sprintf("mem_%d", mem.MemModID),
|
|
Timestamp: time.Now(),
|
|
Source: "Memory",
|
|
SensorType: "memory",
|
|
SensorName: mem.MemModSlot,
|
|
EventType: "Memory Status",
|
|
Severity: severity,
|
|
Description: description,
|
|
RawData: fmt.Sprintf("Slot: %s, Vendor: %s, P/N: %s, S/N: %s", mem.MemModSlot, mem.MemModVendor, mem.MemModPartNum, mem.MemModSerial),
|
|
})
|
|
}
|
|
}
|
|
|
|
return events
|
|
}
|
|
|
|
// extractComponentFirmware extracts firmware versions from all component data
|
|
func extractComponentFirmware(text string, hw *models.HardwareConfig) {
|
|
// Create a map to track existing firmware entries (avoid duplicates)
|
|
existingFW := make(map[string]bool)
|
|
for _, fw := range hw.Firmware {
|
|
existingFW[fw.DeviceName] = true
|
|
}
|
|
|
|
// HDD firmware is already extracted from asset.json with better names
|
|
// Skip extracting from component.log to avoid duplicates
|
|
|
|
// Extract PSU firmware from RESTful PSU info
|
|
rePSU := regexp.MustCompile(`RESTful PSU info:\s*(\{[\s\S]*?\})\s*RESTful Network`)
|
|
if match := rePSU.FindStringSubmatch(text); match != nil {
|
|
jsonStr := strings.ReplaceAll(match[1], "\n", "")
|
|
var psuInfo PSURESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &psuInfo); err == nil {
|
|
for _, psu := range psuInfo.PowerSupplies {
|
|
if psu.Present == 1 && psu.FwVer != "" {
|
|
fwName := fmt.Sprintf("PSU%d (%s)", psu.ID, psu.Model)
|
|
if !existingFW[fwName] {
|
|
hw.Firmware = append(hw.Firmware, models.FirmwareInfo{
|
|
DeviceName: fwName,
|
|
Version: psu.FwVer,
|
|
})
|
|
existingFW[fwName] = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract Network Adapter firmware from RESTful Network Adapter info
|
|
reNet := regexp.MustCompile(`RESTful Network Adapter info:\s*(\{[\s\S]*?\})\s*RESTful fan`)
|
|
if match := reNet.FindStringSubmatch(text); match != nil {
|
|
jsonStr := strings.ReplaceAll(match[1], "\n", "")
|
|
var netInfo NetworkAdapterRESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &netInfo); err == nil {
|
|
for _, adapter := range netInfo.SysAdapters {
|
|
if adapter.Present == 1 && adapter.FwVer != "" && adapter.FwVer != "NA" {
|
|
fwName := fmt.Sprintf("NIC %s (%s)", adapter.Location, adapter.Model)
|
|
if !existingFW[fwName] {
|
|
hw.Firmware = append(hw.Firmware, models.FirmwareInfo{
|
|
DeviceName: fwName,
|
|
Version: adapter.FwVer,
|
|
})
|
|
existingFW[fwName] = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// DiskBackplaneRESTInfo represents the RESTful diskbackplane info structure
|
|
type DiskBackplaneRESTInfo []struct {
|
|
PortCount int `json:"port_count"`
|
|
DriverCount int `json:"driver_count"`
|
|
Front int `json:"front"`
|
|
BackplaneIndex int `json:"backplane_index"`
|
|
Present int `json:"present"`
|
|
CPLDVersion string `json:"cpld_version"`
|
|
Temperature int `json:"temperature"`
|
|
}
|
|
|
|
func parseDiskBackplaneInfo(text string, hw *models.HardwareConfig) {
|
|
// Find RESTful diskbackplane info section
|
|
re := regexp.MustCompile(`RESTful diskbackplane info:\s*(\[[\s\S]*?\])\s*BMC`)
|
|
match := re.FindStringSubmatch(text)
|
|
if match == nil {
|
|
return
|
|
}
|
|
|
|
jsonStr := match[1]
|
|
jsonStr = strings.ReplaceAll(jsonStr, "\n", "")
|
|
|
|
var backplaneInfo DiskBackplaneRESTInfo
|
|
if err := json.Unmarshal([]byte(jsonStr), &backplaneInfo); err != nil {
|
|
return
|
|
}
|
|
|
|
// Create storage entries based on backplane info
|
|
for _, bp := range backplaneInfo {
|
|
if bp.Present != 1 {
|
|
continue
|
|
}
|
|
|
|
location := "Rear"
|
|
if bp.Front == 1 {
|
|
location = "Front"
|
|
}
|
|
|
|
// Create entries for each port (disk slot)
|
|
for i := 0; i < bp.PortCount; i++ {
|
|
isPresent := i < bp.DriverCount
|
|
|
|
hw.Storage = append(hw.Storage, models.Storage{
|
|
Slot: fmt.Sprintf("%d", i),
|
|
Present: isPresent,
|
|
Location: location,
|
|
BackplaneID: bp.BackplaneIndex,
|
|
Type: "HDD",
|
|
})
|
|
}
|
|
}
|
|
}
|