map strict flag to analyze result (#551)

* add util functions

* rename func HasStrictAnalyzersFailed

* map strict flag to analyze err result

Author: Pavan Sokke Nagaraj

pkg/preflight/analyze.go

@@ -77,8 +77,10 @@ func doAnalyze(allCollectedData map[string][]byte, analyzers []*troubleshootv1be
 	for _, analyzer := range analyzers {
 		analyzeResult, err := analyze.Analyze(analyzer, getCollectedFileContents, getChildCollectedFileContents)
 		if err != nil {
+			strict, _ := HasStrictAnalyzer(analyzer)
 			analyzeResult = []*analyze.AnalyzeResult{
 				{
+					Strict:  strict,
 					IsFail:  true,
 					Title:   "Analyzer Failed",
 					Message: err.Error(),

pkg/preflight/util.go

@@ -0,0 +1,80 @@
+package preflight
+
+import (
+	"encoding/json"
+
+	"github.com/pkg/errors"
+	troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
+)
+
+// HasStrictAnalyzers - checks and returns true if a preflight's analyzer has strict:true, else false
+func HasStrictAnalyzers(preflight *troubleshootv1beta2.Preflight) (bool, error) {
+	if preflight == nil {
+		return false, nil
+	}
+
+	marshalledAnalyzers, err := json.Marshal(preflight.Spec.Analyzers) // marshall and remove nil Analyzers eg result: "[{\"clusterVersion\":{\"exclude\":\"\",\"strict\":\"false\",\"outcomes\":null}}]"
+	if err != nil {
+		return false, errors.Wrap(err, "failed to marshal analyzers")
+	}
+
+	analyzersMap := []map[string]interface{}{}
+	err = json.Unmarshal(marshalledAnalyzers, &analyzersMap) // Unmarshall again so we can loop over non nil analyzers
+	if err != nil {
+		return false, errors.Wrap(err, "failed to unmarshal analyzers")
+	}
+
+	// analyzerMap will ignore empty Analyzers and loop around Analyzer with data
+	for _, analyzers := range analyzersMap { // for each analyzer: map["clusterVersion": map[string]interface{} ["exclude": "", "strict": "true", "outcomes": nil]
+		return hasStrictAnalyzer(analyzers)
+	}
+	return false, nil
+}
+
+// HasStrictAnalyzers - checks and returns true if a preflight's analyzer has strict:true, else false
+func HasStrictAnalyzer(analyzer *troubleshootv1beta2.Analyze) (bool, error) {
+	marshalledAnalyzer, err := json.Marshal(analyzer)
+	if err != nil {
+		return false, errors.Wrap(err, "error while marshalling analyzer")
+	}
+
+	analyzerMap := make(map[string]interface{})
+	err = json.Unmarshal(marshalledAnalyzer, &analyzerMap) // Unmarshall again so we can loop over non nil analyzers
+	if err != nil {
+		return false, errors.Wrap(err, "failed to unmarshal analyzers")
+	}
+	return hasStrictAnalyzer(analyzerMap)
+}
+
+func hasStrictAnalyzer(analyzerMap map[string]interface{}) (bool, error) {
+	for _, analyzer := range analyzerMap { // for each analyzerMeta: map[string]interface{} ["exclude": "", "strict": "true", "outcomes": nil]
+		marshalledAnalyzer, err := json.Marshal(analyzer)
+		if err != nil {
+			return false, errors.Wrap(err, "error while marshalling analyzer")
+		}
+		// return Analyzer.Strict which can be extracted from AnalyzeMeta
+		analyzeMeta := troubleshootv1beta2.AnalyzeMeta{}
+		err = json.Unmarshal(marshalledAnalyzer, &analyzeMeta)
+		if err != nil {
+			return false, errors.Wrap(err, "error while un-marshalling marshalledAnalyzers")
+		}
+		return analyzeMeta.Strict.BoolOrDefaultFalse(), nil
+	}
+	return false, nil
+}
+
+// HasStrictAnalyzersFailed - checks if preflight analyzer's result is strict:true and isFail:true, then returns true else false
+func HasStrictAnalyzersFailed(preflightResult *UploadPreflightResults) bool {
+	hasStrictAnalyzersFailed := false
+	// if results are empty, treat as failure
+	if preflightResult == nil || len(preflightResult.Results) == 0 {
+		hasStrictAnalyzersFailed = true
+	} else {
+		for _, result := range preflightResult.Results {
+			if result.IsFail && result.Strict {
+				hasStrictAnalyzersFailed = true
+			}
+		}
+	}
+	return hasStrictAnalyzersFailed
+}