mirror of
https://github.com/replicatedhq/troubleshoot.git
synced 2026-04-15 07:16:34 +00:00
Gerard NguyenandDiamon Wiggins
f0b8de68ae
* implement refactor for multiple node analyzers --------- Co-authored-by: Diamon Wiggins <38189728+diamonwiggins@users.noreply.github.com>
96 lines
2.6 KiB
Go
96 lines
2.6 KiB
Go
package analyzer
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/pkg/errors"
|
|
troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
|
|
"github.com/replicatedhq/troubleshoot/pkg/collect"
|
|
)
|
|
|
|
type AnalyzeHostIPV4Interfaces struct {
|
|
hostAnalyzer *troubleshootv1beta2.IPV4InterfacesAnalyze
|
|
}
|
|
|
|
func (a *AnalyzeHostIPV4Interfaces) Title() string {
|
|
return hostAnalyzerTitleOrDefault(a.hostAnalyzer.AnalyzeMeta, "IPv4 Interfaces")
|
|
}
|
|
|
|
func (a *AnalyzeHostIPV4Interfaces) IsExcluded() (bool, error) {
|
|
return isExcluded(a.hostAnalyzer.Exclude)
|
|
}
|
|
|
|
func (a *AnalyzeHostIPV4Interfaces) Analyze(
|
|
getCollectedFileContents func(string) ([]byte, error), findFiles getChildCollectedFileContents,
|
|
) ([]*AnalyzeResult, error) {
|
|
result := AnalyzeResult{Title: a.Title()}
|
|
|
|
collectedContents, err := retrieveCollectedContents(
|
|
getCollectedFileContents,
|
|
collect.HostIPV4InterfacesPath,
|
|
collect.NodeInfoBaseDir,
|
|
collect.HostIPV4FileName,
|
|
)
|
|
if err != nil {
|
|
return []*AnalyzeResult{&result}, err
|
|
}
|
|
|
|
results, err := analyzeHostCollectorResults(collectedContents, a.hostAnalyzer.Outcomes, a.CheckCondition, a.Title())
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to analyze IPv4 interfaces")
|
|
}
|
|
|
|
return results, nil
|
|
}
|
|
|
|
func compareHostIPV4InterfacesConditionalToActual(conditional string, ipv4Interfaces []net.Interface) (res bool, err error) {
|
|
parts := strings.Split(conditional, " ")
|
|
if len(parts) != 3 {
|
|
return false, fmt.Errorf("Expected exactly 3 parts in conditional, got %d", len(parts))
|
|
}
|
|
|
|
keyword := parts[0]
|
|
operator := parts[1]
|
|
desired := parts[2]
|
|
|
|
if keyword != "count" {
|
|
return false, fmt.Errorf(`Only supported keyword is "count", got %q`, keyword)
|
|
}
|
|
|
|
desiredInt, err := strconv.ParseInt(desired, 10, 64)
|
|
if err != nil {
|
|
return false, errors.Wrapf(err, "failed to parse %q as int", desired)
|
|
}
|
|
|
|
actualCount := len(ipv4Interfaces)
|
|
|
|
switch operator {
|
|
case "<":
|
|
return actualCount < int(desiredInt), nil
|
|
case "<=":
|
|
return actualCount <= int(desiredInt), nil
|
|
case ">":
|
|
return actualCount > int(desiredInt), nil
|
|
case ">=":
|
|
return actualCount >= int(desiredInt), nil
|
|
case "=", "==", "===":
|
|
return actualCount == int(desiredInt), nil
|
|
}
|
|
|
|
return false, fmt.Errorf("Unknown operator %q. Supported operators are: <, <=, ==, >=, >", operator)
|
|
}
|
|
|
|
func (a *AnalyzeHostIPV4Interfaces) CheckCondition(when string, data []byte) (bool, error) {
|
|
|
|
var ipv4Interfaces []net.Interface
|
|
if err := json.Unmarshal(data, &ipv4Interfaces); err != nil {
|
|
return false, fmt.Errorf("failed to unmarshal data into []net.Interface: %v", err)
|
|
}
|
|
|
|
return compareHostIPV4InterfacesConditionalToActual(when, ipv4Interfaces)
|
|
}
|