607 lines
17 KiB
Go
607 lines
17 KiB
Go
// Package unraid provides parser for Unraid diagnostics archives.
|
|
package unraid
|
|
|
|
import (
|
|
"bufio"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.mchus.pro/mchus/logpile/internal/models"
|
|
"git.mchus.pro/mchus/logpile/internal/parser"
|
|
)
|
|
|
|
// parserVersion - increment when parsing logic changes.
|
|
const parserVersion = "1.0.0"
|
|
|
|
func init() {
|
|
parser.Register(&Parser{})
|
|
}
|
|
|
|
// Parser implements VendorParser for Unraid diagnostics.
|
|
type Parser struct{}
|
|
|
|
func (p *Parser) Name() string { return "Unraid Parser" }
|
|
func (p *Parser) Vendor() string { return "unraid" }
|
|
func (p *Parser) Version() string { return parserVersion }
|
|
|
|
// Detect checks if files contain typical Unraid markers.
|
|
func (p *Parser) Detect(files []parser.ExtractedFile) int {
|
|
confidence := 0
|
|
hasUnraidVersion := false
|
|
hasDiagnosticsDir := false
|
|
hasVarsParity := false
|
|
|
|
for _, f := range files {
|
|
path := strings.ToLower(f.Path)
|
|
content := string(f.Content)
|
|
|
|
// Check for unraid version file
|
|
if strings.Contains(path, "unraid-") && strings.HasSuffix(path, ".txt") {
|
|
hasUnraidVersion = true
|
|
confidence += 40
|
|
}
|
|
|
|
// Check for Unraid-specific directories
|
|
if strings.Contains(path, "diagnostics-") &&
|
|
(strings.Contains(path, "/system/") ||
|
|
strings.Contains(path, "/smart/") ||
|
|
strings.Contains(path, "/config/")) {
|
|
hasDiagnosticsDir = true
|
|
if confidence < 60 {
|
|
confidence += 20
|
|
}
|
|
}
|
|
|
|
// Check file content for Unraid markers
|
|
if strings.Contains(content, "Unraid kernel build") {
|
|
confidence += 50
|
|
}
|
|
|
|
// Check for vars.txt with disk array info
|
|
if strings.Contains(path, "vars.txt") && strings.Contains(content, "[parity]") {
|
|
hasVarsParity = true
|
|
confidence += 30
|
|
}
|
|
|
|
if confidence >= 100 {
|
|
return 100
|
|
}
|
|
}
|
|
|
|
// Boost confidence if we see multiple key indicators together
|
|
if hasUnraidVersion && (hasDiagnosticsDir || hasVarsParity) {
|
|
confidence += 20
|
|
}
|
|
|
|
if confidence > 100 {
|
|
return 100
|
|
}
|
|
return confidence
|
|
}
|
|
|
|
// Parse parses Unraid diagnostics and returns normalized data.
|
|
func (p *Parser) Parse(files []parser.ExtractedFile) (*models.AnalysisResult, error) {
|
|
result := &models.AnalysisResult{
|
|
Events: make([]models.Event, 0),
|
|
FRU: make([]models.FRUInfo, 0),
|
|
Sensors: make([]models.SensorReading, 0),
|
|
Hardware: &models.HardwareConfig{
|
|
Firmware: make([]models.FirmwareInfo, 0),
|
|
CPUs: make([]models.CPU, 0),
|
|
Memory: make([]models.MemoryDIMM, 0),
|
|
Storage: make([]models.Storage, 0),
|
|
},
|
|
}
|
|
|
|
// Track storage by slot to avoid duplicates
|
|
storageBySlot := make(map[string]*models.Storage)
|
|
|
|
// Parse different file types
|
|
for _, f := range files {
|
|
path := strings.ToLower(f.Path)
|
|
content := string(f.Content)
|
|
|
|
switch {
|
|
case strings.Contains(path, "unraid-") && strings.HasSuffix(path, ".txt"):
|
|
parseVersionFile(content, result)
|
|
|
|
case strings.HasSuffix(path, "/system/lscpu.txt") || strings.HasSuffix(path, "\\system\\lscpu.txt"):
|
|
parseLsCPU(content, result)
|
|
|
|
case strings.HasSuffix(path, "/system/motherboard.txt") || strings.HasSuffix(path, "\\system\\motherboard.txt"):
|
|
parseMotherboard(content, result)
|
|
|
|
case strings.HasSuffix(path, "/system/memory.txt") || strings.HasSuffix(path, "\\system\\memory.txt"):
|
|
parseMemory(content, result)
|
|
|
|
case strings.HasSuffix(path, "/system/vars.txt") || strings.HasSuffix(path, "\\system\\vars.txt"):
|
|
parseVarsToMap(content, storageBySlot, result)
|
|
|
|
case strings.Contains(path, "/smart/") && strings.HasSuffix(path, ".txt"):
|
|
parseSMARTFileToMap(content, f.Path, storageBySlot, result)
|
|
|
|
case strings.HasSuffix(path, "/logs/syslog.txt") || strings.HasSuffix(path, "\\logs\\syslog.txt"):
|
|
parseSyslog(content, result)
|
|
}
|
|
}
|
|
|
|
// Convert storage map to slice
|
|
for _, disk := range storageBySlot {
|
|
result.Hardware.Storage = append(result.Hardware.Storage, *disk)
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func parseVersionFile(content string, result *models.AnalysisResult) {
|
|
lines := strings.Split(content, "\n")
|
|
if len(lines) > 0 {
|
|
version := strings.TrimSpace(lines[0])
|
|
if version != "" {
|
|
result.Hardware.Firmware = append(result.Hardware.Firmware, models.FirmwareInfo{
|
|
DeviceName: "Unraid OS",
|
|
Version: version,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseLsCPU(content string, result *models.AnalysisResult) {
|
|
// Normalize line endings
|
|
content = strings.ReplaceAll(content, "\r\n", "\n")
|
|
|
|
var cpu models.CPU
|
|
cpu.Socket = 0 // Default to socket 0
|
|
|
|
// Parse CPU model - handle multiple spaces
|
|
if m := regexp.MustCompile(`(?m)^Model name:\s+(.+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
cpu.Model = strings.TrimSpace(m[1])
|
|
}
|
|
|
|
// Parse CPU(s) - total thread count
|
|
if m := regexp.MustCompile(`(?m)^CPU\(s\):\s+(\d+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
cpu.Threads = parseInt(m[1])
|
|
}
|
|
|
|
// Parse cores per socket
|
|
if m := regexp.MustCompile(`(?m)^Core\(s\) per socket:\s+(\d+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
cpu.Cores = parseInt(m[1])
|
|
}
|
|
|
|
// Parse CPU max MHz
|
|
if m := regexp.MustCompile(`(?m)^CPU max MHz:\s+([\d.]+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
cpu.FrequencyMHz = int(parseFloat(m[1]))
|
|
}
|
|
|
|
// If no max MHz, try current MHz
|
|
if cpu.FrequencyMHz == 0 {
|
|
if m := regexp.MustCompile(`(?m)^CPU MHz:\s+([\d.]+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
cpu.FrequencyMHz = int(parseFloat(m[1]))
|
|
}
|
|
}
|
|
|
|
// Only add if we got at least the model
|
|
if cpu.Model != "" {
|
|
result.Hardware.CPUs = append(result.Hardware.CPUs, cpu)
|
|
}
|
|
}
|
|
|
|
func parseMotherboard(content string, result *models.AnalysisResult) {
|
|
var board models.BoardInfo
|
|
|
|
// Parse manufacturer from dmidecode output
|
|
lines := strings.Split(content, "\n")
|
|
inBIOSSection := false
|
|
|
|
for _, line := range lines {
|
|
trimmed := strings.TrimSpace(line)
|
|
|
|
if strings.Contains(trimmed, "BIOS Information") {
|
|
inBIOSSection = true
|
|
continue
|
|
}
|
|
|
|
if inBIOSSection {
|
|
if strings.HasPrefix(trimmed, "Vendor:") {
|
|
parts := strings.SplitN(trimmed, ":", 2)
|
|
if len(parts) == 2 {
|
|
board.Manufacturer = strings.TrimSpace(parts[1])
|
|
}
|
|
} else if strings.HasPrefix(trimmed, "Version:") {
|
|
parts := strings.SplitN(trimmed, ":", 2)
|
|
if len(parts) == 2 {
|
|
biosVersion := strings.TrimSpace(parts[1])
|
|
result.Hardware.Firmware = append(result.Hardware.Firmware, models.FirmwareInfo{
|
|
DeviceName: "System BIOS",
|
|
Version: biosVersion,
|
|
})
|
|
}
|
|
} else if strings.HasPrefix(trimmed, "Release Date:") {
|
|
// Could extract BIOS date if needed
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract product name from first line
|
|
if len(lines) > 0 {
|
|
firstLine := strings.TrimSpace(lines[0])
|
|
if firstLine != "" {
|
|
board.ProductName = firstLine
|
|
}
|
|
}
|
|
|
|
result.Hardware.BoardInfo = board
|
|
}
|
|
|
|
func parseMemory(content string, result *models.AnalysisResult) {
|
|
// Parse memory from free output
|
|
// Example: Mem: 50Gi 11Gi 1.4Gi 565Mi 39Gi 39Gi
|
|
if m := regexp.MustCompile(`(?m)^Mem:\s+(\d+(?:\.\d+)?)(Ki|Mi|Gi|Ti)`).FindStringSubmatch(content); len(m) >= 3 {
|
|
size := parseFloat(m[1])
|
|
unit := m[2]
|
|
|
|
var sizeMB int
|
|
switch unit {
|
|
case "Ki":
|
|
sizeMB = int(size / 1024)
|
|
case "Mi":
|
|
sizeMB = int(size)
|
|
case "Gi":
|
|
sizeMB = int(size * 1024)
|
|
case "Ti":
|
|
sizeMB = int(size * 1024 * 1024)
|
|
}
|
|
|
|
if sizeMB > 0 {
|
|
result.Hardware.Memory = append(result.Hardware.Memory, models.MemoryDIMM{
|
|
Slot: "system",
|
|
Present: true,
|
|
SizeMB: sizeMB,
|
|
Type: "DRAM",
|
|
Status: "ok",
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseVarsToMap(content string, storageBySlot map[string]*models.Storage, result *models.AnalysisResult) {
|
|
// Normalize line endings
|
|
content = strings.ReplaceAll(content, "\r\n", "\n")
|
|
|
|
// Parse PHP-style array from vars.txt
|
|
// Extract only the first "disks" section to avoid duplicates
|
|
disksStart := strings.Index(content, "disks\n(")
|
|
if disksStart == -1 {
|
|
return
|
|
}
|
|
|
|
// Find the end of this disks array (look for next top-level key or end)
|
|
remaining := content[disksStart:]
|
|
endPattern := regexp.MustCompile(`(?m)^[a-z_]+\n\(`)
|
|
endMatches := endPattern.FindAllStringIndex(remaining, -1)
|
|
|
|
var disksSection string
|
|
if len(endMatches) > 1 {
|
|
// Use second match as end (first match is "disks" itself)
|
|
disksSection = remaining[:endMatches[1][0]]
|
|
} else {
|
|
disksSection = remaining
|
|
}
|
|
|
|
// Look for disk entries within this section only
|
|
diskRe := regexp.MustCompile(`(?m)^\s+\[(disk\d+|parity|cache\d*)\]\s+=>\s+Array`)
|
|
matches := diskRe.FindAllStringSubmatch(disksSection, -1)
|
|
|
|
seen := make(map[string]bool)
|
|
for _, match := range matches {
|
|
if len(match) < 2 {
|
|
continue
|
|
}
|
|
diskName := match[1]
|
|
|
|
// Skip if already processed
|
|
if seen[diskName] {
|
|
continue
|
|
}
|
|
seen[diskName] = true
|
|
|
|
// Find the section for this disk
|
|
diskSection := extractDiskSection(disksSection, diskName)
|
|
if diskSection == "" {
|
|
continue
|
|
}
|
|
|
|
var disk models.Storage
|
|
disk.Slot = diskName
|
|
|
|
// Parse disk properties
|
|
if m := regexp.MustCompile(`\[device\]\s*=>\s*(\w+)`).FindStringSubmatch(diskSection); len(m) == 2 {
|
|
disk.Interface = "SATA (" + m[1] + ")"
|
|
}
|
|
|
|
if m := regexp.MustCompile(`\[id\]\s*=>\s*([^\n]+)`).FindStringSubmatch(diskSection); len(m) == 2 {
|
|
idValue := strings.TrimSpace(m[1])
|
|
// Only use if it's not empty or a placeholder
|
|
if idValue != "" && !strings.Contains(idValue, "=>") {
|
|
disk.Model = idValue
|
|
}
|
|
}
|
|
|
|
if m := regexp.MustCompile(`\[size\]\s*=>\s*(\d+)`).FindStringSubmatch(diskSection); len(m) == 2 {
|
|
sizeKB := parseInt(m[1])
|
|
if sizeKB > 0 {
|
|
disk.SizeGB = sizeKB / (1024 * 1024) // Convert KB to GB
|
|
}
|
|
}
|
|
|
|
if m := regexp.MustCompile(`\[temp\]\s*=>\s*(\d+)`).FindStringSubmatch(diskSection); len(m) == 2 {
|
|
temp := parseInt(m[1])
|
|
if temp > 0 {
|
|
result.Sensors = append(result.Sensors, models.SensorReading{
|
|
Name: diskName + "_temp",
|
|
Type: "temperature",
|
|
Value: float64(temp),
|
|
Unit: "C",
|
|
Status: getTempStatus(temp),
|
|
RawValue: strconv.Itoa(temp),
|
|
})
|
|
}
|
|
}
|
|
|
|
if m := regexp.MustCompile(`\[fsType\]\s*=>\s*(\w+)`).FindStringSubmatch(diskSection); len(m) == 2 {
|
|
fsType := m[1]
|
|
if fsType != "" && fsType != "auto" {
|
|
disk.Type = fsType
|
|
}
|
|
}
|
|
|
|
disk.Present = true
|
|
|
|
// Only add/merge disks with meaningful data
|
|
if disk.Model != "" && disk.SizeGB > 0 {
|
|
// Check if we already have this disk from SMART files
|
|
if existing, ok := storageBySlot[diskName]; ok {
|
|
// Merge vars.txt data into existing entry, preferring SMART data
|
|
if existing.Model == "" && disk.Model != "" {
|
|
existing.Model = disk.Model
|
|
}
|
|
if existing.SizeGB == 0 && disk.SizeGB > 0 {
|
|
existing.SizeGB = disk.SizeGB
|
|
}
|
|
if existing.Type == "" && disk.Type != "" {
|
|
existing.Type = disk.Type
|
|
}
|
|
if existing.Interface == "" && disk.Interface != "" {
|
|
existing.Interface = disk.Interface
|
|
}
|
|
// vars.txt doesn't have serial/firmware, so don't overwrite from SMART
|
|
} else {
|
|
// New disk not in SMART data
|
|
storageBySlot[diskName] = &disk
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func extractDiskSection(content, diskName string) string {
|
|
// Find the start of this disk's array section
|
|
startPattern := regexp.MustCompile(`(?m)^\s+\[` + regexp.QuoteMeta(diskName) + `\]\s+=>\s+Array\s*\n\s+\(`)
|
|
startIdx := startPattern.FindStringIndex(content)
|
|
if startIdx == nil {
|
|
return ""
|
|
}
|
|
|
|
// Find the end (next disk or end of disks array)
|
|
endPattern := regexp.MustCompile(`(?m)^\s+\)`)
|
|
remainingContent := content[startIdx[1]:]
|
|
endIdx := endPattern.FindStringIndex(remainingContent)
|
|
|
|
if endIdx == nil {
|
|
return remainingContent
|
|
}
|
|
|
|
return remainingContent[:endIdx[0]]
|
|
}
|
|
|
|
func parseSMARTFileToMap(content, filePath string, storageBySlot map[string]*models.Storage, result *models.AnalysisResult) {
|
|
// Extract disk name from filename
|
|
// Example: ST4000NM000B-2TF100_WX103EC9-20260205-2333 disk1 (sdi).txt
|
|
diskName := ""
|
|
if m := regexp.MustCompile(`(disk\d+|parity|cache\d*)`).FindStringSubmatch(filePath); len(m) > 0 {
|
|
diskName = m[1]
|
|
}
|
|
if diskName == "" {
|
|
return
|
|
}
|
|
|
|
var disk models.Storage
|
|
disk.Slot = diskName
|
|
|
|
// Parse device model
|
|
if m := regexp.MustCompile(`(?m)^Device Model:\s+(.+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
disk.Model = strings.TrimSpace(m[1])
|
|
}
|
|
|
|
// Parse serial number
|
|
if m := regexp.MustCompile(`(?m)^Serial Number:\s+(.+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
disk.SerialNumber = strings.TrimSpace(m[1])
|
|
}
|
|
|
|
// Parse firmware version
|
|
if m := regexp.MustCompile(`(?m)^Firmware Version:\s+(.+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
disk.Firmware = strings.TrimSpace(m[1])
|
|
}
|
|
|
|
// Parse capacity
|
|
if m := regexp.MustCompile(`(?m)^User Capacity:\s+([\d,]+)\s+bytes`).FindStringSubmatch(content); len(m) == 2 {
|
|
capacityStr := strings.ReplaceAll(m[1], ",", "")
|
|
if capacity, err := strconv.ParseInt(capacityStr, 10, 64); err == nil {
|
|
disk.SizeGB = int(capacity / 1_000_000_000)
|
|
}
|
|
}
|
|
|
|
// Parse rotation rate
|
|
if m := regexp.MustCompile(`(?m)^Rotation Rate:\s+(.+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
rateStr := strings.TrimSpace(m[1])
|
|
if strings.Contains(strings.ToLower(rateStr), "solid state") {
|
|
disk.Type = "ssd"
|
|
} else {
|
|
disk.Type = "hdd"
|
|
}
|
|
}
|
|
|
|
// Parse SATA version for interface
|
|
if m := regexp.MustCompile(`(?m)^SATA Version is:\s+(.+?)(?:,|$)`).FindStringSubmatch(content); len(m) == 2 {
|
|
disk.Interface = strings.TrimSpace(m[1])
|
|
}
|
|
|
|
// Parse SMART health
|
|
if m := regexp.MustCompile(`(?m)^SMART overall-health self-assessment test result:\s+(.+)$`).FindStringSubmatch(content); len(m) == 2 {
|
|
health := strings.TrimSpace(m[1])
|
|
if !strings.EqualFold(health, "PASSED") {
|
|
result.Events = append(result.Events, models.Event{
|
|
Timestamp: time.Now(),
|
|
Source: "SMART",
|
|
EventType: "Disk Health",
|
|
Severity: models.SeverityWarning,
|
|
Description: "SMART health check failed for " + diskName,
|
|
RawData: health,
|
|
})
|
|
}
|
|
}
|
|
|
|
disk.Present = true
|
|
|
|
// Only add/merge if we got meaningful data
|
|
if disk.Model != "" || disk.SerialNumber != "" {
|
|
// Check if we already have this disk from vars.txt
|
|
if existing, ok := storageBySlot[diskName]; ok {
|
|
// Merge SMART data into existing entry
|
|
if existing.Model == "" && disk.Model != "" {
|
|
existing.Model = disk.Model
|
|
}
|
|
if existing.SerialNumber == "" && disk.SerialNumber != "" {
|
|
existing.SerialNumber = disk.SerialNumber
|
|
}
|
|
if existing.Firmware == "" && disk.Firmware != "" {
|
|
existing.Firmware = disk.Firmware
|
|
}
|
|
if existing.SizeGB == 0 && disk.SizeGB > 0 {
|
|
existing.SizeGB = disk.SizeGB
|
|
}
|
|
if existing.Type == "" && disk.Type != "" {
|
|
existing.Type = disk.Type
|
|
}
|
|
if existing.Interface == "" && disk.Interface != "" {
|
|
existing.Interface = disk.Interface
|
|
}
|
|
} else {
|
|
// New disk not in vars.txt
|
|
storageBySlot[diskName] = &disk
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseSyslog(content string, result *models.AnalysisResult) {
|
|
scanner := bufio.NewScanner(strings.NewReader(content))
|
|
scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
|
|
lineCount := 0
|
|
maxLines := 100 // Limit parsing to avoid too many events
|
|
|
|
for scanner.Scan() && lineCount < maxLines {
|
|
line := scanner.Text()
|
|
if strings.TrimSpace(line) == "" {
|
|
continue
|
|
}
|
|
|
|
// Parse syslog line
|
|
// Example: Feb 5 23:33:01 box3 kernel: Linux version 6.12.54-Unraid
|
|
timestamp, message, severity := parseSyslogLine(line)
|
|
|
|
result.Events = append(result.Events, models.Event{
|
|
Timestamp: timestamp,
|
|
Source: "syslog",
|
|
EventType: "System Log",
|
|
Severity: severity,
|
|
Description: message,
|
|
RawData: line,
|
|
})
|
|
|
|
lineCount++
|
|
}
|
|
|
|
if err := scanner.Err(); err != nil {
|
|
result.Events = append(result.Events, models.Event{
|
|
Timestamp: time.Now(),
|
|
Source: "syslog",
|
|
EventType: "System Log",
|
|
Severity: models.SeverityWarning,
|
|
Description: "syslog scan error",
|
|
RawData: err.Error(),
|
|
})
|
|
}
|
|
}
|
|
|
|
func parseSyslogLine(line string) (time.Time, string, models.Severity) {
|
|
// Simple syslog parser
|
|
// Format: Feb 5 23:33:01 hostname process[pid]: message
|
|
timestamp := time.Now()
|
|
message := line
|
|
severity := models.SeverityInfo
|
|
|
|
// Try to parse timestamp
|
|
syslogRe := regexp.MustCompile(`^(\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})\s+\S+\s+(.+)$`)
|
|
if m := syslogRe.FindStringSubmatch(line); len(m) == 3 {
|
|
timeStr := m[1]
|
|
message = m[2]
|
|
|
|
// Parse timestamp (add current year)
|
|
year := time.Now().Year()
|
|
if ts, err := time.Parse("Jan 2 15:04:05 2006", timeStr+" "+strconv.Itoa(year)); err == nil {
|
|
timestamp = ts
|
|
}
|
|
}
|
|
|
|
// Classify severity
|
|
lowerMsg := strings.ToLower(message)
|
|
switch {
|
|
case strings.Contains(lowerMsg, "panic"),
|
|
strings.Contains(lowerMsg, "fatal"),
|
|
strings.Contains(lowerMsg, "critical"):
|
|
severity = models.SeverityCritical
|
|
|
|
case strings.Contains(lowerMsg, "error"),
|
|
strings.Contains(lowerMsg, "warning"),
|
|
strings.Contains(lowerMsg, "failed"):
|
|
severity = models.SeverityWarning
|
|
|
|
default:
|
|
severity = models.SeverityInfo
|
|
}
|
|
|
|
return timestamp, message, severity
|
|
}
|
|
|
|
func getTempStatus(temp int) string {
|
|
switch {
|
|
case temp >= 60:
|
|
return "critical"
|
|
case temp >= 50:
|
|
return "warning"
|
|
default:
|
|
return "ok"
|
|
}
|
|
}
|
|
|
|
func parseInt(s string) int {
|
|
v, _ := strconv.Atoi(strings.TrimSpace(s))
|
|
return v
|
|
}
|
|
|
|
func parseFloat(s string) float64 {
|
|
v, _ := strconv.ParseFloat(strings.TrimSpace(s), 64)
|
|
return v
|
|
}
|