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

cmd/cmdmain.go

@@ -4,8 +4,6 @@ import (
 	"os"
 	"path/filepath"
 
-	"k8s.io/klog/v2"
-
 	"github.com/kubeovn/kube-ovn/cmd/cni"
 	"github.com/kubeovn/kube-ovn/cmd/controller"
 	"github.com/kubeovn/kube-ovn/cmd/controller_health_check"
@@ -14,6 +12,7 @@ import (
 	"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 (
@@ -47,6 +46,6 @@ func main() {
 	case CmdOvnLeaderChecker:
 		ovn_leader_checker.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

@@ -7,29 +7,28 @@ import (
 	"strings"
 	"time"
 
-	"k8s.io/klog/v2"
-
 	"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

@@ -39,23 +39,23 @@ 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")
 	}
 
 	if err = config.Init(nicBridgeMappings); err != nil {
-		klog.Fatalf("failed to initialize config: %v", err)
+		util.LogFatalAndExit(err, "failed to initialize 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()
@@ -74,15 +74,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(config.CniConfDir, config.CniConfFile, config.CniConfName); err != nil {
-		klog.Fatalf("failed to mv cni conf, %v", err)
+		util.LogFatalAndExit(err, "failed to mv cni config file")
 	}
 
 	mux := http.NewServeMux()

cmd/ovn_leader_checker/ovn_leader_checker.go

@@ -1,18 +1,17 @@
 package ovn_leader_checker
 
 import (
-	"k8s.io/klog/v2"
-
 	"github.com/kubeovn/kube-ovn/pkg/ovn_leader_checker"
+	"github.com/kubeovn/kube-ovn/pkg/util"
 )
 
 func CmdMain() {
 	cfg, err := ovn_leader_checker.ParseFlags()
 	if err != nil {
-		klog.Fatalf("ovn_leader_checker parseFlags error %v", err)
+		util.LogFatalAndExit(err, "failed to parse flags")
 	}
 	if err = ovn_leader_checker.KubeClientInit(cfg); err != nil {
-		klog.Fatalf("KubeClientInit err %v", err)
+		util.LogFatalAndExit(err, "failed to initialize kube client")
 	}
 	ovn_leader_checker.StartOvnLeaderCheck(cfg)
 }

cmd/ovn_monitor/ovn_monitor.go

@@ -7,6 +7,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"
 )
 
@@ -16,7 +17,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

@@ -21,7 +21,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

@@ -9,6 +9,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"
 )
 
@@ -18,7 +19,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

@@ -148,7 +148,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

@@ -480,56 +480,56 @@ 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.SetLsDnatModDlDst(c.config.LsDnatModDlDst); err != nil {
-		klog.Fatal(err)
+		util.LogFatalAndExit(err, "failed to set NB_Global option ls_dnat_mod_dl_dst")
 	}
 	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")
 	}
 
 	if err := c.addNodeGwStaticRoute(); 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
@@ -634,7 +634,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 {
@@ -657,7 +657,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

@@ -98,7 +98,7 @@ func ParseFlags() *Configuration {
 		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

@@ -101,8 +101,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])
 
@@ -659,13 +658,11 @@ func (c *Controller) Run(stopCh <-chan struct{}) {
 	go wait.Until(c.operateMod, 10*time.Second, 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_linux.go

@@ -401,11 +401,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)
@@ -416,7 +416,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)
 	}
 }