Merge branch 'main' into el-analyze-typo-20220615

Author: edgarlanting

pkg/analyze/analyzer.go

@@ -2,6 +2,7 @@ package analyzer
 
 import (
 	"fmt"
+	"reflect"
 	"strconv"
 
 	"github.com/pkg/errors"
@@ -339,6 +340,36 @@ func Analyze(analyzer *troubleshootv1beta2.Analyze, getFile getCollectedFileCont
 		}
 		return results, nil
 	}
+	if analyzer.YamlCompare != nil {
+		isExcluded, err := isExcluded(analyzer.YamlCompare.Exclude)
+		if err != nil {
+			return nil, err
+		}
+		if isExcluded {
+			return nil, nil
+		}
+		result, err := analyzeYamlCompare(analyzer.YamlCompare, getFile)
+		if err != nil {
+			return nil, err
+		}
+		result.Strict = analyzer.YamlCompare.Strict.BoolOrDefaultFalse()
+		return []*AnalyzeResult{result}, nil
+	}
+	if analyzer.JsonCompare != nil {
+		isExcluded, err := isExcluded(analyzer.JsonCompare.Exclude)
+		if err != nil {
+			return nil, err
+		}
+		if isExcluded {
+			return nil, nil
+		}
+		result, err := analyzeJsonCompare(analyzer.JsonCompare, getFile)
+		if err != nil {
+			return nil, err
+		}
+		result.Strict = analyzer.JsonCompare.Strict.BoolOrDefaultFalse()
+		return []*AnalyzeResult{result}, nil
+	}
 	if analyzer.Postgres != nil {
 		isExcluded, err := isExcluded(analyzer.Postgres.Exclude)
 		if err != nil {
@@ -472,3 +503,25 @@ func Analyze(analyzer *troubleshootv1beta2.Analyze, getFile getCollectedFileCont
 
 	return nil, errors.New("invalid analyzer")
 }
+
+func GetExcludeFlag(analyzer *troubleshootv1beta2.Analyze) *multitype.BoolOrString {
+	if analyzer == nil {
+		return nil
+	}
+
+	reflected := reflect.ValueOf(analyzer).Elem()
+	for i := 0; i < reflected.NumField(); i++ {
+		if reflected.Field(i).IsNil() {
+			continue
+		}
+
+		field := reflect.Indirect(reflected.Field(i)).FieldByName("Exclude")
+		exclude, ok := field.Interface().(*multitype.BoolOrString)
+		if !ok {
+			continue
+		}
+		return exclude
+	}
+
+	return nil
+}

pkg/analyze/analyzer_test.go

@@ -0,0 +1,67 @@
+package analyzer
+
+import (
+	"testing"
+
+	troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
+	"github.com/replicatedhq/troubleshoot/pkg/multitype"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_GetExcludeFlag(t *testing.T) {
+	tests := []struct {
+		name     string
+		analyzer *troubleshootv1beta2.Analyze
+		want     bool
+	}{
+		{
+			name:     "nil case",
+			analyzer: nil,
+			want:     false,
+		},
+		{
+			name: "true is set",
+			analyzer: &troubleshootv1beta2.Analyze{
+				TextAnalyze: &troubleshootv1beta2.TextAnalyze{
+					AnalyzeMeta: troubleshootv1beta2.AnalyzeMeta{
+						Exclude: multitype.FromBool(true),
+					},
+				},
+			},
+			want: true,
+		},
+		{
+			name: "false is set",
+			analyzer: &troubleshootv1beta2.Analyze{
+				ClusterVersion: &troubleshootv1beta2.ClusterVersion{
+					AnalyzeMeta: troubleshootv1beta2.AnalyzeMeta{
+						Exclude: multitype.FromBool(false),
+					},
+				},
+			},
+			want: false,
+		},
+		{
+			name: "nothing is set",
+			analyzer: &troubleshootv1beta2.Analyze{
+				Postgres: &troubleshootv1beta2.DatabaseAnalyze{
+					AnalyzeMeta: troubleshootv1beta2.AnalyzeMeta{},
+				},
+			},
+			want: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			req := require.New(t)
+
+			gotWrapped := GetExcludeFlag(test.analyzer)
+			got, err := gotWrapped.Bool()
+			req.NoError(err)
+
+			assert.Equal(t, test.want, got)
+		})
+	}
+}

pkg/analyze/json_compare.go

@@ -0,0 +1,112 @@
+package analyzer
+
+import (
+	"encoding/json"
+	"path/filepath"
+	"reflect"
+	"strconv"
+
+	"github.com/pkg/errors"
+	troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
+	iutils "github.com/replicatedhq/troubleshoot/pkg/interfaceutils"
+)
+
+func analyzeJsonCompare(analyzer *troubleshootv1beta2.JsonCompare, getCollectedFileContents func(string) ([]byte, error)) (*AnalyzeResult, error) {
+	fullPath := filepath.Join(analyzer.CollectorName, analyzer.FileName)
+	collected, err := getCollectedFileContents(fullPath)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to read collected file name: %s", fullPath)
+	}
+
+	var actual interface{}
+	err = json.Unmarshal(collected, &actual)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to parse collected data as json")
+	}
+
+	if analyzer.Path != "" {
+		actual, err = iutils.GetAtPath(actual, analyzer.Path)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to get object at path: %s", analyzer.Path)
+		}
+	}
+
+	var expected interface{}
+	err = json.Unmarshal([]byte(analyzer.Value), &expected)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to parse expected value as json")
+	}
+
+	title := analyzer.CheckName
+	if title == "" {
+		title = analyzer.CollectorName
+	}
+
+	result := &AnalyzeResult{
+		Title:   title,
+		IconKey: "kubernetes_text_analyze",
+		IconURI: "https://troubleshoot.sh/images/analyzer-icons/text-analyze.svg",
+	}
+
+	equal := reflect.DeepEqual(actual, expected)
+
+	for _, outcome := range analyzer.Outcomes {
+		if outcome.Fail != nil {
+			when := false
+			if outcome.Fail.When != "" {
+				when, err = strconv.ParseBool(outcome.Fail.When)
+				if err != nil {
+					return nil, errors.Wrapf(err, "failed to process when statement: %s", outcome.Fail.When)
+				}
+			}
+
+			if when == equal {
+				result.IsFail = true
+				result.Message = outcome.Fail.Message
+				result.URI = outcome.Fail.URI
+
+				return result, nil
+			}
+		} else if outcome.Warn != nil {
+			when := false
+			if outcome.Warn.When != "" {
+				when, err = strconv.ParseBool(outcome.Warn.When)
+				if err != nil {
+					return nil, errors.Wrapf(err, "failed to process when statement: %s", outcome.Warn.When)
+				}
+			}
+
+			if when == equal {
+				result.IsWarn = true
+				result.Message = outcome.Warn.Message
+				result.URI = outcome.Warn.URI
+
+				return result, nil
+			}
+		} else if outcome.Pass != nil {
+			when := true // default to passing when values are equal
+			if outcome.Pass.When != "" {
+				when, err = strconv.ParseBool(outcome.Pass.When)
+				if err != nil {
+					return nil, errors.Wrapf(err, "failed to process when statement: %s", outcome.Pass.When)
+				}
+			}
+
+			if when == equal {
+				result.IsPass = true
+				result.Message = outcome.Pass.Message
+				result.URI = outcome.Pass.URI
+
+				return result, nil
+			}
+		}
+	}
+
+	return &AnalyzeResult{
+		Title:   title,
+		IconKey: "kubernetes_text_analyze",
+		IconURI: "https://troubleshoot.sh/images/analyzer-icons/text-analyze.svg",
+		IsFail:  true,
+		Message: "Invalid analyzer",
+	}, nil
+}