app

var ErrDBRequired = validation.NewFieldError("db-url", "is required")

var RootCmd = &cobra.Command{
	Use:   "goalert",
	Short: "Alerting platform.",
	RunE: func(cmd *cobra.Command, args []string) error {
		l := log.FromContext(cmd.Context())

		if viper.GetBool("json") {
			l.EnableJSON()
		}
		if viper.GetBool("verbose") {
			l.EnableDebug()
		}
		if viper.GetBool("log-errors-only") {
			l.ErrorsOnly()
		}

		if viper.GetBool("list-experimental") {
			fmt.Print(`Usage: goalert --experimental=<flag1>,<flag2> ...

These flags are not guaranteed to be stable and may change or be removed at any
time. They are used to enable in-development features and are not intended for 
production use.


Available Flags:

`)

			for _, f := range expflag.AllFlags() {
				fmt.Printf("\t%s\t\t%s", f, expflag.Description(f))
			}

			return nil
		}

		err := viper.ReadInConfig()

		if err != nil && !isCfgNotFound(err) {
			return errors.Wrap(err, "read config")
		}

		err = initPromServer()
		if err != nil {
			return err
		}
		err = initPprofServer()
		if err != nil {
			return err
		}

		ctx := cmd.Context()
		cfg, err := getConfig(ctx)
		if err != nil {
			return err
		}

		doMigrations := func(url string) error {
			if cfg.APIOnly {
				err = migrate.VerifyAll(log.WithDebug(ctx), url)
				if err != nil {
					return errors.Wrap(err, "verify migrations")
				}
				return nil
			}

			s := time.Now()
			n, err := migrate.ApplyAll(log.WithDebug(ctx), url)
			if err != nil {
				return errors.Wrap(err, "apply migrations")
			}
			if n > 0 {
				log.Logf(ctx, "Applied %d migrations in %s.", n, time.Since(s))
			}

			return nil
		}

		err = doMigrations(cfg.DBURL)
		if err != nil {
			return err
		}

		var pool *pgxpool.Pool
		if cfg.DBURLNext != "" {
			err = migrate.VerifyIsLatest(ctx, cfg.DBURL)
			if err != nil {
				return errors.Wrap(err, "verify db")
			}

			err = doMigrations(cfg.DBURLNext)
			if err != nil {
				return errors.Wrap(err, "nextdb")
			}

			mgr, err := swo.NewManager(swo.Config{
				OldDBURL: cfg.DBURL,
				NewDBURL: cfg.DBURLNext,
				CanExec:  !cfg.APIOnly,
				Logger:   cfg.LegacyLogger,
				MaxOpen:  cfg.DBMaxOpen,
				MaxIdle:  cfg.DBMaxIdle,
			})
			if err != nil {
				return errors.Wrap(err, "init switchover handler")
			}
			pool = mgr.Pool()
			cfg.SWO = mgr
		} else {
			appURL, err := sqldrv.AppURL(cfg.DBURL, fmt.Sprintf("GoAlert %s", version.GitVersion()))
			if err != nil {
				return errors.Wrap(err, "connect to postgres")
			}

			poolCfg, err := pgxpool.ParseConfig(appURL)
			if err != nil {
				return errors.Wrap(err, "parse db URL")
			}
			poolCfg.MaxConns = int32(cfg.DBMaxOpen)
			poolCfg.MinConns = int32(cfg.DBMaxIdle)
			sqldrv.SetConfigRetries(poolCfg)
			calllimiter.SetConfigQueryLimiterSupport(poolCfg)

			pool, err = pgxpool.NewWithConfig(context.Background(), poolCfg)
			if err != nil {
				return errors.Wrap(err, "connect to postgres")
			}
		}

		app, err := NewApp(cfg, pool)
		if err != nil {
			return errors.Wrap(err, "init app")
		}

		go handleShutdown(ctx, app.Shutdown)

		trigCh := make(chan os.Signal, 1)
		signal.Notify(trigCh, triggerSignals...)
		go func() {
			for range trigCh {
				app.Trigger()
			}
		}()

		return errors.Wrap(app.Run(ctx), "run app")
	},
}