firehol/netdata

// SPDX-License-Identifier: GPL-3.0-or-later

package megacli

import (
    "bufio"
    "bytes"
    "errors"
    "fmt"
    "strings"
)

type (
    megaAdapter struct {
        number     string
        name       string
        state      string
        physDrives map[string]*megaPhysDrive
    }
    megaPhysDrive struct {
        adapterNumber          string
        number                 string
        wwn                    string
        slotNumber             string
        drivePosition          string
        pdType                 string
        mediaErrorCount        string
        predictiveFailureCount string
    }
)

var adapterStates = []string{
    "optimal",
    "degraded",
    "partially_degraded",
    "failed",
}

func (m *MegaCli) collectPhysDrives(mx map[string]int64) error {
    bs, err := m.exec.physDrivesInfo()
    if err != nil {
        return err
    }

    adapters, err := parsePhysDrivesInfo(bs)
    if err != nil {
        return err
    }
    if len(adapters) == 0 {
        return errors.New("no adapters found")
    }

    var drives int

    for _, ad := range adapters {
        if !m.adapters[ad.number] {
            m.adapters[ad.number] = true
            m.addAdapterCharts(ad)
        }

        px := fmt.Sprintf("adapter_%s_health_state_", ad.number)
        for _, st := range adapterStates {
            mx[px+st] = 0
        }
        st := strings.ReplaceAll(strings.ToLower(ad.state), " ", "_")
        mx[px+st] = 1

        for _, pd := range ad.physDrives {
            if !m.adapters[pd.wwn] {
                m.adapters[pd.wwn] = true
                m.addPhysDriveCharts(pd)
            }
            drives++

            px := fmt.Sprintf("phys_drive_%s_", pd.wwn)

            writeInt(mx, px+"media_error_count", pd.mediaErrorCount)
            writeInt(mx, px+"predictive_failure_count", pd.predictiveFailureCount)
        }
    }

    m.Debugf("found %d adapters, %d physical drives", len(m.adapters), drives)

    return nil
}

func parsePhysDrivesInfo(bs []byte) (map[string]*megaAdapter, error) {
    adapters := make(map[string]*megaAdapter)

    var ad *megaAdapter
    var pd *megaPhysDrive

    sc := bufio.NewScanner(bytes.NewReader(bs))

    for sc.Scan() {
        line := strings.TrimSpace(sc.Text())

        switch {
        case strings.HasPrefix(line, "Adapter #"):
            idx := strings.TrimPrefix(line, "Adapter #")
            ad = &megaAdapter{number: idx, physDrives: make(map[string]*megaPhysDrive)}
            adapters[idx] = ad
        case strings.HasPrefix(line, "Name") && ad != nil:
            ad.name = getColonSepValue(line)
        case strings.HasPrefix(line, "State") && ad != nil:
            ad.state = getColonSepValue(line)
        case strings.HasPrefix(line, "PD:") && ad != nil:
            if parts := strings.Fields(line); len(parts) == 3 {
                idx := parts[1]
                pd = &megaPhysDrive{number: idx, adapterNumber: ad.number}
                ad.physDrives[idx] = pd
            }
        case strings.HasPrefix(line, "Slot Number:") && pd != nil:
            pd.slotNumber = getColonSepValue(line)
        case strings.HasPrefix(line, "Drive's position:") && pd != nil:
            pd.drivePosition = getColonSepValue(line)
        case strings.HasPrefix(line, "WWN:") && pd != nil:
            pd.wwn = getColonSepValue(line)
        case strings.HasPrefix(line, "PD Type:") && pd != nil:
            pd.pdType = getColonSepValue(line)
        case strings.HasPrefix(line, "Media Error Count:") && pd != nil:
            pd.mediaErrorCount = getColonSepNumValue(line)
        case strings.HasPrefix(line, "Predictive Failure Count:") && pd != nil:
            pd.predictiveFailureCount = getColonSepNumValue(line)
        }
    }

    return adapters, nil
}