log: replace the pattern log.Error() + os.Exit(1) with log.Fatal() (#…

…1964)

cmd/tnf/claim/compare/compare.go

@@ -112,8 +112,7 @@ func NewCommand() *cobra.Command {
 func claimCompare(_ *cobra.Command, _ []string) error {
 	err := claimCompareFilesfunc(Claim1FilePathFlag, Claim2FilePathFlag)
 	if err != nil {
-		log.Error("Error comparing claim files: %v", err)
-		os.Exit(1)
+		log.Fatal("Error comparing claim files: %v", err)
 	}
 	return nil
 }

cnf-certification-test/lifecycle/suite.go

@@ -17,7 +17,6 @@
 package lifecycle
 
 import (
-	"os"
 	"time"
 
 	"github.com/test-network-function/cnf-certification-test/cnf-certification-test/common"
@@ -666,8 +665,7 @@ func testPodsRecreation(check *checksdb.Check, env *provider.TestEnvironment) {
 
 		err = podrecreation.CordonHelper(nodeName, podrecreation.Uncordon)
 		if err != nil {
-			check.LogError("Error uncordoning the node: %s", nodeName)
-			os.Exit(1) //nolint: gocritic
+			check.LogFatal("Error uncordoning the node: %s", nodeName)
 		}
 	}
 

cnf-certification-test/preflight/suite.go

@@ -18,7 +18,6 @@ package preflight
 
 import (
 	"fmt"
-	"os"
 	"strings"
 
 	"github.com/test-network-function/cnf-certification-test/cnf-certification-test/common"
@@ -98,8 +97,7 @@ func testPreflightOperators(checksGroup *checksdb.ChecksGroup, env *provider.Tes
 		// in-general you are only going to have an operator installed once in a cluster.
 		err := op.SetPreflightResults(env)
 		if err != nil {
-			log.Error("Failed running Preflight on operator %q,  err: %v", op.Name, err)
-			os.Exit(1)
+			log.Fatal("Failed running Preflight on operator %q,  err: %v", op.Name, err)
 		}
 	}
 
@@ -121,8 +119,7 @@ func testPreflightContainers(checksGroup *checksdb.ChecksGroup, env *provider.Te
 	for _, cut := range env.Containers {
 		err := cut.SetPreflightResults(preflightImageCache, env)
 		if err != nil {
-			log.Error("Failed running Preflight on image %q, err: %v", cut.Image, err)
-			os.Exit(1)
+			log.Fatal("Failed running Preflight on image %q, err: %v", cut.Image, err)
 		}
 	}
 

cnf-certification-test/webserver/webserver.go

@@ -264,17 +264,15 @@ func runHandler(w http.ResponseWriter, r *http.Request) {
 
 	tnfConfig, err := os.ReadFile("tnf_config.yml")
 	if err != nil {
-		log.Error("Error reading YAML file: %v", err)
-		os.Exit(1) //nolint:gocritic
+		log.Fatal("Error reading YAML file: %v", err) //nolint:gocritic // exitAfterDefer
 	}
 
 	newData := updateTnf(tnfConfig, &data)
 
 	// Write the modified YAML data back to the file
 	err = os.WriteFile("tnf_config.yml", newData, os.ModePerm)
 	if err != nil {
-		log.Error("Error writing YAML file: %v", err)
-		os.Exit(1)
+		log.Fatal("Error writing YAML file: %v", err)
 	}
 	_ = clientsholder.GetNewClientsHolder(kubeconfigTempFile.Name())
 
@@ -324,8 +322,7 @@ func updateTnf(tnfConfig []byte, data *RequestedData) []byte {
 
 	err := yaml.Unmarshal(tnfConfig, &config)
 	if err != nil {
-		log.Error("Error unmarshalling YAML: %v", err)
-		os.Exit(1)
+		log.Fatal("Error unmarshalling YAML: %v", err)
 	}
 
 	// Modify the configuration
@@ -406,8 +403,7 @@ func updateTnf(tnfConfig []byte, data *RequestedData) []byte {
 	// Serialize the modified config back to YAML format
 	newData, err := yaml.Marshal(&config)
 	if err != nil {
-		log.Error("Error marshaling YAML: %v", err)
-		os.Exit(1)
+		log.Fatal("Error marshaling YAML: %v", err)
 	}
 	return newData
 }

internal/clientsholder/clientsholder.go

@@ -19,7 +19,6 @@ package clientsholder
 import (
 	"errors"
 	"fmt"
-	"os"
 	"time"
 
 	clientconfigv1 "github.com/openshift/client-go/config/clientset/versioned/typed/config/v1"
@@ -152,33 +151,23 @@ func ClearTestClientsHolder() {
 
 // GetClientsHolder returns the singleton ClientsHolder object.
 func GetClientsHolder(filenames ...string) *ClientsHolder {
-	const exitUsage = 2
 	if clientsHolder.ready {
 		return &clientsHolder
 	}
 	if len(filenames) == 0 {
-		errMsg := "Please provide a valid Kubeconfig. Either set the KUBECONFIG environment variable or alternatively copy a kube config to $HOME/.kube/config"
-		log.Error(errMsg)
-		fmt.Fprintf(os.Stderr, "ERROR: %s\n", errMsg)
-		os.Exit(exitUsage)
+		log.Fatal("Please provide a valid Kubeconfig. Either set the KUBECONFIG environment variable or alternatively copy a kube config to $HOME/.kube/config")
 	}
 	clientsHolder, err := newClientsHolder(filenames...)
 	if err != nil {
-		errMsg := fmt.Sprintf("Failed to create k8s clients holder, err: %v", err)
-		log.Error(errMsg)
-		fmt.Fprintf(os.Stderr, "ERROR: %s\n", errMsg)
-		os.Exit(1)
+		log.Fatal("Failed to create k8s clients holder, err: %v", err)
 	}
 	return clientsHolder
 }
 
 func GetNewClientsHolder(kubeconfigFile string) *ClientsHolder {
 	_, err := newClientsHolder(kubeconfigFile)
 	if err != nil {
-		errMsg := fmt.Sprintf("Failed to create k8s clients holder, err: %v", err)
-		log.Error(errMsg)
-		fmt.Fprintf(os.Stderr, "ERROR: %s\n", errMsg)
-		os.Exit(1)
+		log.Fatal("Failed to create k8s clients holder, err: %v", err)
 	}
 
 	return &clientsHolder

internal/log/log.go

@@ -179,8 +179,7 @@ func Logf(logger *Logger, level, format string, args ...any) {
 
 	logLevel, err := parseLevel(level)
 	if err != nil {
-		logger.Error("Error when parsing log level, err: %v", err)
-		os.Exit(1)
+		logger.Fatal("Error when parsing log level, err: %v", err)
 	}
 
 	if !logger.l.Enabled(context.Background(), logLevel) {

main.go

@@ -105,8 +105,7 @@ func main() {
 		log.Info("Running CNF Certification Suite in stand-alone mode")
 		err = certsuite.Run(*flags.LabelsFlag, *flags.OutputDir)
 		if err != nil {
-			log.Error("Failed to run CNF Certification Suite: %v", err)
-			os.Exit(1) //nolint:gocritic // exitAfterDefer
+			log.Fatal("Failed to run CNF Certification Suite: %v", err) //nolint:gocritic // exitAfterDefer
 		}
 	}
 }

pkg/autodiscover/autodiscover.go

@@ -19,7 +19,6 @@ package autodiscover
 import (
 	"context"
 	"errors"
-	"os"
 	"regexp"
 	"time"
 
@@ -132,8 +131,7 @@ func DoAutoDiscover(config *configuration.TestConfiguration) DiscoveredTestData
 	var err error
 	data.StorageClasses, err = getAllStorageClasses(oc.K8sClient.StorageV1())
 	if err != nil {
-		log.Error("Failed to retrieve storageClasses - err: %v", err)
-		os.Exit(1)
+		log.Fatal("Failed to retrieve storageClasses - err: %v", err)
 	}
 
 	podsUnderTestLabelsObjects := createLabels(config.PodsUnderTestLabels)
@@ -144,8 +142,7 @@ func DoAutoDiscover(config *configuration.TestConfiguration) DiscoveredTestData
 
 	data.AllNamespaces, err = getAllNamespaces(oc.K8sClient.CoreV1())
 	if err != nil {
-		log.Error("Cannot get namespaces, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get namespaces, err: %v", err)
 	}
 	data.AllSubscriptions = findSubscriptions(oc.OlmClient, []string{""})
 	data.AllCsvs, err = getAllOperators(oc.OlmClient)
@@ -162,24 +159,21 @@ func DoAutoDiscover(config *configuration.TestConfiguration) DiscoveredTestData
 	data.DebugPods, _ = findPodsByLabels(oc.K8sClient.CoreV1(), debugLabels, debugNS)
 	data.ResourceQuotaItems, err = getResourceQuotas(oc.K8sClient.CoreV1())
 	if err != nil {
-		log.Error("Cannot get resource quotas, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get resource quotas, err: %v", err)
 	}
 	data.PodDisruptionBudgets, err = getPodDisruptionBudgets(oc.K8sClient.PolicyV1(), data.Namespaces)
 	if err != nil {
-		log.Error("Cannot get pod disruption budgets, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get pod disruption budgets, err: %v", err)
 	}
 	data.NetworkPolicies, err = getNetworkPolicies(oc.K8sNetworkingClient)
 	if err != nil {
-		log.Error("Cannot get network policies, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get network policies, err: %v", err)
 	}
 
 	// Get cluster crds
-	data.AllCrds = GetClusterCrdNames()
-	if data.AllCrds == nil {
-		os.Exit(1)
+	data.AllCrds, err = getClusterCrdNames()
+	if err != nil {
+		log.Fatal("Cannot get cluster CRD anmes, err: %v", err)
 	}
 	data.Crds = FindTestCrdNames(data.AllCrds, config.CrdFilters)
 
@@ -190,15 +184,13 @@ func DoAutoDiscover(config *configuration.TestConfiguration) DiscoveredTestData
 
 	openshiftVersion, err := getOpenshiftVersion(oc.OcpClient)
 	if err != nil {
-		log.Error("Failed to get the OpenShift version, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Failed to get the OpenShift version, err: %v", err)
 	}
 
 	data.OpenshiftVersion = openshiftVersion
 	k8sVersion, err := oc.K8sClient.Discovery().ServerVersion()
 	if err != nil {
-		log.Error("Cannot get the K8s version, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get the K8s version, err: %v", err)
 	}
 	data.ValidProtocolNames = config.ValidProtocolNames
 	data.ServicesIgnoreList = config.ServicesIgnoreList
@@ -216,44 +208,37 @@ func DoAutoDiscover(config *configuration.TestConfiguration) DiscoveredTestData
 	// Find ClusterRoleBindings
 	clusterRoleBindings, err := getClusterRoleBindings(oc.K8sClient.RbacV1())
 	if err != nil {
-		log.Error("Cannot get cluster role bindings, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get cluster role bindings, err: %v", err)
 	}
 	data.ClusterRoleBindings = clusterRoleBindings
 	// Find RoleBindings
 	roleBindings, err := getRoleBindings(oc.K8sClient.RbacV1())
 	if err != nil {
-		log.Error("Cannot get role bindings, error: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get role bindings, error: %v", err)
 	}
 	data.RoleBindings = roleBindings
 	// find roles
 	roles, err := getRoles(oc.K8sClient.RbacV1())
 	if err != nil {
-		log.Error("Cannot get roles, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get roles, err: %v", err)
 	}
 	data.Roles = roles
 	data.Hpas = findHpaControllers(oc.K8sClient, data.Namespaces)
 	data.Nodes, err = oc.K8sClient.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
-		log.Error("Cannot get list of nodes, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get list of nodes, err: %v", err)
 	}
 	data.PersistentVolumes, err = getPersistentVolumes(oc.K8sClient.CoreV1())
 	if err != nil {
-		log.Error("Cannot get list of persistent volumes, error: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get list of persistent volumes, error: %v", err)
 	}
 	data.PersistentVolumeClaims, err = getPersistentVolumeClaims(oc.K8sClient.CoreV1())
 	if err != nil {
-		log.Error("Cannot get list of persistent volume claims, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get list of persistent volume claims, err: %v", err)
 	}
 	data.Services, err = getServices(oc.K8sClient.CoreV1(), data.Namespaces, data.ServicesIgnoreList)
 	if err != nil {
-		log.Error("Cannot get list of services, err: %v", err)
-		os.Exit(1)
+		log.Fatal("Cannot get list of services, err: %v", err)
 	}
 
 	data.ExecutedBy = config.ExecutedBy

pkg/autodiscover/autodiscover_crds.go

@@ -17,31 +17,33 @@
 package autodiscover
 
 import (
+	"fmt"
 	"strings"
 
+	"github.com/test-network-function/cnf-certification-test/internal/clientsholder"
 	"github.com/test-network-function/cnf-certification-test/internal/log"
 	"github.com/test-network-function/cnf-certification-test/pkg/configuration"
 
 	"context"
 
 	apiextv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 
-	clientsholder "github.com/test-network-function/cnf-certification-test/internal/clientsholder"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 // getClusterCrdNames returns a list of crd names found in the cluster.
-func GetClusterCrdNames() (crdList []*apiextv1.CustomResourceDefinition) {
+func getClusterCrdNames() ([]*apiextv1.CustomResourceDefinition, error) {
 	oc := clientsholder.GetClientsHolder()
 	crds, err := oc.APIExtClient.ApiextensionsV1().CustomResourceDefinitions().List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
-		log.Error("Unable to get cluster CRDs, err: %v", err)
-		return nil
+		return nil, fmt.Errorf("unable to get cluster CRDs, err: %v", err)
 	}
+
+	var crdList []*apiextv1.CustomResourceDefinition
 	for idx := range crds.Items {
 		crdList = append(crdList, &crds.Items[idx])
 	}
-	return crdList
+	return crdList, nil
 }
 
 // FindTestCrdNames gets a list of CRD names based on configured groups.

pkg/autodiscover/autodiscover_crds_test.go

@@ -125,6 +125,8 @@ func TestGetClusterCrdNames(t *testing.T) {
 	for _, tc := range testCases {
 		_ = clientsholder.GetTestClientsHolder(tc.generated())
 		// Run the function and assert the results
-		assert.Equal(t, tc.expectedTargetCRDs, GetClusterCrdNames())
+		crdNames, err := getClusterCrdNames()
+		assert.Nil(t, err)
+		assert.Equal(t, tc.expectedTargetCRDs, crdNames)
 	}
 }

pkg/autodiscover/autodiscover_scales.go

@@ -2,7 +2,6 @@ package autodiscover
 
 import (
 	"context"
-	"os"
 
 	"github.com/test-network-function/cnf-certification-test/internal/clientsholder"
 	"github.com/test-network-function/cnf-certification-test/internal/log"
@@ -48,8 +47,7 @@ func GetScaleCrUnderTest(namespaces []string, crds []*apiextv1.CustomResourceDef
 			for _, ns := range namespaces {
 				crs, err := dynamicClient.Resource(gvr).Namespace(ns).List(context.TODO(), metav1.ListOptions{})
 				if err != nil {
-					log.Error("Error getting CRs of CRD %q in namespace %q, err: %v", crd.Name, ns, err)
-					os.Exit(1)
+					log.Fatal("Error getting CRs of CRD %q in namespace %q, err: %v", crd.Name, ns, err)
 				}
 
 				if len(crs.Items) > 0 {
@@ -77,8 +75,7 @@ func getCrScaleObjects(crs []unstructured.Unstructured, crd *apiextv1.CustomReso
 		namespace := cr.GetNamespace()
 		crScale, err := clients.ScalingClient.Scales(namespace).Get(context.TODO(), groupResourceSchema, name, metav1.GetOptions{})
 		if err != nil {
-			log.Error("Error while getting the scale of CR=%s (CRD=%s) in namespace %s: %v", name, crd.Name, namespace, err)
-			os.Exit(1)
+			log.Fatal("Error while getting the scale of CR=%s (CRD=%s) in namespace %s: %v", name, crd.Name, namespace, err)
 		}
 
 		scaleObjects = append(scaleObjects, ScaleObject{Scale: crScale, GroupResourceSchema: groupResourceSchema})