Fix the issues pointed by the internal checks

Adding a proper error handling to fix an improper error throw operations.
Adjusting klog to avoid a possibility for a race condition.

Author: togashidm

.github/e2e/e2e_test.go

@@ -11,6 +11,8 @@ import (
 	"testing"
 	"time"
 
+	"k8s.io/klog/v2"
+
 	"github.com/pkg/errors"
 
 	"github.com/intel/platform-aware-scheduling/telemetry-aware-scheduling/pkg/metrics"
@@ -54,25 +56,25 @@ func init() {
 	}
 	config, err := clientcmd.BuildConfigFromFlags("", *kubeConfigPath)
 	if err != nil {
-		panic(err.Error())
+		klog.Exit(err.Error())
 	}
 
 	// create the clientset
 	cl, err = kubernetes.NewForConfig(config)
 	if err != nil {
-		panic(err.Error())
+		klog.Exit(err.Error())
 	}
 	cm = metrics.NewClient(config)
 
 	tascl, err = tasclient.New(*config, "default")
 	if err != nil {
-		panic(err.Error())
+		klog.Exit(err.Error())
 	}
 	//TODO: Replace the generic timeout with an explicit check for the custom metrics from the API Server which times out after some period
 	err = waitForMetrics(120 * time.Second)
 
 	if err != nil {
-		panic(err.Error())
+		klog.Exit(err.Error())
 	}
 }
 

extender/scheduler.go

@@ -93,6 +93,9 @@ func (m Server) StartServer(port string, certFile string, keyFile string, caFile
 	if unsafe {
 		klog.V(2).InfoS("Extender Listening on HTTP "+port, "component", "extender")
 		err = http.ListenAndServe(":"+port, mx)
+		if err != nil {
+			klog.V(2).InfoS("Listening on HTTP failed: "+err.Error(), "component", "extender")
+		}
 	} else {
 		srv := configureSecureServer(port, caFile)
 		srv.Handler = mx

telemetry-aware-scheduling/cmd/main.go

@@ -51,21 +51,27 @@ func main() {
 //tasController The controller load the TAS policy/strategies and places them into a local cache that is available
 //to all TAS components. It also monitors the current state of policies.
 func tasController(kubeConfig string, syncPeriod string, cache *tascache.AutoUpdatingCache) {
+	defer func() {
+		err := recover()
+		if err != nil {
+			klog.V(2).InfoS("Recovered from runtime error", "component", "controller")
+		}
+	}()
 	kubeClient, clientConfig, err := getkubeClient(kubeConfig)
 	if err != nil {
-		klog.V(2).InfoS("Issue in getting client config: "+err.Error(), "component", "controller")
-		panic(err)
+		klog.V(2).InfoS("Issue in getting client config", "component", "controller")
+		klog.Exit(err.Error())
 	}
 	syncDuration, err := time.ParseDuration(syncPeriod)
 	if err != nil {
-		klog.V(2).InfoS("Sync problems in Parsing: "+err.Error(), "component", "controller")
-		panic(err)
+		klog.V(2).InfoS("Sync problems in Parsing", "component", "controller")
+		klog.Exit(err.Error())
 	}
 	metricsClient := metrics.NewClient(clientConfig)
 	telpolicyClient, _, err := telemetrypolicyclient.NewRest(*clientConfig)
 	if err != nil {
-		klog.V(2).InfoS("Rest client access to telemetrypolicy CRD problem: "+err.Error(), "component", "controller")
-		panic(err)
+		klog.V(2).InfoS("Rest client access to telemetrypolicy CRD problem", "component", "controller")
+		klog.Exit(err.Error())
 	}
 	metricTicker := time.NewTicker(syncDuration)
 	initialData := map[string]interface{}{}

telemetry-aware-scheduling/pkg/cache/mocks.go

@@ -4,6 +4,8 @@ package cache
 import (
 	"time"
 
+	"k8s.io/klog/v2"
+
 	"github.com/intel/platform-aware-scheduling/telemetry-aware-scheduling/pkg/metrics"
 	telemetrypolicy "github.com/intel/platform-aware-scheduling/telemetry-aware-scheduling/pkg/telemetrypolicy/api/v1alpha1"
 	"k8s.io/apimachinery/pkg/api/resource"
@@ -20,9 +22,18 @@ func MockEmptySelfUpdatingCache() ReaderWriter {
 //MockSelfUpdatingCache returns auto updating cache
 func MockSelfUpdatingCache() *AutoUpdatingCache {
 	n := MockEmptySelfUpdatingCache()
-	_ = n.WriteMetric("dummyMetric1", TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}))
-	_ = n.WriteMetric("dummyMetric2", TestNodeMetricCustomInfo([]string{"node 1", "node2"}, []int64{100, 200}))
-	_ = n.WriteMetric("dummyMetric3", TestNodeMetricCustomInfo([]string{"node Z", "node Y"}, []int64{8, 40000000}))
+	err := n.WriteMetric("dummyMetric1", TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30}))
+	if err != nil {
+		klog.InfoS("Unable to create a dummymetric: "+err.Error(), "component", "testing")
+	}
+	err = n.WriteMetric("dummyMetric2", TestNodeMetricCustomInfo([]string{"node 1", "node2"}, []int64{100, 200}))
+	if err != nil {
+		klog.InfoS("Unable to create a dummymetric: "+err.Error(), "component", "testing")
+	}
+	err = n.WriteMetric("dummyMetric3", TestNodeMetricCustomInfo([]string{"node Z", "node Y"}, []int64{8, 40000000}))
+	if err != nil {
+		klog.InfoS("Unable to create a dummymetric: "+err.Error(), "component", "testing")
+	}
 	return n.(*AutoUpdatingCache)
 }
 

telemetry-aware-scheduling/pkg/controller/controller.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
 
 	strategy "github.com/intel/platform-aware-scheduling/telemetry-aware-scheduling/pkg/strategies/core"
 	"github.com/intel/platform-aware-scheduling/telemetry-aware-scheduling/pkg/strategies/deschedule"
@@ -20,11 +21,15 @@ import (
 
 //Run starts the controller watching on the Informer queue and doesnt' stop it until the Done signal is received from context
 func (controller *TelemetryPolicyController) Run(context context.Context) {
-	klog.V(2).InfoS("Watching Telemetry Policies", "component", "controller")
+	log.Print("Watching Telemetry Policies", "component", "controller")
+	defer func() {
+		if err := recover(); err != nil {
+			log.Print("Recovered from runtime error", "component", "controller")
+		}
+	}()
 	_, err := controller.watch(context)
 	if err != nil {
-		klog.V(2).InfoS(err.Error(), "component", "controller")
-		panic(err)
+		log.Panic(err.Error())
 	}
 	<-context.Done()
 }

telemetry-aware-scheduling/pkg/metrics/client_test.go

@@ -29,10 +29,15 @@ var baseTimeStamp = time.Date(2019, time.May, 20, 12, 25, 00, 0, time.UTC)
 //As in NewTestFactory method from kubectl/testing/fake.go
 //Reproduced rather than referenced because of dependency issues.
 func dummyRestClientConfig() *restclient.Config {
+	defer func() {
+		if err := recover(); err != nil {
+			klog.InfoS("Recovered from runtime error", "component", "testing")
+		}
+	}()
 	tmpFile, err := ioutil.TempFile("", "cmdtests_temp")
 	if err != nil {
-		klog.InfoS("Unable to create a fake client config: "+err.Error(), "component", "testing")
-		panic(err)
+		klog.InfoS("Unable to create a fake client config", "component", "testing")
+		klog.Exit(err.Error())
 	}
 	loadingRules := &clientcmd.ClientConfigLoadingRules{
 		Precedence:     []string{tmpFile.Name()},

telemetry-aware-scheduling/pkg/metrics/mocks.go

@@ -16,10 +16,15 @@ import (
 
 //DummyRestClientConfig  Mocks used for testing in the metrics and other packages
 func DummyRestClientConfig() *restclient.Config {
+	defer func() {
+		if err := recover(); err != nil {
+			klog.InfoS("Recovered from runtime error", "component", "testing")
+		}
+	}()
 	tmpFile, err := ioutil.TempFile("", "cmdtests_temp")
 	if err != nil {
-		klog.InfoS("Unable to create a fake client config: "+err.Error(), "component", "testing")
-		panic(err)
+		klog.InfoS("Unable to create a fake client config", "component", "testing")
+		klog.Exit(err.Error())
 	}
 	loadingRules := &clientcmd.ClientConfigLoadingRules{
 		Precedence:     []string{tmpFile.Name()},

telemetry-aware-scheduling/pkg/strategies/core/enforcer.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"fmt"
+	"log"
 	"sync"
 	"time"
 
@@ -121,8 +122,7 @@ func (e *MetricEnforcer) enforceStrategy(strategyType string, cache cache.Reader
 			if enf, ok := str.(Enforceable); ok {
 				_, err := enf.Enforce(e, cache)
 				if err != nil {
-					msg := fmt.Sprintf("Strategy was not enforceable: %v", err)
-					klog.V(2).InfoS(msg, "component", "controller")
+					log.Print("Strategy was not enforceable.", err.Error(), "component", "controller")
 				}
 			}
 		}

telemetry-aware-scheduling/pkg/strategies/dontschedule/strategy_test.go

@@ -33,7 +33,7 @@ func TestDontScheduleStrategy_Violated(t *testing.T) {
 			err := tt.args.cache.WriteMetric("memory", metrics.NodeMetricsInfo{"node-1": {Timestamp: time.Now(), Window: 1, Value: *resource.NewQuantity(10, resource.DecimalSI)}})
 			if err != nil {
 				klog.V(4).InfoS(err.Error(), "component", "testing")
-				panic(err)
+				klog.Exit(err)
 			}
 			if got := tt.d.Violated(tt.args.cache); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Strategy.Violated() = %v, want %v", got, tt.want)