test/integration: Use logutil.Fatal

Author: tchap

test/integration/hermetic_test.go

@@ -9,7 +9,6 @@ import (
 	"flag"
 	"fmt"
 	"io"
-	"log"
 	"os"
 	"path/filepath"
 	"testing"
@@ -35,6 +34,7 @@ import (
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/ext-proc/backend"
 	runserver "sigs.k8s.io/gateway-api-inference-extension/pkg/ext-proc/server"
 	extprocutils "sigs.k8s.io/gateway-api-inference-extension/pkg/ext-proc/test"
+	logutil "sigs.k8s.io/gateway-api-inference-extension/pkg/ext-proc/util/logging"
 	"sigs.k8s.io/yaml"
 )
 
@@ -420,7 +420,7 @@ func setUpHermeticServer(pods []*backend.PodMetrics) (client extProcPb.ExternalP
 		if err := serverRunner.AsRunnable(
 			backend.NewK8sDataStore(backend.WithPods(pods)), pmc,
 		).Start(serverCtx); err != nil {
-			log.Fatalf("Failed to start ext-proc server: %v", err)
+			logutil.Fatal(err, "Failed to start ext-proc server")
 		}
 	}()
 
@@ -431,13 +431,13 @@ func setUpHermeticServer(pods []*backend.PodMetrics) (client extProcPb.ExternalP
 	// Create a grpc connection
 	conn, err := grpc.NewClient(address, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		log.Fatalf("Failed to connect to %v: %v", address, err)
+		logutil.Fatal(err, "Failed to connect", "address", address)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	client, err = extProcPb.NewExternalProcessorClient(conn).Process(ctx)
 	if err != nil {
-		log.Fatalf("Failed to create client: %v", err)
+		logutil.Fatal(err, "Failed to create client")
 	}
 	return client, func() {
 		cancel()
@@ -455,24 +455,23 @@ func BeforeSuit() {
 	}
 	cfg, err := testEnv.Start()
 	if err != nil {
-		log.Fatalf("Failed to start test environment, cfg: %v error: %v", cfg, err)
+		logutil.Fatal(err, "Failed to start test environment", "config", cfg)
 	}
 
 	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
 	utilruntime.Must(v1alpha1.AddToScheme(scheme))
 
 	k8sClient, err = k8sclient.New(cfg, k8sclient.Options{Scheme: scheme})
 	if err != nil {
-		log.Fatalf("Failed to start k8s Client: %v", err)
+		logutil.Fatal(err, "Failed to start k8s Client")
 	} else if k8sClient == nil {
-		log.Fatalf("No error, but returned kubernetes client is nil, cfg: %v", cfg)
+		logutil.Fatal(nil, "No error, but returned kubernetes client is nil", "config", cfg)
 	}
 
 	// Init runtime.
 	mgr, err := ctrl.NewManager(cfg, ctrl.Options{Scheme: scheme})
 	if err != nil {
-		klog.ErrorS(err, "Failed to create controller manager")
-		klog.FlushAndExit(klog.ExitFlushTimeout, 1)
+		logutil.Fatal(err, "Failed to create controller manager")
 	}
 
 	serverRunner = runserver.NewDefaultExtProcServerRunner()
@@ -481,13 +480,13 @@ func BeforeSuit() {
 	serverRunner.Datastore = backend.NewK8sDataStore()
 
 	if err := serverRunner.SetupWithManager(mgr); err != nil {
-		log.Fatalf("Failed to start server runner: %v", err)
+		logutil.Fatal(err, "Failed to setup server runner")
 	}
 
 	// Start the controller manager in go routine, not blocking
 	go func() {
 		if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
-			log.Fatalf("Failed to start manager: %v", err)
+			logutil.Fatal(err, "Failed to start manager")
 		}
 	}()
 
@@ -501,30 +500,30 @@ func BeforeSuit() {
 	manifestsPath := filepath.Join("..", "testdata", "inferencepool-with-model-hermetic.yaml")
 	docs, err := readDocuments(manifestsPath)
 	if err != nil {
-		log.Fatalf("Can't read object manifests at path %v, %v", manifestsPath, err)
+		logutil.Fatal(err, "Can't read object manifests", "path", manifestsPath)
 	}
 
 	for _, doc := range docs {
 		inferenceModel := &v1alpha1.InferenceModel{}
 		if err = yaml.Unmarshal(doc, inferenceModel); err != nil {
-			log.Fatalf("Can't unmarshal object: %v", doc)
+			logutil.Fatal(err, "Can't unmarshal object", "document", doc)
 		}
 		if inferenceModel.Kind == "InferenceModel" {
 			klog.InfoS("Creating inference model", "model", inferenceModel)
 			if err := k8sClient.Create(context.Background(), inferenceModel); err != nil {
-				log.Fatalf("unable to create inferenceModel %v: %v", inferenceModel.Name, err)
+				logutil.Fatal(err, "Unable to create inferenceModel", "modelName", inferenceModel.Name)
 			}
 		}
 	}
 	for _, doc := range docs {
 		inferencePool := &v1alpha1.InferencePool{}
 		if err = yaml.Unmarshal(doc, inferencePool); err != nil {
-			log.Fatalf("Can't unmarshal object: %v", doc)
+			logutil.Fatal(err, "Can't unmarshal object", "document", doc)
 		}
 		if inferencePool.Kind == "InferencePool" {
 			klog.InfoS("Creating inference pool", "pool", inferencePool)
 			if err := k8sClient.Create(context.Background(), inferencePool); err != nil {
-				log.Fatalf("unable to create inferencePool %v: %v", inferencePool.Name, err)
+				logutil.Fatal(err, "Unable to create inferencePool", "poolName", inferencePool.Name)
 			}
 		}
 	}