logpile no longer carries its own archive/vendor parsers or Redfish raw-payload replay/analysis engine. Both now live in git.mchus.pro/reanimator/parser/v13 (already used by the sibling `core` project), reached through parser.NewService().AnalyzeArchivePayload / AnalyzeRedfishRawPayloads. logpile keeps live BMC/Redfish collection, the DB, exporter, server and UI. - Deleted internal/parser/ (interface, registry, archive extraction, all vendor packages), internal/collector/redfish_replay*.go (replay engine, confirmed near-identical to the module's redfish/ package), internal/ingest/ (pure duplicate of the module's Service), internal/models/ (repointed every import to the module's models package instead), and internal/rar5 (only used by the deleted archive extractor). Removed the now-unused third_party/pciids submodule. - internal/collector/redfish.go: Collect() now calls parser.NewService().AnalyzeRedfishRawPayloads(...) at the one place it used to call the local ReplayRedfishFromRawPayloads (an existing "unified tunnel" between live collection and raw import). A deadcode-driven pass then removed ~150 doc-to-model conversion helpers in redfish.go that duplicated the module's redfish/ package and were already unreachable before this change; kept the small generic dedup/scoring helpers the live crawler still calls. - internal/collector/redfishprofile/ stays whole: Collect() depends on it directly for acquisition-time tuning. Its analysis-only methods (ApplyAnalysisProfiles/PostAnalyze) are now dead but left in place rather than splitting the package's single Profile interface. - pciids moved with the module (now a public package there); logpile's live collector and exporter import it from there instead of keeping a local copy. - go.mod: new require on git.mchus.pro/reanimator/parser/v13 v13.0.0 (plain module dependency, not a submodule like reanimator/chart, since this module is independently versioned and shared with core). - bible-local docs rewritten for the new boundary; see ADL-080. See also the companion change in git.mchus.pro/reanimator/parser (tagged v13.0.0): new top-level exports (IsSupportedArchiveFilename/SupportedArchiveExtensions/ ParseInDefaultArchiveLocation/PrivacyScanEnabled) and pciids moved to a public package, both needed to complete this migration. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
216 lines
4.8 KiB
Go
216 lines
4.8 KiB
Go
package exporter
|
|
|
|
import (
|
|
"encoding/csv"
|
|
"encoding/json"
|
|
"io"
|
|
"strings"
|
|
|
|
"git.mchus.pro/reanimator/parser/v13/models"
|
|
)
|
|
|
|
// Exporter handles data export in various formats
|
|
type Exporter struct {
|
|
result *models.AnalysisResult
|
|
}
|
|
|
|
// New creates a new exporter
|
|
func New(result *models.AnalysisResult) *Exporter {
|
|
return &Exporter{result: result}
|
|
}
|
|
|
|
// ExportCSV exports serial numbers to CSV format
|
|
func (e *Exporter) ExportCSV(w io.Writer) error {
|
|
if _, err := w.Write([]byte{0xEF, 0xBB, 0xBF}); err != nil {
|
|
return err
|
|
}
|
|
writer := csv.NewWriter(w)
|
|
writer.Comma = ';'
|
|
defer writer.Flush()
|
|
|
|
// Header
|
|
if err := writer.Write([]string{"Component", "Serial Number", "Manufacturer", "Location"}); err != nil {
|
|
return err
|
|
}
|
|
|
|
if e.result == nil {
|
|
return nil
|
|
}
|
|
|
|
// FRU data
|
|
for _, fru := range e.result.FRU {
|
|
if !hasUsableSerial(fru.SerialNumber) {
|
|
continue
|
|
}
|
|
name := fru.ProductName
|
|
if name == "" {
|
|
name = fru.Description
|
|
}
|
|
if err := writer.Write([]string{
|
|
name,
|
|
fru.SerialNumber,
|
|
fru.Manufacturer,
|
|
fru.PartNumber,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Hardware data
|
|
if e.result.Hardware != nil {
|
|
// Board
|
|
if hasUsableSerial(e.result.Hardware.BoardInfo.SerialNumber) {
|
|
if err := writer.Write([]string{
|
|
e.result.Hardware.BoardInfo.ProductName,
|
|
strings.TrimSpace(e.result.Hardware.BoardInfo.SerialNumber),
|
|
e.result.Hardware.BoardInfo.Manufacturer,
|
|
"Board",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
seenCanonical := make(map[string]struct{})
|
|
for _, dev := range canonicalDevicesForExport(e.result.Hardware) {
|
|
if !hasUsableSerial(dev.SerialNumber) {
|
|
continue
|
|
}
|
|
serial := strings.TrimSpace(dev.SerialNumber)
|
|
seenCanonical[serial] = struct{}{}
|
|
component, manufacturer, location := csvFieldsFromCanonicalDevice(dev)
|
|
if err := writer.Write([]string{component, serial, manufacturer, location}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Legacy network cards
|
|
for _, nic := range e.result.Hardware.NetworkCards {
|
|
if !hasUsableSerial(nic.SerialNumber) {
|
|
continue
|
|
}
|
|
serial := strings.TrimSpace(nic.SerialNumber)
|
|
if _, ok := seenCanonical[serial]; ok {
|
|
continue
|
|
}
|
|
if err := writer.Write([]string{
|
|
nic.Model,
|
|
serial,
|
|
"",
|
|
"Network",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ExportJSON exports all data to JSON format
|
|
func (e *Exporter) ExportJSON(w io.Writer) error {
|
|
encoder := json.NewEncoder(w)
|
|
encoder.SetIndent("", " ")
|
|
return encoder.Encode(e.result)
|
|
}
|
|
|
|
func hasUsableSerial(serial string) bool {
|
|
s := strings.TrimSpace(serial)
|
|
if s == "" {
|
|
return false
|
|
}
|
|
switch strings.ToUpper(s) {
|
|
case "N/A", "NA", "NONE", "NULL", "UNKNOWN", "-":
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
func csvFieldsFromCanonicalDevice(dev models.HardwareDevice) (component, manufacturer, location string) {
|
|
component = firstNonEmptyString(
|
|
dev.Model,
|
|
dev.PartNumber,
|
|
dev.DeviceClass,
|
|
dev.Kind,
|
|
)
|
|
manufacturer = firstNonEmptyString(dev.Manufacturer, inferCSVVendor(dev))
|
|
location = firstNonEmptyString(dev.Location, dev.Slot, dev.BDF, dev.Kind)
|
|
|
|
switch dev.Kind {
|
|
case models.DeviceKindCPU:
|
|
if component == "" {
|
|
component = "CPU"
|
|
}
|
|
if location == "" {
|
|
location = "CPU"
|
|
}
|
|
case models.DeviceKindMemory:
|
|
component = firstNonEmptyString(dev.PartNumber, dev.Model, "Memory")
|
|
case models.DeviceKindPCIe, models.DeviceKindGPU, models.DeviceKindNetwork:
|
|
if location == "" {
|
|
location = firstNonEmptyString(dev.Slot, dev.BDF, "PCIe")
|
|
}
|
|
case models.DeviceKindPSU:
|
|
component = firstNonEmptyString(dev.Model, "Power Supply")
|
|
}
|
|
|
|
return component, manufacturer, location
|
|
}
|
|
|
|
func inferCSVVendor(dev models.HardwareDevice) string {
|
|
switch dev.Kind {
|
|
case models.DeviceKindCPU:
|
|
return ""
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func firstNonEmptyString(values ...string) string {
|
|
for _, value := range values {
|
|
if strings.TrimSpace(value) != "" {
|
|
return strings.TrimSpace(value)
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// ExportLogsCSV writes all recognized events as a semicolon-delimited UTF-8 CSV readable in Excel.
|
|
func ExportLogsCSV(w io.Writer, result *models.AnalysisResult) error {
|
|
if _, err := w.Write([]byte{0xEF, 0xBB, 0xBF}); err != nil {
|
|
return err
|
|
}
|
|
writer := csv.NewWriter(w)
|
|
writer.Comma = ';'
|
|
defer writer.Flush()
|
|
|
|
if err := writer.Write([]string{"timestamp", "source", "severity", "sensor_type", "sensor_name", "event_type", "id", "description", "raw_data"}); err != nil {
|
|
return err
|
|
}
|
|
|
|
if result == nil {
|
|
return nil
|
|
}
|
|
|
|
for _, e := range result.Events {
|
|
ts := ""
|
|
if !e.Timestamp.IsZero() {
|
|
ts = e.Timestamp.UTC().Format("2006-01-02T15:04:05Z")
|
|
}
|
|
if err := writer.Write([]string{
|
|
ts,
|
|
e.Source,
|
|
string(e.Severity),
|
|
e.SensorType,
|
|
e.SensorName,
|
|
e.EventType,
|
|
e.ID,
|
|
e.Description,
|
|
e.RawData,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|