func ServiceLauncher()

in cmd/kube-egress-gateway-cnimanager/cmd/serve.go [80:166]
78 lines of code
7 McCabe index (conditional complexity)

func ServiceLauncher(cmd *cobra.Command, args []string) {
	ctx := signals.SetupSignalHandler()
	g, ctx := errgroup.WithContext(ctx)
	zapLog, err := zap.NewProduction()
	if err != nil {
		panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
	}
	logger.SetDefaultLogger(zapr.NewLogger(zapLog))
	logger := logger.GetLogger()

	k8sCluster := getKubeCluster(ctx, logger)
	k8sClient := k8sCluster.GetClient()

	cniConfMgr, err := cniconf.NewCNIConfManager(consts.CNIConfDir, confFileName, exceptionCidrs, cniUninstallConfigMapName, k8sClient, grpcPort)
	if err != nil {
		logger.Error(err, "failed to create cni config manager")
		os.Exit(1)
	}

	nodeTaintHandler := toolscache.ResourceEventHandlerFuncs{
		AddFunc: func(obj interface{}) {
			removeNodeTaintIfNeeded(obj, func() bool { return cniConfMgr.IsReady() }, k8sClient, logger)
		},
		UpdateFunc: func(_, newObj interface{}) {
			removeNodeTaintIfNeeded(newObj, func() bool { return cniConfMgr.IsReady() }, k8sClient, logger)
		},
	}
	startKubeCluster(ctx, k8sCluster, nodeTaintHandler, logger)

	g.Go(func() error {
		if err := cniConfMgr.Start(ctx); err != nil {
			logger.Error(err, "failed to start cni config manager monitoring")
			os.Exit(1)
		}
		return nil
	})

	nicSvc := cnimanager.NewNicService(k8sClient)
	server := grpc.NewServer(
		grpc.StatsHandler(otelgrpc.NewServerHandler()),
		grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(
			grpc_ctxtags.StreamServerInterceptor(),
			grpc_zap.StreamServerInterceptor(zapLog),
			grpc_prometheus.StreamServerInterceptor,
			grpc_recovery.StreamServerInterceptor(),
		)),
		grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(
			grpc_ctxtags.UnaryServerInterceptor(),
			grpc_zap.UnaryServerInterceptor(
				zapLog,
				grpc_zap.WithDecider(func(fullMethodName string, err error) bool {
					return fullMethodName != "/grpc.health.v1.Health/Check"
				})),
			grpc_prometheus.UnaryServerInterceptor,
			grpc_recovery.UnaryServerInterceptor(),
		)),
	)

	healthServer := health.NewServer()
	healthServer.SetServingStatus("", healthgrpc.HealthCheckResponse_SERVING)
	healthgrpc.RegisterHealthServer(server, healthServer)

	cniprotocol.RegisterNicServiceServer(server, nicSvc)
	var listener net.Listener
	listener, err = net.Listen("tcp", fmt.Sprintf(":%d", grpcPort))
	if err != nil {
		logger.Error(err, "failed to listen")
		os.Exit(1)
	}

	g.Go(func() error {
		<-ctx.Done()
		logger.Error(ctx.Err(), "os signal received, shutting down")
		server.GracefulStop()
		return nil
	})
	err = server.Serve(listener)
	if err != nil {
		logger.Error(err, "failed to serve")
	}
	// wait for all context to be done
	err = g.Wait()
	if err != nil {
		logger.Error(err, "unexpected error returned from errgroup")
	}
	logger.Info("server shutdown")
}