func realMain()

in cmd/alerter/main.go [52:141]
75 lines of code
13 McCabe index (conditional complexity)

func realMain(ctx *cli.Context) error {
	logger.Infof("%s version:%s", os.Args[0], version.String())

	endpoints := make(map[string]string)
	endpointsArg := ctx.StringSlice("kusto-endpoint")
	for _, v := range endpointsArg {
		parts := strings.Split(v, "=")
		if len(parts) != 2 {
			return cli.Exit("Invalid kusto-endpoint format, expected <name>=<endpoint>", 1)
		}
		endpoints[parts[0]] = parts[1]
	}

	tags := make(map[string]string)
	tagsArg := ctx.StringSlice("tag")
	for _, v := range tagsArg {
		parts := strings.Split(v, "=")
		if len(parts) != 2 {
			return cli.Exit("Invalid tag format, expected <key>=<value>", 1)
		}
		tags[strings.ToLower(parts[0])] = strings.ToLower(parts[1])
	}

	// Always add region and cloud tags which are required params for alerter currently.
	tags["region"] = strings.ToLower(ctx.String("region"))
	tags["cloud"] = strings.ToLower(ctx.String("cloud"))

	for k, v := range tags {
		logger.Infof("Using tag %s=%s", k, v)
	}

	scheme := clientgoscheme.Scheme
	if err := clientgoscheme.AddToScheme(scheme); err != nil {
		return err
	}
	if err := alertrulev1.AddToScheme(scheme); err != nil {
		return err
	}

	_, _, ctrlCli, err := newKubeClient(ctx)
	if err != nil {
		return err
	}

	opts := &alerter.AlerterOpts{
		Port:             ctx.Int("port"),
		KustoEndpoints:   endpoints,
		Region:           ctx.String("region"),
		Cloud:            ctx.String("cloud"),
		AlertAddr:        ctx.String("alerter-address"),
		Concurrency:      ctx.Int("concurrency"),
		MaxNotifications: ctx.Int("max-notifications"),
		MSIID:            ctx.String("auth-msi-id"),
		KustoToken:       ctx.String("auth-token"),
		Tags:             tags,
		CtrlCli:          ctrlCli,
	}

	svcCtx, cancel := context.WithCancel(context.Background())
	defer cancel()

	if ctx.String("lint-dir") != "" {
		return alerter.Lint(svcCtx, opts, ctx.String("lint-dir"))
	}

	svc, err := alerter.NewService(opts)
	if err != nil {
		return err
	}

	if err := svc.Open(svcCtx); err != nil {
		return err
	}

	sc := make(chan os.Signal, 1)
	signal.Notify(sc, os.Interrupt, syscall.SIGTERM)
	go func() {
		sig := <-sc
		cancel()

		logger.Infof("Received signal %s, exiting...", sig.String())
		// Shutdown the server and cancel context
		err := svc.Close()
		if err != nil {
			logger.Errorf(err.Error())
		}
	}()
	<-svcCtx.Done()
	return nil
}