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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
package test
import (
"bytes"
"fmt"
"io/ioutil"
"net/http"
"strings"
"testing"
"time"
"github.com/miekg/dns"
)
func TestReload(t *testing.T) {
corefile := `.:0 {
whoami
}
`
coreInput := NewInput(corefile)
c, err := CoreDNSServer(corefile)
if err != nil {
t.Fatalf("Could not get CoreDNS serving instance: %s", err)
}
udp, _ := CoreDNSServerPorts(c, 0)
send(t, udp)
c1, err := c.Restart(coreInput)
if err != nil {
t.Fatal(err)
}
udp, _ = CoreDNSServerPorts(c1, 0)
send(t, udp)
c1.Stop()
}
func send(t *testing.T, server string) {
m := new(dns.Msg)
m.SetQuestion("whoami.example.org.", dns.TypeSRV)
r, err := dns.Exchange(m, server)
if err != nil {
// This seems to fail a lot on travis, quick'n dirty: redo
r, err = dns.Exchange(m, server)
if err != nil {
return
}
}
if r.Rcode != dns.RcodeSuccess {
t.Fatalf("Expected successful reply, got %s", dns.RcodeToString[r.Rcode])
}
if len(r.Extra) != 2 {
t.Fatalf("Expected 2 RRs in additional, got %d", len(r.Extra))
}
}
func TestReloadHealth(t *testing.T) {
corefile := `
.:0 {
health 127.0.0.1:52182
whoami
}`
c, err := CoreDNSServer(corefile)
if err != nil {
if strings.Contains(err.Error(), inUse) {
return // meh, but don't error
}
t.Fatalf("Could not get service instance: %s", err)
}
if c1, err := c.Restart(NewInput(corefile)); err != nil {
t.Fatal(err)
} else {
c1.Stop()
}
}
func TestReloadMetricsHealth(t *testing.T) {
corefile := `
.:0 {
prometheus 127.0.0.1:53183
health 127.0.0.1:53184
whoami
}`
c, err := CoreDNSServer(corefile)
if err != nil {
if strings.Contains(err.Error(), inUse) {
return // meh, but don't error
}
t.Fatalf("Could not get service instance: %s", err)
}
c1, err := c.Restart(NewInput(corefile))
if err != nil {
t.Fatal(err)
}
defer c1.Stop()
time.Sleep(1 * time.Second)
// Health
resp, err := http.Get("http://localhost:53184/health")
if err != nil {
t.Fatal(err)
}
ok, _ := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if string(ok) != "OK" {
t.Errorf("Failed to receive OK, got %s", ok)
}
// Metrics
resp, err = http.Get("http://localhost:53183/metrics")
if err != nil {
t.Fatal(err)
}
const proc = "process_virtual_memory_bytes"
metrics, _ := ioutil.ReadAll(resp.Body)
if !bytes.Contains(metrics, []byte(proc)) {
t.Errorf("Failed to see %s in metric output", proc)
}
}
func collectMetricsInfo(addr, proc string) error {
cl := &http.Client{}
resp, err := cl.Get(fmt.Sprintf("http://%s/metrics", addr))
if err != nil {
return err
}
metrics, _ := ioutil.ReadAll(resp.Body)
if !bytes.Contains(metrics, []byte(proc)) {
return fmt.Errorf("failed to see %s in metric output", proc)
}
return nil
}
// TestReloadSeveralTimeMetrics ensures that metrics are not pushed to
// prometheus once the metrics plugin is removed and a coredns
// reload is triggered
// 1. check that metrics have not been exported to prometheus before coredns starts
// 2. ensure that build-related metrics have been exported once coredns starts
// 3. trigger multiple reloads without changing the corefile
// 4. remove the metrics plugin and trigger a final reload
// 5. ensure the original prometheus exporter has not received more metrics
func TestReloadSeveralTimeMetrics(t *testing.T) {
//TODO: add a tool that find an available port because this needs to be a port
// that is not used in another test
promAddress := "127.0.0.1:53185"
proc := "coredns_build_info"
corefileWithMetrics := `
.:0 {
prometheus ` + promAddress + `
whoami
}`
corefileWithoutMetrics := `
.:0 {
whoami
}`
if err := collectMetricsInfo(promAddress, proc); err == nil {
t.Errorf("Prometheus is listening before the test started")
}
serverWithMetrics, err := CoreDNSServer(corefileWithMetrics)
if err != nil {
if strings.Contains(err.Error(), inUse) {
return
}
t.Errorf("Could not get service instance: %s", err)
}
// verify prometheus is running
if err := collectMetricsInfo(promAddress, proc); err != nil {
t.Errorf("Prometheus is not listening : %s", err)
}
reloadCount := 2
for i := 0; i < reloadCount; i++ {
serverReload, err := serverWithMetrics.Restart(
NewInput(corefileWithMetrics),
)
if err != nil {
t.Errorf("Could not restart CoreDNS : %s, at loop %v", err, i)
}
if err := collectMetricsInfo(promAddress, proc); err != nil {
t.Errorf("Prometheus is not listening : %s", err)
}
serverWithMetrics = serverReload
}
// reload without prometheus
serverWithoutMetrics, err := serverWithMetrics.Restart(
NewInput(corefileWithoutMetrics),
)
if err != nil {
t.Errorf("Could not restart a second time CoreDNS : %s", err)
}
serverWithoutMetrics.Stop()
// verify that metrics have not been pushed
if err := collectMetricsInfo(promAddress, proc); err == nil {
t.Errorf("Prometheus is still listening")
}
}
const inUse = "address already in use"
|
