/
scheduler.go
84 lines (68 loc) · 1.75 KB
/
scheduler.go
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
package alerting
import (
"math"
"time"
"github.com/famarks/grafarg/pkg/infra/log"
"github.com/famarks/grafarg/pkg/models"
"github.com/famarks/grafarg/pkg/setting"
)
type schedulerImpl struct {
jobs map[int64]*Job
log log.Logger
}
func newScheduler() scheduler {
return &schedulerImpl{
jobs: make(map[int64]*Job),
log: log.New("alerting.scheduler"),
}
}
func (s *schedulerImpl) Update(rules []*Rule) {
s.log.Debug("Scheduling update", "ruleCount", len(rules))
jobs := make(map[int64]*Job)
for i, rule := range rules {
var job *Job
if s.jobs[rule.ID] != nil {
job = s.jobs[rule.ID]
} else {
job = &Job{}
job.SetRunning(false)
}
job.Rule = rule
offset := ((rule.Frequency * 1000) / int64(len(rules))) * int64(i)
job.Offset = int64(math.Floor(float64(offset) / 1000))
if job.Offset == 0 { // zero offset causes division with 0 panics.
job.Offset = 1
}
jobs[rule.ID] = job
}
s.jobs = jobs
}
func (s *schedulerImpl) Tick(tickTime time.Time, execQueue chan *Job) {
now := tickTime.Unix()
for _, job := range s.jobs {
if job.GetRunning() || job.Rule.State == models.AlertStatePaused {
continue
}
if job.OffsetWait && now%job.Offset == 0 {
job.OffsetWait = false
s.enqueue(job, execQueue)
continue
}
// Check the job frequency against the minimum interval required
interval := job.Rule.Frequency
if interval < setting.AlertingMinInterval {
interval = setting.AlertingMinInterval
}
if now%interval == 0 {
if job.Offset > 0 {
job.OffsetWait = true
} else {
s.enqueue(job, execQueue)
}
}
}
}
func (s *schedulerImpl) enqueue(job *Job, execQueue chan *Job) {
s.log.Debug("Scheduler: Putting job on to exec queue", "name", job.Rule.Name, "id", job.Rule.ID)
execQueue <- job
}