Align Reanimator export with updated integration guide

internal/exporter/reanimator_converter.go

@@ -2,6 +2,8 @@ package exporter
 
 import (
 	"fmt"
+	"net/url"
+	"regexp"
 	"strings"
 	"time"
 
@@ -22,25 +24,15 @@ func ConvertToReanimator(result *models.AnalysisResult) (*ReanimatorExport, erro
 		return nil, fmt.Errorf("board serial_number is required for Reanimator export")
 	}
 
-	// Determine target host (required field)
-	targetHost := result.TargetHost
-	if targetHost == "" {
-		// Try to extract from filename (e.g., "redfish://10.10.10.103")
-		if strings.HasPrefix(result.Filename, "redfish://") {
-			targetHost = strings.TrimPrefix(result.Filename, "redfish://")
-		} else if strings.HasPrefix(result.Filename, "ipmi://") {
-			targetHost = strings.TrimPrefix(result.Filename, "ipmi://")
-		} else {
-			targetHost = "unknown"
-		}
-	}
+	// Determine target host (optional field)
+	targetHost := inferTargetHost(result.TargetHost, result.Filename)
 
 	boardSerial := result.Hardware.BoardInfo.SerialNumber
 
 	export := &ReanimatorExport{
 		Filename:    result.Filename,
-		SourceType:  result.SourceType,
-		Protocol:    result.Protocol,
+		SourceType:  normalizeSourceType(result.SourceType),
+		Protocol:    normalizeProtocol(result.Protocol),
 		TargetHost:  targetHost,
 		CollectedAt: formatRFC3339(result.CollectedAt),
 		Hardware: ReanimatorHardware{
@@ -68,8 +60,8 @@ func formatRFC3339(t time.Time) string {
 // convertBoard converts BoardInfo to Reanimator format
 func convertBoard(board models.BoardInfo) ReanimatorBoard {
 	return ReanimatorBoard{
-		Manufacturer: board.Manufacturer,
-		ProductName:  board.ProductName,
+		Manufacturer: normalizeNullableString(board.Manufacturer),
+		ProductName:  normalizeNullableString(board.ProductName),
 		SerialNumber: board.SerialNumber,
 		PartNumber:   board.PartNumber,
 		UUID:         board.UUID,
@@ -110,7 +102,7 @@ func convertCPUs(cpus []models.CPU) []ReanimatorCPU {
 			FrequencyMHz:    cpu.FrequencyMHz,
 			MaxFrequencyMHz: cpu.MaxFreqMHz,
 			Manufacturer:    manufacturer,
-			Status:          "OK", // CPUs are typically OK if detected
+			Status:          "Unknown",
 		})
 	}
 	return result
@@ -124,8 +116,8 @@ func convertMemory(memory []models.MemoryDIMM) []ReanimatorMemory {
 
 	result := make([]ReanimatorMemory, 0, len(memory))
 	for _, mem := range memory {
-		status := mem.Status
-		if status == "" {
+		status := normalizeStatus(mem.Status, true)
+		if strings.TrimSpace(mem.Status) == "" {
 			if mem.Present {
 				status = "OK"
 			} else {
@@ -213,7 +205,7 @@ func convertPCIeDevices(hw *models.HardwareConfig, boardSerial string) []Reanima
 			MaxLinkSpeed: pcie.MaxLinkSpeed,
 			SerialNumber: serialNumber,
 			Firmware:     "", // PCIeDevice doesn't have firmware in models
-			Status:       "OK",
+			Status:       "Unknown",
 		})
 	}
 
@@ -227,9 +219,6 @@ func convertPCIeDevices(hw *models.HardwareConfig, boardSerial string) []Reanima
 
 		// Determine device class
 		deviceClass := "DisplayController"
-		if gpu.Model != "" {
-			deviceClass = gpu.Model
-		}
 
 		result = append(result, ReanimatorPCIe{
 			Slot:         gpu.Slot,
@@ -245,7 +234,7 @@ func convertPCIeDevices(hw *models.HardwareConfig, boardSerial string) []Reanima
 			MaxLinkSpeed: gpu.MaxLinkSpeed,
 			SerialNumber: serialNumber,
 			Firmware:     gpu.Firmware,
-			Status:       inferGPUStatus(gpu.Status),
+			Status:       normalizeStatus(gpu.Status, false),
 		})
 	}
 
@@ -275,7 +264,7 @@ func convertPCIeDevices(hw *models.HardwareConfig, boardSerial string) []Reanima
 			MaxLinkSpeed: "",
 			SerialNumber: serialNumber,
 			Firmware:     nic.Firmware,
-			Status:       inferNetworkStatus(nic.Status),
+			Status:       normalizeStatus(nic.Status, false),
 		})
 	}
 
@@ -295,14 +284,7 @@ func convertPowerSupplies(psus []models.PSU) []ReanimatorPSU {
 			continue
 		}
 
-		status := psu.Status
-		if status == "" {
-			if psu.Present {
-				status = "OK"
-			} else {
-				status = "Empty"
-			}
-		}
+		status := normalizeStatus(psu.Status, false)
 
 		result = append(result, ReanimatorPSU{
 			Slot:         psu.Slot,
@@ -329,28 +311,28 @@ func inferCPUManufacturer(model string) string {
 
 	// Intel patterns
 	if strings.Contains(upper, "INTEL") ||
-	   strings.Contains(upper, "XEON") ||
-	   strings.Contains(upper, "CORE I") {
+		strings.Contains(upper, "XEON") ||
+		strings.Contains(upper, "CORE I") {
 		return "Intel"
 	}
 
 	// AMD patterns
 	if strings.Contains(upper, "AMD") ||
-	   strings.Contains(upper, "EPYC") ||
-	   strings.Contains(upper, "RYZEN") ||
-	   strings.Contains(upper, "THREADRIPPER") {
+		strings.Contains(upper, "EPYC") ||
+		strings.Contains(upper, "RYZEN") ||
+		strings.Contains(upper, "THREADRIPPER") {
 		return "AMD"
 	}
 
 	// ARM patterns
 	if strings.Contains(upper, "ARM") ||
-	   strings.Contains(upper, "CORTEX") {
+		strings.Contains(upper, "CORTEX") {
 		return "ARM"
 	}
 
 	// Ampere patterns
 	if strings.Contains(upper, "AMPERE") ||
-	   strings.Contains(upper, "ALTRA") {
+		strings.Contains(upper, "ALTRA") {
 		return "Ampere"
 	}
 
@@ -373,23 +355,83 @@ func generatePCIeSerialNumber(boardSerial, slot, bdf string) string {
 // inferStorageStatus determines storage device status
 func inferStorageStatus(stor models.Storage) string {
 	if !stor.Present {
-		return "Empty"
+		return "Unknown"
 	}
-	return "OK"
+	return "Unknown"
 }
 
-// inferGPUStatus converts GPU status to Reanimator status
-func inferGPUStatus(status string) string {
-	if status == "" {
-		return "OK"
+func normalizeSourceType(sourceType string) string {
+	normalized := strings.ToLower(strings.TrimSpace(sourceType))
+	switch normalized {
+	case "api", "logfile", "manual":
+		return normalized
+	default:
+		return ""
 	}
-	return status
 }
 
-// inferNetworkStatus converts network adapter status to Reanimator status
-func inferNetworkStatus(status string) string {
-	if status == "" {
-		return "OK"
+func normalizeProtocol(protocol string) string {
+	normalized := strings.ToLower(strings.TrimSpace(protocol))
+	switch normalized {
+	case "redfish", "ipmi", "snmp", "ssh":
+		return normalized
+	default:
+		return ""
 	}
-	return status
+}
+
+func normalizeNullableString(v string) string {
+	trimmed := strings.TrimSpace(v)
+	if strings.EqualFold(trimmed, "NULL") {
+		return ""
+	}
+	return trimmed
+}
+
+func normalizeStatus(status string, allowEmpty bool) string {
+	switch strings.ToLower(strings.TrimSpace(status)) {
+	case "ok":
+		return "OK"
+	case "warning":
+		return "Warning"
+	case "critical":
+		return "Critical"
+	case "unknown":
+		return "Unknown"
+	case "empty":
+		if allowEmpty {
+			return "Empty"
+		}
+		return "Unknown"
+	default:
+		if allowEmpty {
+			return "Unknown"
+		}
+		return "Unknown"
+	}
+}
+
+var (
+	ipv4Regex = regexp.MustCompile(`(?:^|[^0-9])((?:\d{1,3}\.){3}\d{1,3})(?:[^0-9]|$)`)
+)
+
+func inferTargetHost(targetHost, filename string) string {
+	if trimmed := strings.TrimSpace(targetHost); trimmed != "" {
+		return trimmed
+	}
+
+	candidate := strings.TrimSpace(filename)
+	if candidate == "" {
+		return ""
+	}
+
+	if parsed, err := url.Parse(candidate); err == nil && parsed.Hostname() != "" {
+		return parsed.Hostname()
+	}
+
+	if submatches := ipv4Regex.FindStringSubmatch(candidate); len(submatches) > 1 {
+		return submatches[1]
+	}
+
+	return ""
 }