Use b.Fatal instead of klog.Fatal in scheduler perf tests

The test tool doesn't work properly with klog.Fatal

Signed-off-by: Aldo Culquicondor <acondor@google.com>

test/integration/scheduler_perf/scheduler_perf_test.go

@@ -111,7 +111,10 @@ type testDataCollector interface {
 
 func BenchmarkPerfScheduling(b *testing.B) {
 	dataItems := DataItems{Version: "v1"}
-	tests := getSimpleTestCases(configFile)
+	tests, err := parseTestCases(configFile)
+	if err != nil {
+		b.Fatal(err)
+	}
 
 	for _, test := range tests {
 		name := fmt.Sprintf("%v/%vNodes/%vInitPods/%vPodsToSchedule", test.Desc, test.Nodes.Num, test.InitPods.Num, test.PodsToSchedule.Num)
@@ -131,14 +134,21 @@ func perfScheduling(test testCase, b *testing.B) []DataItem {
 	finalFunc, podInformer, clientset := mustSetupScheduler()
 	defer finalFunc()
 
-	nodePreparer := getNodePreparer(test.Nodes, clientset)
+	nodePreparer, err := getNodePreparer(test.Nodes, clientset)
+	if err != nil {
+		b.Fatal(err)
+	}
 	if err := nodePreparer.PrepareNodes(); err != nil {
-		klog.Fatalf("%v", err)
+		b.Fatal(err)
 	}
 	defer nodePreparer.CleanupNodes()
 
-	createPods(setupNamespace, test.InitPods, clientset)
+	if err := createPods(setupNamespace, test.InitPods, clientset); err != nil {
-	waitNumPodsScheduled(test.InitPods.Num, podInformer)
+		b.Fatal(err)
+	}
+	if err := waitNumPodsScheduled(b, test.InitPods.Num, podInformer); err != nil {
+		b.Fatal(err)
+	}
 
 	// start benchmark
 	b.ResetTimer()
@@ -151,8 +161,12 @@ func perfScheduling(test testCase, b *testing.B) []DataItem {
 	}
 
 	// Schedule the main workload
-	createPods(testNamespace, test.PodsToSchedule, clientset)
+	if err := createPods(testNamespace, test.PodsToSchedule, clientset); err != nil {
-	waitNumPodsScheduled(test.InitPods.Num+test.PodsToSchedule.Num, podInformer)
+		b.Fatal(err)
+	}
+	if err := waitNumPodsScheduled(b, test.InitPods.Num+test.PodsToSchedule.Num, podInformer); err != nil {
+		b.Fatal(err)
+	}
 
 	close(stopCh)
 	// Note: without this line we're taking the overhead of defer() into account.
@@ -165,18 +179,19 @@ func perfScheduling(test testCase, b *testing.B) []DataItem {
 	return dataItems
 }
 
-func waitNumPodsScheduled(num int, podInformer coreinformers.PodInformer) {
+func waitNumPodsScheduled(b *testing.B, num int, podInformer coreinformers.PodInformer) error {
 	for {
 		scheduled, err := getScheduledPods(podInformer)
 		if err != nil {
-			klog.Fatalf("%v", err)
+			return err
 		}
 		if len(scheduled) >= num {
 			break
 		}
-		klog.Infof("got %d existing pods, required: %d", len(scheduled), num)
+		klog.Infof("%s: got %d existing pods, required: %d", b.Name(), len(scheduled), num)
 		time.Sleep(1 * time.Second)
 	}
+	return nil
 }
 
 func getTestDataCollectors(tc testCase, podInformer coreinformers.PodInformer, b *testing.B) []testDataCollector {
@@ -189,7 +204,7 @@ func getTestDataCollectors(tc testCase, podInformer coreinformers.PodInformer, b
 	return collectors
 }
 
-func getNodePreparer(nc nodeCase, clientset clientset.Interface) testutils.TestNodePreparer {
+func getNodePreparer(nc nodeCase, clientset clientset.Interface) (testutils.TestNodePreparer, error) {
 	var nodeStrategy testutils.PrepareNodeStrategy = &testutils.TrivialNodePrepareStrategy{}
 	if nc.NodeAllocatableStrategy != nil {
 		nodeStrategy = nc.NodeAllocatableStrategy
@@ -200,44 +215,63 @@ func getNodePreparer(nc nodeCase, clientset clientset.Interface) testutils.TestN
 	}
 
 	if nc.NodeTemplatePath != nil {
+		node, err := getNodeSpecFromFile(nc.NodeTemplatePath)
+		if err != nil {
+			return nil, err
+		}
 		return framework.NewIntegrationTestNodePreparerWithNodeSpec(
 			clientset,
 			[]testutils.CountToStrategy{{Count: nc.Num, Strategy: nodeStrategy}},
-			getNodeSpecFromFile(nc.NodeTemplatePath),
+			node,
-		)
+		), nil
 	}
 	return framework.NewIntegrationTestNodePreparer(
 		clientset,
 		[]testutils.CountToStrategy{{Count: nc.Num, Strategy: nodeStrategy}},
 		"scheduler-perf-",
-	)
+	), nil
 }
 
-func createPods(ns string, pc podCase, clientset clientset.Interface) {
+func createPods(ns string, pc podCase, clientset clientset.Interface) error {
-	strategy := getPodStrategy(pc)
+	strategy, err := getPodStrategy(pc)
+	if err != nil {
+		return err
+	}
 	config := testutils.NewTestPodCreatorConfig()
 	config.AddStrategy(ns, pc.Num, strategy)
 	podCreator := testutils.NewTestPodCreator(clientset, config)
-	podCreator.CreatePods()
+	return podCreator.CreatePods()
 }
 
-func getPodStrategy(pc podCase) testutils.TestPodCreateStrategy {
+func getPodStrategy(pc podCase) (testutils.TestPodCreateStrategy, error) {
 	basePod := makeBasePod()
 	if pc.PodTemplatePath != nil {
-		basePod = getPodSpecFromFile(pc.PodTemplatePath)
+		var err error
+		basePod, err = getPodSpecFromFile(pc.PodTemplatePath)
+		if err != nil {
+			return nil, err
+		}
 	}
 	if pc.PersistentVolumeClaimTemplatePath == nil {
-		return testutils.NewCustomCreatePodStrategy(basePod)
+		return testutils.NewCustomCreatePodStrategy(basePod), nil
 	}
 
-	pvTemplate := getPersistentVolumeSpecFromFile(pc.PersistentVolumeTemplatePath)
+	pvTemplate, err := getPersistentVolumeSpecFromFile(pc.PersistentVolumeTemplatePath)
-	pvcTemplate := getPersistentVolumeClaimSpecFromFile(pc.PersistentVolumeClaimTemplatePath)
+	if err != nil {
-	return testutils.NewCreatePodWithPersistentVolumeStrategy(pvcTemplate, getCustomVolumeFactory(pvTemplate), basePod)
+		return nil, err
+	}
+	pvcTemplate, err := getPersistentVolumeClaimSpecFromFile(pc.PersistentVolumeClaimTemplatePath)
+	if err != nil {
+		return nil, err
+	}
+	return testutils.NewCreatePodWithPersistentVolumeStrategy(pvcTemplate, getCustomVolumeFactory(pvTemplate), basePod), nil
 }
 
-func getSimpleTestCases(path string) []testCase {
+func parseTestCases(path string) ([]testCase, error) {
 	var simpleTests []simpleTestCases
-	getSpecFromFile(&path, &simpleTests)
+	if err := getSpecFromFile(&path, &simpleTests); err != nil {
+		return nil, fmt.Errorf("parsing test cases: %v", err)
+	}
 
 	testCases := make([]testCase, 0)
 	for _, s := range simpleTests {
@@ -250,41 +284,47 @@ func getSimpleTestCases(path string) []testCase {
 		}
 	}
 
-	return testCases
+	return testCases, nil
 }
 
-func getNodeSpecFromFile(path *string) *v1.Node {
+func getNodeSpecFromFile(path *string) (*v1.Node, error) {
 	nodeSpec := &v1.Node{}
-	getSpecFromFile(path, nodeSpec)
+	if err := getSpecFromFile(path, nodeSpec); err != nil {
-	return nodeSpec
+		return nil, fmt.Errorf("parsing Node: %v", err)
+	}
+	return nodeSpec, nil
 }
 
-func getPodSpecFromFile(path *string) *v1.Pod {
+func getPodSpecFromFile(path *string) (*v1.Pod, error) {
 	podSpec := &v1.Pod{}
-	getSpecFromFile(path, podSpec)
+	if err := getSpecFromFile(path, podSpec); err != nil {
-	return podSpec
+		return nil, fmt.Errorf("parsing Pod: %v", err)
+	}
+	return podSpec, nil
 }
 
-func getPersistentVolumeSpecFromFile(path *string) *v1.PersistentVolume {
+func getPersistentVolumeSpecFromFile(path *string) (*v1.PersistentVolume, error) {
 	persistentVolumeSpec := &v1.PersistentVolume{}
-	getSpecFromFile(path, persistentVolumeSpec)
+	if err := getSpecFromFile(path, persistentVolumeSpec); err != nil {
-	return persistentVolumeSpec
+		return nil, fmt.Errorf("parsing PersistentVolume: %v", err)
+	}
+	return persistentVolumeSpec, nil
 }
 
-func getPersistentVolumeClaimSpecFromFile(path *string) *v1.PersistentVolumeClaim {
+func getPersistentVolumeClaimSpecFromFile(path *string) (*v1.PersistentVolumeClaim, error) {
 	persistentVolumeClaimSpec := &v1.PersistentVolumeClaim{}
-	getSpecFromFile(path, persistentVolumeClaimSpec)
+	if err := getSpecFromFile(path, persistentVolumeClaimSpec); err != nil {
-	return persistentVolumeClaimSpec
+		return nil, fmt.Errorf("parsing PersistentVolumeClaim: %v", err)
+	}
+	return persistentVolumeClaimSpec, nil
 }
 
-func getSpecFromFile(path *string, spec interface{}) {
+func getSpecFromFile(path *string, spec interface{}) error {
 	bytes, err := ioutil.ReadFile(*path)
 	if err != nil {
-		klog.Fatalf("%v", err)
+		return err
-	}
-	if err := yaml.Unmarshal(bytes, spec); err != nil {
-		klog.Fatalf("%v", err)
 	}
+	return yaml.Unmarshal(bytes, spec)
 }
 
 func getCustomVolumeFactory(pvTemplate *v1.PersistentVolume) func(id int) *v1.PersistentVolume {