-
Notifications
You must be signed in to change notification settings - Fork 2
/
dummy.go
111 lines (92 loc) · 2.17 KB
/
dummy.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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package scheme
import (
"context"
"errors"
"math/rand"
"net/url"
"strings"
"time"
api "github.com/macrat/ayd/lib-ayd"
)
type DummyScheme struct {
target *api.URL
random bool
status api.Status
latency time.Duration
message string
}
func NewDummyScheme(u *api.URL) (DummyScheme, error) {
s := DummyScheme{target: &api.URL{Scheme: u.Scheme, Opaque: u.Opaque, Fragment: u.Fragment}}
if u.Opaque == "" {
s.target.Opaque = u.Host
}
s.target.Opaque = strings.ToLower(s.target.Opaque)
switch s.target.Opaque {
case "", "healthy":
s.status = api.StatusHealthy
case "degrade":
s.status = api.StatusDegrade
case "failure":
s.status = api.StatusFailure
case "aborted":
s.status = api.StatusAborted
case "unknown":
s.status = api.StatusUnknown
case "random":
s.random = true
default:
return DummyScheme{}, errors.New("opaque must healthy, degrade, failure, aborted, unknown, or random")
}
query := url.Values{}
if latency := u.ToURL().Query().Get("latency"); latency != "" {
d, err := time.ParseDuration(latency)
if err != nil {
return DummyScheme{}, err
}
s.latency = d
query.Set("latency", d.String())
}
if message := u.ToURL().Query().Get("message"); message != "" {
s.message = message
query.Set("message", message)
}
s.target.RawQuery = query.Encode()
return s, nil
}
func (s DummyScheme) Status() api.Status {
if !s.random {
return s.status
}
return []api.Status{
api.StatusHealthy,
api.StatusDegrade,
api.StatusFailure,
api.StatusUnknown,
}[rand.Intn(4)]
}
func (s DummyScheme) Target() *api.URL {
return s.target
}
func (s DummyScheme) Probe(ctx context.Context, r Reporter) {
stime := time.Now()
latency := s.latency
if s.target.ToURL().Query().Get("latency") == "" {
latency = time.Duration(rand.Intn(10000)) * time.Microsecond
}
rec := api.Record{
Time: stime,
Status: s.Status(),
Target: s.target,
Latency: latency,
Message: s.message,
}
select {
case <-time.After(latency):
case <-ctx.Done():
rec.Latency = time.Since(stime)
}
r.Report(s.target, timeoutOr(ctx, rec))
}
func (s DummyScheme) Alert(ctx context.Context, r Reporter, _ api.Record) {
s.Probe(ctx, AlertReporter{s.target, r})
}