replace klog.Fatalf with klog.ErrorS and klog.FlushAndExit (#2093)

cmd/cmdmain.go

@@ -1,17 +1,17 @@
 package main
 
 import (
-	"github.com/kubeovn/kube-ovn/cmd/controller_health_check"
 	"os"
 	"strings"
 
-	"k8s.io/klog/v2"
+	"github.com/kubeovn/kube-ovn/cmd/controller_health_check"
 
 	"github.com/kubeovn/kube-ovn/cmd/controller"
 	"github.com/kubeovn/kube-ovn/cmd/daemon"
 	"github.com/kubeovn/kube-ovn/cmd/ovn_monitor"
 	"github.com/kubeovn/kube-ovn/cmd/pinger"
 	"github.com/kubeovn/kube-ovn/cmd/speaker"
+	"github.com/kubeovn/kube-ovn/pkg/util"
 )
 
 const (
@@ -40,6 +40,6 @@ func main() {
 	case CmdControllerHealthCheck:
 		controller_health_check.CmdMain()
 	default:
-		klog.Fatalf("%s is an unknown command", cmd)
+		util.LogFatalAndExit(nil, "%s is an unknown command", cmd)
 	}
 }

cmd/controller/controller.go

@@ -31,11 +31,11 @@ func CmdMain() {
 	util.InitKlogMetrics()
 	config, err := controller.ParseFlags()
 	if err != nil {
-		klog.Fatalf("parse config failed %v", err)
+		util.LogFatalAndExit(err, "failed to parse config")
 	}
 
 	if err := checkPermission(config); err != nil {
-		klog.Fatalf("failed to check permission %v", err)
+		util.LogFatalAndExit(err, "failed to check permission")
 	}
 
 	go loopOvnNbctlDaemon(config)

cmd/controller_health_check/controller_health_check.go

@@ -2,32 +2,33 @@ package controller_health_check
 
 import (
 	"fmt"
-	"github.com/kubeovn/kube-ovn/pkg/ovs"
-	"k8s.io/klog/v2"
 	"net"
 	"os"
 	"strings"
 	"time"
+
+	"github.com/kubeovn/kube-ovn/pkg/ovs"
+	"github.com/kubeovn/kube-ovn/pkg/util"
 )
 
 func CmdMain() {
 	content, err := os.ReadFile("/var/run/ovn/ovn-nbctl.pid")
 	if err != nil {
-		klog.Fatalf("failed to get ovn-nbctl daemon pid, %s", err)
+		util.LogFatalAndExit(err, "failed to get ovn-nbctl daemon pid")
 	}
 	daemonPid := strings.TrimSuffix(string(content), "\n")
 	if err := os.Setenv("OVN_NB_DAEMON", fmt.Sprintf("/var/run/ovn/ovn-nbctl.%s.ctl", daemonPid)); err != nil {
-		klog.Fatalf("failed to set env OVN_NB_DAEMON, %v", err)
+		util.LogFatalAndExit(err, "failed to set env OVN_NB_DAEMON")
 	}
 	if err := ovs.CheckAlive(); err != nil {
 		os.Exit(1)
 	}
 	conn, err := net.DialTimeout("tcp", "127.0.0.1:10660", 3*time.Second)
 	if err != nil {
-		klog.Fatalf("failed to probe the socket, %s", err)
+		util.LogFatalAndExit(err, "failed to probe the socket")
 	}
 	err = conn.Close()
 	if err != nil {
-		klog.Fatalf("Unexpected error closing TCP probe socket: %v (%#v)", err, err)
+		util.LogFatalAndExit(err, "failed to close connection")
 	}
 }

cmd/daemon/cniserver.go

@@ -32,24 +32,24 @@ func CmdMain() {
 
 	nicBridgeMappings, err := daemon.InitOVSBridges()
 	if err != nil {
-		klog.Fatalf("failed to initialize OVS bridges: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize OVS bridges")
 	}
 
 	config, err := daemon.ParseFlags(nicBridgeMappings)
 	if err != nil {
-		klog.Fatalf("parse config failed %v", err)
+		util.LogFatalAndExit(err, "failed to parse config")
 	}
 
 	if err := Retry(util.ChasRetryTime, util.ChasRetryIntev, initChassisAnno, config); err != nil {
-		klog.Fatalf("failed to annotate chassis id, %v", err)
+		util.LogFatalAndExit(err, "failed to initialize ovn chassis annotation")
 	}
 
 	if err = daemon.InitMirror(config); err != nil {
-		klog.Fatalf("failed to init mirror nic, %v", err)
+		util.LogFatalAndExit(err, "failed to initialize ovs mirror")
 	}
 
 	if err = daemon.InitNodeGateway(config); err != nil {
-		klog.Fatalf("init node gateway failed %v", err)
+		util.LogFatalAndExit(err, "failed to initialize node gateway")
 	}
 
 	stopCh := signals.SetupSignalHandler()
@@ -68,15 +68,15 @@ func CmdMain() {
 		}))
 	ctl, err := daemon.NewController(config, podInformerFactory, nodeInformerFactory, kubeovnInformerFactory)
 	if err != nil {
-		klog.Fatalf("create controller failed %v", err)
+		util.LogFatalAndExit(err, "failed to create controller")
 	}
 	podInformerFactory.Start(stopCh)
 	nodeInformerFactory.Start(stopCh)
 	kubeovnInformerFactory.Start(stopCh)
 	go ctl.Run(stopCh)
 	go daemon.RunServer(config, ctl)
 	if err := mvCNIConf(); err != nil {
-		klog.Fatalf("failed to mv cni conf, %v", err)
+		util.LogFatalAndExit(err, "failed to mv cni config")
 	}
 
 	mux := http.NewServeMux()

cmd/ovn_monitor/ovn_monitor.go

@@ -8,6 +8,7 @@ import (
 	"k8s.io/klog/v2"
 
 	ovn "github.com/kubeovn/kube-ovn/pkg/ovnmonitor"
+	"github.com/kubeovn/kube-ovn/pkg/util"
 	"github.com/kubeovn/kube-ovn/versions"
 )
 
@@ -17,7 +18,7 @@ func CmdMain() {
 	klog.Infof(versions.String())
 	config, err := ovn.ParseFlags()
 	if err != nil {
-		klog.Fatalf("parse config failed %v", err)
+		util.LogFatalAndExit(err, "failed to parse config")
 	}
 
 	exporter := ovn.NewExporter(config)

cmd/pinger/pinger.go

@@ -22,7 +22,7 @@ func CmdMain() {
 	util.InitKlogMetrics()
 	config, err := pinger.ParseFlags()
 	if err != nil {
-		klog.Fatalf("parse config failed %v", err)
+		util.LogFatalAndExit(err, "failed to parse config")
 	}
 	if config.Mode == "server" {
 		http.Handle("/metrics", promhttp.Handler())

cmd/speaker/speaker.go

@@ -10,6 +10,7 @@ import (
 	"k8s.io/sample-controller/pkg/signals"
 
 	"github.com/kubeovn/kube-ovn/pkg/speaker"
+	"github.com/kubeovn/kube-ovn/pkg/util"
 	"github.com/kubeovn/kube-ovn/versions"
 )
 
@@ -19,7 +20,7 @@ func CmdMain() {
 	klog.Infof(versions.String())
 	config, err := speaker.ParseFlags()
 	if err != nil {
-		klog.Fatalf("failed to parse config %v", err)
+		util.LogFatalAndExit(err, "failed to parse config")
 	}
 
 	stopCh := signals.SetupSignalHandler()

cmd/webhook/server.go

@@ -12,6 +12,7 @@ import (
 	ctrlwebhook "sigs.k8s.io/controller-runtime/pkg/webhook"
 
 	ovnv1 "github.com/kubeovn/kube-ovn/pkg/apis/kubeovn/v1"
+	"github.com/kubeovn/kube-ovn/pkg/util"
 	ovnwebhook "github.com/kubeovn/kube-ovn/pkg/webhook"
 	"github.com/kubeovn/kube-ovn/versions"
 	"github.com/spf13/pflag"
@@ -27,13 +28,13 @@ var (
 
 func init() {
 	if err := corev1.AddToScheme(scheme); err != nil {
-		klog.Fatalf("failed to add scheme, %v", err)
+		util.LogFatalAndExit(err, "failed to add core v1 scheme")
 	}
 	if err := appsv1.AddToScheme(scheme); err != nil {
-		klog.Fatalf("failed to add scheme, %v", err)
+		util.LogFatalAndExit(err, "failed to add apps v1 scheme")
 	}
 	if err := ovnv1.AddToScheme(scheme); err != nil {
-		klog.Fatalf("failed to add scheme, %v", err)
+		util.LogFatalAndExit(err, "failed to add ovn v1 scheme")
 	}
 }
 
@@ -52,7 +53,7 @@ func main() {
 		if f2 != nil {
 			value := f1.Value.String()
 			if err := f2.Value.Set(value); err != nil {
-				klog.Fatalf("failed to set flag, %v", err)
+				util.LogFatalAndExit(err, "failed to set flag")
 			}
 		}
 	})

pkg/controller/config.go

@@ -144,7 +144,7 @@ func ParseFlags() (*Configuration, error) {
 		if f2 != nil {
 			value := f1.Value.String()
 			if err := f2.Value.Set(value); err != nil {
-				klog.Fatalf("failed to set pflag, %v", err)
+				util.LogFatalAndExit(err, "failed to set pflag")
 			}
 		}
 	})

pkg/controller/controller.go

@@ -374,54 +374,54 @@ func (c *Controller) Run(stopCh <-chan struct{}) {
 		cacheSyncs = append(cacheSyncs, c.npsSynced)
 	}
 	if ok := cache.WaitForCacheSync(stopCh, cacheSyncs...); !ok {
-		klog.Fatalf("failed to wait for caches to sync")
+		util.LogFatalAndExit(nil, "failed to wait for caches to sync")
 	}
 
 	if err := c.ovnLegacyClient.SetUseCtInvMatch(); err != nil {
-		klog.Fatalf("failed to set NB_Global option use_ct_inv_match to false: %v", err)
+		util.LogFatalAndExit(err, "failed to set NB_Global option use_ct_inv_match")
 	}
 
 	if err := c.InitDefaultVpc(); err != nil {
-		klog.Fatalf("failed to init default vpc: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize default vpc")
 	}
 
 	if err := c.InitOVN(); err != nil {
-		klog.Fatalf("failed to init ovn resource: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize ovn resources")
 	}
 
 	// sync ip crd before initIPAM since ip crd will be used to restore vm and statefulset pod in initIPAM
 	if err := c.initSyncCrdIPs(); err != nil {
-		klog.Errorf("failed to sync crd ips: %v", err)
+		util.LogFatalAndExit(err, "failed to sync crd ips")
 	}
 
 	if err := c.InitIPAM(); err != nil {
-		klog.Fatalf("failed to init ipam: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize ipam")
 	}
 
 	if err := c.initNodeRoutes(); err != nil {
-		klog.Fatalf("failed to initialize node routes: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize node routes")
 	}
 
 	if err := c.initDenyAllSecurityGroup(); err != nil {
-		klog.Fatalf("failed to init 'deny_all' security group: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize 'deny_all' security group")
 	}
 
 	// remove resources in ovndb that not exist any more in kubernetes resources
 	if err := c.gc(); err != nil {
-		klog.Fatalf("gc failed: %v", err)
+		util.LogFatalAndExit(err, "failed to run gc")
 	}
 
 	c.registerSubnetMetrics()
 	if err := c.initSyncCrdSubnets(); err != nil {
-		klog.Errorf("failed to sync crd subnets: %v", err)
+		util.LogFatalAndExit(err, "failed to sync crd subnets")
 	}
 	if err := c.initSyncCrdVlans(); err != nil {
-		klog.Errorf("failed to sync crd vlans: %v", err)
+		util.LogFatalAndExit(err, "failed to sync crd vlans")
 	}
 	// The static route for node gw can be deleted when gc static route, so add it after gc process
 	dstIp := "0.0.0.0/0,::/0"
 	if err := c.ovnLegacyClient.AddStaticRoute("", dstIp, c.config.NodeSwitchGateway, c.config.ClusterRouter, util.NormalRouteType, false); err != nil {
-		klog.Errorf("failed to add static route for node gw: %v", err)
+		util.LogFatalAndExit(err, "failed to add static route for node gateway")
 	}
 
 	// start workers to do all the network operations
@@ -504,7 +504,7 @@ func (c *Controller) startWorkers(stopCh <-chan struct{}) {
 		time.Sleep(3 * time.Second)
 		lss, err := c.ovnLegacyClient.ListLogicalSwitch(c.config.EnableExternalVpc)
 		if err != nil {
-			klog.Fatalf("failed to list logical switch: %v", err)
+			util.LogFatalAndExit(err, "failed to list logical switch")
 		}
 
 		if util.IsStringIn(c.config.DefaultLogicalSwitch, lss) && util.IsStringIn(c.config.NodeSwitch, lss) && c.addNamespaceQueue.Len() == 0 {
@@ -527,7 +527,7 @@ func (c *Controller) startWorkers(stopCh <-chan struct{}) {
 		time.Sleep(3 * time.Second)
 		nodes, err := c.nodesLister.List(labels.Everything())
 		if err != nil {
-			klog.Fatalf("failed to list nodes: %v", err)
+			util.LogFatalAndExit(err, "failed to list nodes")
 		}
 		for _, node := range nodes {
 			if node.Annotations[util.AllocatedAnnotation] != "true" {

pkg/controller/election.go

@@ -79,7 +79,7 @@ func setupLeaderElection(config *leaderElectionConfig) *leaderelection.LeaderEle
 			if config.OnStoppedLeading != nil {
 				config.OnStoppedLeading()
 			}
-			klog.Fatalf("leaderelection lost")
+			util.LogFatalAndExit(nil, "leaderelection lost")
 		},
 		OnNewLeader: func(identity string) {
 			klog.Infof("new leader elected: %v", identity)
@@ -114,7 +114,7 @@ func setupLeaderElection(config *leaderElectionConfig) *leaderelection.LeaderEle
 		Callbacks:     callbacks,
 	})
 	if err != nil {
-		klog.Fatalf("unexpected error starting leader election: %v", err)
+		util.LogFatalAndExit(err, "failed to create leader elector")
 	}
 
 	go elector.Run(context.Background())

pkg/daemon/config.go

@@ -87,7 +87,7 @@ func ParseFlags(nicBridgeMappings map[string]string) (*Configuration, error) {
 		if f2 != nil {
 			value := f1.Value.String()
 			if err := f2.Value.Set(value); err != nil {
-				klog.Fatalf("failed to set flag, %v", err)
+				util.LogFatalAndExit(err, "failed to set flag")
 			}
 		}
 	})

pkg/daemon/controller.go

@@ -113,8 +113,7 @@ func NewController(config *Configuration, podInformerFactory informers.SharedInf
 
 	node, err := config.KubeClient.CoreV1().Nodes().Get(context.Background(), config.NodeName, metav1.GetOptions{})
 	if err != nil {
-		klog.Fatalf("failed to get node %s info %v", config.NodeName, err)
-		return nil, err
+		util.LogFatalAndExit(err, "failed to get node %s info", config.NodeName)
 	}
 	controller.protocol = util.CheckProtocol(node.Annotations[util.IpAddressAnnotation])
 
@@ -1254,13 +1253,11 @@ func (c *Controller) Run(stopCh <-chan struct{}) {
 	go wait.Until(rotateLog, 1*time.Hour, stopCh)
 
 	if ok := cache.WaitForCacheSync(stopCh, c.providerNetworksSynced, c.subnetsSynced, c.podsSynced, c.nodesSynced, c.htbQosSynced); !ok {
-		klog.Fatalf("failed to wait for caches to sync")
-		return
+		util.LogFatalAndExit(nil, "failed to wait for caches to sync")
 	}
 
 	if err := c.setIPSet(); err != nil {
-		klog.Errorf("failed to set ipsets: %v", err)
-		return
+		util.LogFatalAndExit(err, "failed to set ipsets")
 	}
 
 	klog.Info("Started workers")

pkg/daemon/ovs.go

@@ -381,11 +381,11 @@ func configureNodeNic(portName, ip, gw string, macAddr net.HardwareAddr, mtu int
 func (c *Controller) loopOvn0Check() {
 	link, err := netlink.LinkByName(util.NodeNic)
 	if err != nil {
-		klog.Fatalf("failed to get ovn0 nic: %v", err)
+		util.LogFatalAndExit(err, "failed to get ovn0 nic:")
 	}
 
 	if link.Attrs().OperState == netlink.OperDown {
-		klog.Fatalf("ovn0 nic is down")
+		util.LogFatalAndExit(err, "ovn0 nic is down")
 	}
 
 	node, err := c.nodesLister.Get(c.config.NodeName)
@@ -396,7 +396,7 @@ func (c *Controller) loopOvn0Check() {
 	ip := node.Annotations[util.IpAddressAnnotation]
 	gw := node.Annotations[util.GatewayAnnotation]
 	if err := waitNetworkReady(util.NodeNic, ip, gw, false, false); err != nil {
-		klog.Fatalf("failed to ping ovn0 gw: %s, %v", gw, err)
+		util.LogFatalAndExit(err, "failed to ping ovn0 gateway %s", gw, err)
 	}
 }
 

pkg/ovnmonitor/exporter.go

@@ -8,6 +8,8 @@ import (
 
 	"github.com/greenpau/ovsdb"
 	"k8s.io/klog/v2"
+
+	"github.com/kubeovn/kube-ovn/pkg/util"
 )
 
 const metricNamespace = "kube_ovn"
@@ -112,8 +114,7 @@ func (e *Exporter) StartConnection() error {
 func (e *Exporter) TryClientConnection() {
 	for {
 		if tryConnectCnt > 5 {
-			klog.Fatalf("%s: ovn-monitor failed to reconnect db socket finally", e.Client.System.Hostname)
-			break
+			util.LogFatalAndExit(nil, "%s: ovn-monitor failed to reconnect db socket finally", e.Client.System.Hostname)
 		}
 
 		if err := e.StartConnection(); err != nil {