mchus/logpile
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases 13 Wiki Activity

Update Inspur parsing and align release docs

Browse Source
This commit is contained in:
Michael Chus
2026-02-15 23:13:47 +03:00
parent c13788132b
commit 514da76ddb
11 changed files with 1231 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

580
internal/exporter/reanimator_converter.go
View File

@@ -4,6 +4,7 @@ import (
"fmt"
"net/url"
"regexp"
"sort"
"strings"
"time"
@@ -27,20 +28,22 @@ func ConvertToReanimator(result *models.AnalysisResult) (*ReanimatorExport, erro
// Determine target host (optional field)
targetHost := inferTargetHost(result.TargetHost, result.Filename)
collectedAt := formatRFC3339(result.CollectedAt)
export := &ReanimatorExport{
Filename: result.Filename,
SourceType: normalizeSourceType(result.SourceType),
Protocol: normalizeProtocol(result.Protocol),
TargetHost: targetHost,
CollectedAt: formatRFC3339(result.CollectedAt),
CollectedAt: collectedAt,
Hardware: ReanimatorHardware{
Board: convertBoard(result.Hardware.BoardInfo),
Firmware: convertFirmware(result.Hardware.Firmware),
CPUs: convertCPUs(result.Hardware.CPUs),
Memory: convertMemory(result.Hardware.Memory),
Storage: convertStorage(result.Hardware.Storage),
PCIeDevices: convertPCIeDevices(result.Hardware),
PowerSupplies: convertPowerSupplies(result.Hardware.PowerSupply),
Firmware: dedupeFirmware(convertFirmware(result.Hardware.Firmware)),
CPUs: dedupeCPUs(convertCPUs(result.Hardware.CPUs, collectedAt)),
Memory: dedupeMemory(convertMemory(result.Hardware.Memory, collectedAt)),
Storage: dedupeStorage(convertStorage(result.Hardware.Storage, collectedAt)),
PCIeDevices: dedupePCIe(convertPCIeDevices(result.Hardware, collectedAt)),
PowerSupplies: dedupePSUs(convertPowerSupplies(result.Hardware.PowerSupply, collectedAt)),
},
}
@@ -83,7 +86,7 @@ func convertFirmware(firmware []models.FirmwareInfo) []ReanimatorFirmware {
}
// convertCPUs converts CPU information to Reanimator format
func convertCPUs(cpus []models.CPU) []ReanimatorCPU {
func convertCPUs(cpus []models.CPU, collectedAt string) []ReanimatorCPU {
if len(cpus) == 0 {
return nil
}
@@ -92,22 +95,41 @@ func convertCPUs(cpus []models.CPU) []ReanimatorCPU {
for _, cpu := range cpus {
manufacturer := inferCPUManufacturer(cpu.Model)
cpuStatus := normalizeStatus(cpu.Status, false)
if strings.TrimSpace(cpu.Status) == "" {
cpuStatus = "Unknown"
}
meta := buildStatusMeta(
cpuStatus,
cpu.StatusCheckedAt,
cpu.StatusChangedAt,
cpu.StatusAtCollect,
cpu.StatusHistory,
cpu.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorCPU{
Socket: cpu.Socket,
Model: cpu.Model,
Cores: cpu.Cores,
Threads: cpu.Threads,
FrequencyMHz: cpu.FrequencyMHz,
MaxFrequencyMHz: cpu.MaxFreqMHz,
Manufacturer: manufacturer,
Status: "Unknown",
Socket: cpu.Socket,
Model: cpu.Model,
Cores: cpu.Cores,
Threads: cpu.Threads,
FrequencyMHz: cpu.FrequencyMHz,
MaxFrequencyMHz: cpu.MaxFreqMHz,
Manufacturer: manufacturer,
Status: cpuStatus,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
return result
}
// convertMemory converts memory modules to Reanimator format
func convertMemory(memory []models.MemoryDIMM) []ReanimatorMemory {
func convertMemory(memory []models.MemoryDIMM, collectedAt string) []ReanimatorMemory {
if len(memory) == 0 {
return nil
}
@@ -123,25 +145,40 @@ func convertMemory(memory []models.MemoryDIMM) []ReanimatorMemory {
}
}
meta := buildStatusMeta(
status,
mem.StatusCheckedAt,
mem.StatusChangedAt,
mem.StatusAtCollect,
mem.StatusHistory,
mem.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorMemory{
Slot: mem.Slot,
Location: mem.Location,
Present: mem.Present,
SizeMB: mem.SizeMB,
Type: mem.Type,
MaxSpeedMHz: mem.MaxSpeedMHz,
CurrentSpeedMHz: mem.CurrentSpeedMHz,
Manufacturer: mem.Manufacturer,
SerialNumber: mem.SerialNumber,
PartNumber: mem.PartNumber,
Status: status,
Slot: mem.Slot,
Location: mem.Location,
Present: mem.Present,
SizeMB: mem.SizeMB,
Type: mem.Type,
MaxSpeedMHz: mem.MaxSpeedMHz,
CurrentSpeedMHz: mem.CurrentSpeedMHz,
Manufacturer: mem.Manufacturer,
SerialNumber: mem.SerialNumber,
PartNumber: mem.PartNumber,
Status: status,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
return result
}
// convertStorage converts storage devices to Reanimator format
func convertStorage(storage []models.Storage) []ReanimatorStorage {
func convertStorage(storage []models.Storage, collectedAt string) []ReanimatorStorage {
if len(storage) == 0 {
return nil
}
@@ -154,29 +191,60 @@ func convertStorage(storage []models.Storage) []ReanimatorStorage {
}
status := inferStorageStatus(stor)
if strings.TrimSpace(stor.Status) != "" {
status = normalizeStatus(stor.Status, false)
}
meta := buildStatusMeta(
status,
stor.StatusCheckedAt,
stor.StatusChangedAt,
stor.StatusAtCollect,
stor.StatusHistory,
stor.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorStorage{
Slot: stor.Slot,
Type: stor.Type,
Model: stor.Model,
SizeGB: stor.SizeGB,
SerialNumber: stor.SerialNumber,
Manufacturer: stor.Manufacturer,
Firmware: stor.Firmware,
Interface: stor.Interface,
Present: stor.Present,
Status: status,
Slot: stor.Slot,
Type: stor.Type,
Model: stor.Model,
SizeGB: stor.SizeGB,
SerialNumber: stor.SerialNumber,
Manufacturer: stor.Manufacturer,
Firmware: stor.Firmware,
Interface: stor.Interface,
Present: stor.Present,
Status: status,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
return result
}
// convertPCIeDevices converts PCIe devices, GPUs, and network adapters to Reanimator format
func convertPCIeDevices(hw *models.HardwareConfig) []ReanimatorPCIe {
func convertPCIeDevices(hw *models.HardwareConfig, collectedAt string) []ReanimatorPCIe {
result := make([]ReanimatorPCIe, 0)
gpuSlots := make(map[string]struct{}, len(hw.GPUs))
for _, gpu := range hw.GPUs {
slot := strings.ToLower(strings.TrimSpace(gpu.Slot))
if slot != "" {
gpuSlots[slot] = struct{}{}
}
}
// Convert regular PCIe devices
for _, pcie := range hw.PCIeDevices {
slot := strings.ToLower(strings.TrimSpace(pcie.Slot))
if _, isDedicatedGPU := gpuSlots[slot]; isDedicatedGPU || isDisplayClass(pcie.DeviceClass) {
// Skip GPU-like PCIe entries to avoid duplicates:
// dedicated GPUs are exported from hw.GPUs with richer metadata.
continue
}
serialNumber := normalizedSerial(pcie.SerialNumber)
// Determine model (prefer PartNumber, fallback to DeviceClass)
@@ -185,21 +253,37 @@ func convertPCIeDevices(hw *models.HardwareConfig) []ReanimatorPCIe {
model = pcie.DeviceClass
}
status := normalizeStatus(pcie.Status, false)
meta := buildStatusMeta(
status,
pcie.StatusCheckedAt,
pcie.StatusChangedAt,
pcie.StatusAtCollect,
pcie.StatusHistory,
pcie.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorPCIe{
Slot: pcie.Slot,
VendorID: pcie.VendorID,
DeviceID: pcie.DeviceID,
BDF: pcie.BDF,
DeviceClass: pcie.DeviceClass,
Manufacturer: pcie.Manufacturer,
Model: model,
LinkWidth: pcie.LinkWidth,
LinkSpeed: pcie.LinkSpeed,
MaxLinkWidth: pcie.MaxLinkWidth,
MaxLinkSpeed: pcie.MaxLinkSpeed,
SerialNumber: serialNumber,
Firmware: "", // PCIeDevice doesn't have firmware in models
Status: "Unknown",
Slot: pcie.Slot,
VendorID: pcie.VendorID,
DeviceID: pcie.DeviceID,
BDF: pcie.BDF,
DeviceClass: pcie.DeviceClass,
Manufacturer: pcie.Manufacturer,
Model: model,
LinkWidth: pcie.LinkWidth,
LinkSpeed: pcie.LinkSpeed,
MaxLinkWidth: pcie.MaxLinkWidth,
MaxLinkSpeed: pcie.MaxLinkSpeed,
SerialNumber: serialNumber,
Firmware: "", // PCIeDevice doesn't have firmware in models
Status: status,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
@@ -210,21 +294,37 @@ func convertPCIeDevices(hw *models.HardwareConfig) []ReanimatorPCIe {
// Determine device class
deviceClass := "DisplayController"
status := normalizeStatus(gpu.Status, false)
meta := buildStatusMeta(
status,
gpu.StatusCheckedAt,
gpu.StatusChangedAt,
gpu.StatusAtCollect,
gpu.StatusHistory,
gpu.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorPCIe{
Slot: gpu.Slot,
VendorID: gpu.VendorID,
DeviceID: gpu.DeviceID,
BDF: gpu.BDF,
DeviceClass: deviceClass,
Manufacturer: gpu.Manufacturer,
Model: gpu.Model,
LinkWidth: gpu.CurrentLinkWidth,
LinkSpeed: gpu.CurrentLinkSpeed,
MaxLinkWidth: gpu.MaxLinkWidth,
MaxLinkSpeed: gpu.MaxLinkSpeed,
SerialNumber: serialNumber,
Firmware: gpu.Firmware,
Status: normalizeStatus(gpu.Status, false),
Slot: gpu.Slot,
VendorID: gpu.VendorID,
DeviceID: gpu.DeviceID,
BDF: gpu.BDF,
DeviceClass: deviceClass,
Manufacturer: gpu.Manufacturer,
Model: gpu.Model,
LinkWidth: gpu.CurrentLinkWidth,
LinkSpeed: gpu.CurrentLinkSpeed,
MaxLinkWidth: gpu.MaxLinkWidth,
MaxLinkSpeed: gpu.MaxLinkSpeed,
SerialNumber: serialNumber,
Firmware: gpu.Firmware,
Status: status,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
@@ -236,29 +336,52 @@ func convertPCIeDevices(hw *models.HardwareConfig) []ReanimatorPCIe {
serialNumber := normalizedSerial(nic.SerialNumber)
status := normalizeStatus(nic.Status, false)
meta := buildStatusMeta(
status,
nic.StatusCheckedAt,
nic.StatusChangedAt,
nic.StatusAtCollect,
nic.StatusHistory,
nic.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorPCIe{
Slot: nic.Slot,
VendorID: nic.VendorID,
DeviceID: nic.DeviceID,
BDF: "",
DeviceClass: "NetworkController",
Manufacturer: nic.Vendor,
Model: nic.Model,
LinkWidth: 0,
LinkSpeed: "",
MaxLinkWidth: 0,
MaxLinkSpeed: "",
SerialNumber: serialNumber,
Firmware: nic.Firmware,
Status: normalizeStatus(nic.Status, false),
Slot: nic.Slot,
VendorID: nic.VendorID,
DeviceID: nic.DeviceID,
BDF: "",
DeviceClass: "NetworkController",
Manufacturer: nic.Vendor,
Model: nic.Model,
LinkWidth: 0,
LinkSpeed: "",
MaxLinkWidth: 0,
MaxLinkSpeed: "",
SerialNumber: serialNumber,
Firmware: nic.Firmware,
Status: status,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
return result
}
func isDisplayClass(deviceClass string) bool {
class := strings.ToLower(strings.TrimSpace(deviceClass))
return strings.Contains(class, "display") ||
strings.Contains(class, "vga") ||
strings.Contains(class, "3d controller")
}
// convertPowerSupplies converts power supplies to Reanimator format
func convertPowerSupplies(psus []models.PSU) []ReanimatorPSU {
func convertPowerSupplies(psus []models.PSU, collectedAt string) []ReanimatorPSU {
if len(psus) == 0 {
return nil
}
@@ -271,26 +394,291 @@ func convertPowerSupplies(psus []models.PSU) []ReanimatorPSU {
}
status := normalizeStatus(psu.Status, false)
meta := buildStatusMeta(
status,
psu.StatusCheckedAt,
psu.StatusChangedAt,
psu.StatusAtCollect,
psu.StatusHistory,
psu.ErrorDescription,
collectedAt,
)
result = append(result, ReanimatorPSU{
Slot: psu.Slot,
Present: psu.Present,
Model: psu.Model,
Vendor: psu.Vendor,
WattageW: psu.WattageW,
SerialNumber: psu.SerialNumber,
PartNumber: psu.PartNumber,
Firmware: psu.Firmware,
Status: status,
InputType: psu.InputType,
InputPowerW: psu.InputPowerW,
OutputPowerW: psu.OutputPowerW,
InputVoltage: psu.InputVoltage,
Slot: psu.Slot,
Present: psu.Present,
Model: psu.Model,
Vendor: psu.Vendor,
WattageW: psu.WattageW,
SerialNumber: psu.SerialNumber,
PartNumber: psu.PartNumber,
Firmware: psu.Firmware,
Status: status,
InputType: psu.InputType,
InputPowerW: psu.InputPowerW,
OutputPowerW: psu.OutputPowerW,
InputVoltage: psu.InputVoltage,
StatusCheckedAt: meta.StatusCheckedAt,
StatusChangedAt: meta.StatusChangedAt,
StatusAtCollect: meta.StatusAtCollection,
StatusHistory: meta.StatusHistory,
ErrorDescription: meta.ErrorDescription,
})
}
return result
}
type convertedStatusMeta struct {
StatusCheckedAt string
StatusChangedAt string
StatusAtCollection *ReanimatorStatusAtCollection
StatusHistory []ReanimatorStatusHistoryEntry
ErrorDescription string
}
func buildStatusMeta(
currentStatus string,
checkedAt time.Time,
changedAt time.Time,
statusAtCollection *models.StatusAtCollection,
history []models.StatusHistoryEntry,
errorDescription string,
collectedAt string,
) convertedStatusMeta {
meta := convertedStatusMeta{
StatusCheckedAt: formatOptionalRFC3339(checkedAt),
StatusChangedAt: formatOptionalRFC3339(changedAt),
ErrorDescription: strings.TrimSpace(errorDescription),
}
convertedHistory := make([]ReanimatorStatusHistoryEntry, 0, len(history))
for _, h := range history {
changed := formatOptionalRFC3339(h.ChangedAt)
if changed == "" {
continue
}
convertedHistory = append(convertedHistory, ReanimatorStatusHistoryEntry{
Status: normalizeStatus(h.Status, true),
ChangedAt: changed,
Details: strings.TrimSpace(h.Details),
})
}
sort.Slice(convertedHistory, func(i, j int) bool {
return convertedHistory[i].ChangedAt < convertedHistory[j].ChangedAt
})
if len(convertedHistory) > 0 {
meta.StatusHistory = convertedHistory
if meta.StatusChangedAt == "" {
meta.StatusChangedAt = convertedHistory[len(convertedHistory)-1].ChangedAt
}
}
if statusAtCollection != nil {
at := formatOptionalRFC3339(statusAtCollection.At)
if at != "" && strings.TrimSpace(statusAtCollection.Status) != "" {
meta.StatusAtCollection = &ReanimatorStatusAtCollection{
Status: normalizeStatus(statusAtCollection.Status, true),
At: at,
}
}
}
if meta.StatusAtCollection == nil && strings.TrimSpace(currentStatus) != "" && collectedAt != "" {
meta.StatusAtCollection = &ReanimatorStatusAtCollection{
Status: currentStatus,
At: collectedAt,
}
}
if meta.StatusCheckedAt == "" && len(meta.StatusHistory) > 0 {
meta.StatusCheckedAt = meta.StatusHistory[len(meta.StatusHistory)-1].ChangedAt
}
if meta.StatusCheckedAt == "" && strings.TrimSpace(currentStatus) != "" && collectedAt != "" {
meta.StatusCheckedAt = collectedAt
}
return meta
}
func formatOptionalRFC3339(t time.Time) string {
if t.IsZero() {
return ""
}
return t.UTC().Format(time.RFC3339)
}
func dedupeFirmware(items []ReanimatorFirmware) []ReanimatorFirmware {
if len(items) < 2 {
return items
}
seen := make(map[string]struct{}, len(items))
result := make([]ReanimatorFirmware, 0, len(items))
for _, item := range items {
key := strings.ToLower(strings.TrimSpace(item.DeviceName))
if key == "" {
key = strings.ToLower(strings.TrimSpace(item.Version))
}
if _, ok := seen[key]; ok {
continue
}
seen[key] = struct{}{}
result = append(result, item)
}
return result
}
func dedupeCPUs(items []ReanimatorCPU) []ReanimatorCPU {
if len(items) < 2 {
return items
}
seen := make(map[int]struct{}, len(items))
result := make([]ReanimatorCPU, 0, len(items))
for _, item := range items {
if _, ok := seen[item.Socket]; ok {
continue
}
seen[item.Socket] = struct{}{}
result = append(result, item)
}
return result
}
func dedupeMemory(items []ReanimatorMemory) []ReanimatorMemory {
if len(items) < 2 {
return items
}
seen := make(map[string]struct{}, len(items))
result := make([]ReanimatorMemory, 0, len(items))
for _, item := range items {
key := strings.ToLower(strings.TrimSpace(item.Slot))
if key == "" {
key = strings.ToLower(strings.TrimSpace(item.Location))
}
if _, ok := seen[key]; ok {
continue
}
seen[key] = struct{}{}
result = append(result, item)
}
return result
}
func dedupeStorage(items []ReanimatorStorage) []ReanimatorStorage {
if len(items) < 2 {
return items
}
seen := make(map[string]struct{}, len(items))
result := make([]ReanimatorStorage, 0, len(items))
for _, item := range items {
key := strings.ToLower(strings.TrimSpace(item.SerialNumber))
if key == "" {
key = "slot:" + strings.ToLower(strings.TrimSpace(item.Slot))
}
if _, ok := seen[key]; ok {
continue
}
seen[key] = struct{}{}
result = append(result, item)
}
return result
}
func dedupePSUs(items []ReanimatorPSU) []ReanimatorPSU {
if len(items) < 2 {
return items
}
seen := make(map[string]struct{}, len(items))
result := make([]ReanimatorPSU, 0, len(items))
for _, item := range items {
key := strings.ToLower(strings.TrimSpace(item.SerialNumber))
if key == "" {
key = "slot:" + strings.ToLower(strings.TrimSpace(item.Slot))
}
if _, ok := seen[key]; ok {
continue
}
seen[key] = struct{}{}
result = append(result, item)
}
return result
}
func dedupePCIe(items []ReanimatorPCIe) []ReanimatorPCIe {
if len(items) < 2 {
return items
}
type scored struct {
item ReanimatorPCIe
score int
idx int
}
byKey := make(map[string]scored, len(items))
order := make([]string, 0, len(items))
for i, item := range items {
key := pcieDedupKey(item)
curr := scored{item: item, score: pcieQualityScore(item), idx: i}
existing, ok := byKey[key]
if !ok {
byKey[key] = curr
order = append(order, key)
continue
}
if curr.score > existing.score {
byKey[key] = curr
}
}
result := make([]ReanimatorPCIe, 0, len(byKey))
for _, key := range order {
result = append(result, byKey[key].item)
}
return result
}
func pcieDedupKey(item ReanimatorPCIe) string {
slot := strings.ToLower(strings.TrimSpace(item.Slot))
serial := strings.ToLower(strings.TrimSpace(item.SerialNumber))
bdf := strings.ToLower(strings.TrimSpace(item.BDF))
if slot != "" {
return "slot:" + slot
}
if serial != "" {
return "sn:" + serial
}
if bdf != "" {
return "bdf:" + bdf
}
return strings.ToLower(strings.TrimSpace(item.DeviceClass)) + "|" + strings.ToLower(strings.TrimSpace(item.Model))
}
func pcieQualityScore(item ReanimatorPCIe) int {
score := 0
if strings.TrimSpace(item.SerialNumber) != "" {
score += 4
}
if strings.TrimSpace(item.Model) != "" && !isGenericPCIeModel(item.Model) {
score += 3
}
status := strings.ToLower(strings.TrimSpace(item.Status))
if status == "ok" || status == "warning" || status == "critical" {
score += 2
}
if strings.TrimSpace(item.BDF) != "" {
score++
}
if strings.EqualFold(strings.TrimSpace(item.DeviceClass), "DisplayController") {
score++
}
return score
}
func isGenericPCIeModel(model string) bool {
switch strings.ToLower(strings.TrimSpace(model)) {
case "", "unknown", "vga", "3d controller", "display controller":
return true
default:
return false
}
}
// inferCPUManufacturer determines CPU manufacturer from model string
func inferCPUManufacturer(model string) string {
upper := strings.ToUpper(model)