File size: 3,271 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
package escalationmanager
import (
"context"
"database/sql"
"github.com/target/goalert/alert/alertlog"
"github.com/target/goalert/permission"
"github.com/target/goalert/util/log"
"github.com/target/goalert/util/sqlutil"
"github.com/pkg/errors"
)
// UpdateAll will update the state of all active escalation policies.
func (db *DB) UpdateAll(ctx context.Context) error {
err := db.update(ctx, true, nil)
return err
}
func (db *DB) update(ctx context.Context, all bool, alertID *int) error {
err := permission.LimitCheckAny(ctx, permission.System)
if err != nil {
return err
}
log.Debugf(ctx, "Updating alert escalations.")
tx, err := db.lock.BeginTx(ctx, nil)
if err != nil {
return errors.Wrap(err, "begin tx")
}
defer sqlutil.Rollback(ctx, "escalation manager", tx)
_, err = tx.StmtContext(ctx, db.lockStmt).ExecContext(ctx)
if err != nil {
return errors.Wrap(err, "lock ep step table")
}
_, err = tx.StmtContext(ctx, db.updateOnCall).ExecContext(ctx)
if err != nil {
return errors.Wrap(err, "update ep step on-call")
}
err = tx.Commit()
if err != nil {
return errors.Wrap(err, "commit on-call update")
}
_, err = db.lock.Exec(ctx, db.clearMaintExpiredSvc)
if err != nil {
return errors.Wrap(err, "set maintenance_expires_at to null where expired")
}
_, err = db.lock.Exec(ctx, db.cleanupNoSteps)
if err != nil {
return errors.Wrap(err, "end policies with no steps")
}
err = db.processEscalations(ctx, db.newPolicies, func(rows *sql.Rows) (int, *alertlog.EscalationMetaData, error) {
var id int
var meta alertlog.EscalationMetaData
err := rows.Scan(&id, &meta.NoOneOnCall)
return id, &meta, err
})
if err != nil {
return errors.Wrap(err, "trigger new policies")
}
err = db.processEscalations(ctx, db.deletedSteps, func(rows *sql.Rows) (int, *alertlog.EscalationMetaData, error) {
var id int
var meta alertlog.EscalationMetaData
err := rows.Scan(&id, &meta.Repeat, &meta.NewStepIndex, &meta.NoOneOnCall)
return id, &meta, err
})
if err != nil {
return errors.Wrap(err, "escalate policies with deleted steps")
}
err = db.processEscalations(ctx, db.normalEscalation, func(rows *sql.Rows) (int, *alertlog.EscalationMetaData, error) {
var id int
var meta alertlog.EscalationMetaData
err := rows.Scan(&id, &meta.Repeat, &meta.NewStepIndex, &meta.OldDelayMinutes, &meta.Forced, &meta.NoOneOnCall)
return id, &meta, err
})
if err != nil {
return errors.Wrap(err, "escalate forced or expired")
}
return nil
}
func (db *DB) processEscalations(ctx context.Context, stmt *sql.Stmt, scan func(*sql.Rows) (int, *alertlog.EscalationMetaData, error)) error {
tx, err := db.lock.BeginTx(ctx, nil)
if err != nil {
return err
}
defer sqlutil.Rollback(ctx, "escalation manager: process", tx)
rows, err := tx.StmtContext(ctx, stmt).QueryContext(ctx)
if err != nil {
return err
}
defer rows.Close()
batch := make(map[alertlog.EscalationMetaData][]int)
for rows.Next() {
id, esc, err := scan(rows)
if err != nil {
return err
}
batch[*esc] = append(batch[*esc], id)
}
for meta, ids := range batch {
err = db.log.LogManyTx(ctx, tx, ids, alertlog.TypeEscalated, meta)
if err != nil {
return errors.Wrap(err, "log escalation")
}
}
return tx.Commit()
}
|