app

Documentation

Index

• Variables
• type App
  • func NewApp(c appConfig, db *sql.DB) (*App, error)
  • func (a *App) ActiveRequests() int
  • func (app *App) Pause(ctx context.Context) error
  • func (app *App) Resume()
  • func (app *App) Run(ctx context.Context) error
  • func (app *App) Shutdown(ctx context.Context) error
  • func (a *App) Status() lifecycle.Status
  • func (app *App) Trigger()

Variables

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

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

		err := viper.ReadInConfig()

		if _, ok := err.(viper.ConfigFileNotFoundError); err != nil && !ok {
			return errors.Wrap(err, "read config")
		}

		ctx := context.Background()
		cfg, err := getConfig()
		if err != nil {
			return err
		}
		exporters, err := configTracing(ctx, cfg)
		if err != nil {
			return errors.Wrap(err, "config tracing")
		}

		defer func() {
			// flush exporters
			type flusher interface {
				Flush()
			}
			for _, e := range exporters {
				if f, ok := e.(flusher); ok {
					f.Flush()
				}
			}
		}()

		wrappedDriver := sqltrace.WrapDriver(&stdlib.Driver{}, &sqltrace.WrapOptions{Query: true})

		u, err := url.Parse(cfg.DBURL)
		if err != nil {
			return errors.Wrap(err, "parse old URL")
		}
		q := u.Query()
		if cfg.DBURLNext != "" {
			q.Set("application_name", fmt.Sprintf("GoAlert %s (S/O Mode)", version.GitVersion()))
		} else {
			q.Set("application_name", fmt.Sprintf("GoAlert %s", version.GitVersion()))
		}
		u.RawQuery = q.Encode()
		cfg.DBURL = u.String()

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

		dbc, err := wrappedDriver.OpenConnector(cfg.DBURL)
		if err != nil {
			return errors.Wrap(err, "connect to postgres")
		}
		var db *sql.DB
		var h *switchover.Handler
		if cfg.DBURLNext != "" {
			u, err := url.Parse(cfg.DBURLNext)
			if err != nil {
				return errors.Wrap(err, "parse next URL")
			}
			q := u.Query()
			q.Set("application_name", fmt.Sprintf("GoAlert %s (S/O Mode)", version.GitVersion()))
			u.RawQuery = q.Encode()
			cfg.DBURLNext = u.String()

			dbcNext, err := wrappedDriver.OpenConnector(cfg.DBURLNext)
			if err != nil {
				return errors.Wrap(err, "connect to postres (next)")
			}
			h, err = switchover.NewHandler(ctx, dbc, dbcNext, cfg.DBURL, cfg.DBURLNext)
			if err != nil {
				return errors.Wrap(err, "init changeover handler")
			}
			db = h.DB()
		} else {
			db = sql.OpenDB(dbc)
		}

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

		go handleShutdown(ctx, func(ctx context.Context) error {
			if h != nil {
				h.Abort()
			}
			return app.Shutdown(ctx)
		})

		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")
	},
}

RootCmd is the configuration for running the app binary.

Types

type App

type App struct {
	ConfigStore *config.Store

	AlertStore    alert.Store
	AlertLogStore alertlog.Store

	UserStore             user.Store
	ContactMethodStore    contactmethod.Store
	NotificationRuleStore notificationrule.Store
	FavoriteStore         favorite.Store

	ServiceStore        service.Store
	EscalationStore     escalation.Store
	IntegrationKeyStore integrationkey.Store
	ScheduleRuleStore   rule.Store
	NotificationStore   notification.Store
	ScheduleStore       schedule.Store
	RotationStore       rotation.Store

	OverrideStore  override.Store
	Resolver       resolver.Resolver
	LimitStore     limit.Store
	HeartbeatStore heartbeat.Store

	OAuthKeyring   keyring.Keyring
	SessionKeyring keyring.Keyring

	NonceStore    nonce.Store
	LabelStore    label.Store
	OnCallStore   oncall.Store
	NCStore       notificationchannel.Store
	TimeZoneStore *timezone.Store
	// contains filtered or unexported fields
}

App represents an instance of the GoAlert application.

func NewApp

func NewApp(c appConfig, db *sql.DB) (*App, error)

NewApp constructs a new App and binds the listening socket.

func (*App) ActiveRequests

func (a *App) ActiveRequests() int

ActiveRequests returns the current number of active requests, not including pending ones during pause.

func (*App) Pause

func (app *App) Pause(ctx context.Context) error

func (*App) Resume

func (app *App) Resume()

func (*App) Run

func (app *App) Run(ctx context.Context) error

Run will start the application and start serving traffic.

func (*App) Shutdown

func (app *App) Shutdown(ctx context.Context) error

Shutdown will cause the App to begin a graceful shutdown, using the provided context for any cleanup operations.

func (*App) Status

func (a *App) Status() lifecycle.Status

Status returns the current lifecycle status of the App.

func (*App) Trigger

func (app *App) Trigger()

Trigger will start a processing cycle (normally ever ~5s)