forked from coredns/coredns
/
up.go
93 lines (82 loc) · 2.02 KB
/
up.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
85
86
87
88
89
90
91
92
93
// Package up is used to run a function for some duration. If a new function is added while a previous run is
// still ongoing, nothing new will be executed.
package up
import (
"sync"
"time"
)
// Probe is used to run a single Func until it returns true (indicating a target is healthy). If an Func
// is already in progress no new one will be added, i.e. there is always a maximum of 1 checks in flight.
// When failures start to happen we will back off every second failure up to maximum of 4 intervals.
type Probe struct {
sync.Mutex
inprogress int
interval time.Duration
max time.Duration
}
// Func is used to determine if a target is alive. If so this function must return nil.
type Func func() error
// New returns a pointer to an initialized Probe.
func New() *Probe { return &Probe{} }
// Do will probe target, if a probe is already in progress this is a noop.
func (p *Probe) Do(f Func) {
p.Lock()
if p.inprogress != idle {
p.Unlock()
return
}
p.inprogress = active
interval := p.interval
p.Unlock()
// Passed the lock. Now run f for as long it returns false. If a true is returned
// we return from the goroutine and we can accept another Func to run.
go func() {
i := 1
for {
if err := f(); err == nil {
break
}
time.Sleep(interval)
if i%2 == 0 && i < 4 { // 4 is 2 doubles, so no need to increase anymore - this is *also* checked in double()
p.double()
}
p.Lock()
if p.inprogress == stop {
p.Unlock()
return
}
p.Unlock()
i++
}
p.Lock()
p.inprogress = idle
p.Unlock()
}()
}
func (p *Probe) double() {
p.Lock()
p.interval *= 2
if p.interval > p.max {
p.interval = p.max
}
p.Unlock()
}
// Stop stops the probing.
func (p *Probe) Stop() {
p.Lock()
p.inprogress = stop
p.Unlock()
}
// Start will initialize the probe manager, after which probes can be initiated with Do.
func (p *Probe) Start(interval time.Duration) {
p.Lock()
p.interval = interval
p.max = interval * multiplier
p.Unlock()
}
const (
idle = iota
active
stop
multiplier = 4
)