GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/cloudflared

Public

mirrored from https://github.com/cloudflare/cloudflaredAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
2021.11.0

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

cloudflared/edgediscovery

edgediscovery/edgediscovery_test.go

197lines · modecode

RawDownload
Latest commit unavailable.
1package edgediscovery
2
3import (
4 "net"
5 "testing"
6
7 "github.com/rs/zerolog"
8 "github.com/stretchr/testify/assert"
9
10 "github.com/cloudflare/cloudflared/edgediscovery/allregions"
11)
12
13var (
14 addr0 = allregions.EdgeAddr{
15 TCP: &net.TCPAddr{
16 IP: net.ParseIP("123.0.0.0"),
17 Port: 8000,
18 Zone: "",
19 },
20 UDP: &net.UDPAddr{
21 IP: net.ParseIP("123.0.0.0"),
22 Port: 8000,
23 Zone: "",
24 },
25 }
26 addr1 = allregions.EdgeAddr{
27 TCP: &net.TCPAddr{
28 IP: net.ParseIP("123.0.0.1"),
29 Port: 8000,
30 Zone: "",
31 },
32 UDP: &net.UDPAddr{
33 IP: net.ParseIP("123.0.0.1"),
34 Port: 8000,
35 Zone: "",
36 },
37 }
38 addr2 = allregions.EdgeAddr{
39 TCP: &net.TCPAddr{
40 IP: net.ParseIP("123.0.0.2"),
41 Port: 8000,
42 Zone: "",
43 },
44 UDP: &net.UDPAddr{
45 IP: net.ParseIP("123.0.0.2"),
46 Port: 8000,
47 Zone: "",
48 },
49 }
50 addr3 = allregions.EdgeAddr{
51 TCP: &net.TCPAddr{
52 IP: net.ParseIP("123.0.0.3"),
53 Port: 8000,
54 Zone: "",
55 },
56 UDP: &net.UDPAddr{
57 IP: net.ParseIP("123.0.0.3"),
58 Port: 8000,
59 Zone: "",
60 },
61 }
62
63 testLogger = zerolog.Nop()
64)
65
66func TestGiveBack(t *testing.T) {
67 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0, &addr1, &addr2, &addr3})
68
69 // Give this connection an address
70 assert.Equal(t, 4, edge.AvailableAddrs())
71 const connID = 0
72 addr, err := edge.GetAddr(connID)
73 assert.NoError(t, err)
74 assert.NotNil(t, addr)
75 assert.Equal(t, 3, edge.AvailableAddrs())
76
77 // Get it back
78 edge.GiveBack(addr)
79 assert.Equal(t, 4, edge.AvailableAddrs())
80}
81
82func TestRPCAndProxyShareSingleEdgeIP(t *testing.T) {
83 // Make an edge with a single IP
84 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0})
85 tunnelConnID := 0
86
87 // Use the IP for a tunnel
88 addrTunnel, err := edge.GetAddr(tunnelConnID)
89 assert.NoError(t, err)
90
91 // Ensure the IP can be used for RPC too
92 addrRPC, err := edge.GetAddrForRPC()
93 assert.NoError(t, err)
94 assert.Equal(t, addrTunnel, addrRPC)
95}
96
97func TestGetAddrForRPC(t *testing.T) {
98 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0, &addr1, &addr2, &addr3})
99
100 // Get a connection
101 assert.Equal(t, 4, edge.AvailableAddrs())
102 addr, err := edge.GetAddrForRPC()
103 assert.NoError(t, err)
104 assert.NotNil(t, addr)
105
106 // Using an address for RPC shouldn't consume it
107 assert.Equal(t, 4, edge.AvailableAddrs())
108
109 // Get it back
110 edge.GiveBack(addr)
111 assert.Equal(t, 4, edge.AvailableAddrs())
112}
113
114func TestOnePerRegion(t *testing.T) {
115 // Make an edge with only one address
116 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0, &addr1})
117
118 // Use the only address
119 const connID = 0
120 a1, err := edge.GetAddr(connID)
121 assert.NoError(t, err)
122 assert.NotNil(t, a1)
123
124 // if the first address is bad, get the second one
125 a2, err := edge.GetDifferentAddr(connID)
126 assert.NoError(t, err)
127 assert.NotNil(t, a2)
128 assert.NotEqual(t, a1, a2)
129
130 // now that second one is bad, get the first one again
131 a3, err := edge.GetDifferentAddr(connID)
132 assert.NoError(t, err)
133 assert.Equal(t, a1, a3)
134}
135
136func TestOnlyOneAddrLeft(t *testing.T) {
137 // Make an edge with only one address
138 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0})
139
140 // Use the only address
141 const connID = 0
142 addr, err := edge.GetAddr(connID)
143 assert.NoError(t, err)
144 assert.NotNil(t, addr)
145
146 // If that edge address is "bad", there's no alternative address.
147 _, err = edge.GetDifferentAddr(connID)
148 assert.Error(t, err)
149
150 // previously bad address should become available again on next iteration.
151 addr, err = edge.GetDifferentAddr(connID)
152 assert.NoError(t, err)
153 assert.NotNil(t, addr)
154}
155
156func TestNoAddrsLeft(t *testing.T) {
157 // Make an edge with no addresses
158 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{})
159
160 _, err := edge.GetAddr(2)
161 assert.Error(t, err)
162 _, err = edge.GetAddrForRPC()
163 assert.Error(t, err)
164}
165
166func TestGetAddr(t *testing.T) {
167 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0, &addr1, &addr2, &addr3})
168
169 // Give this connection an address
170 const connID = 0
171 addr, err := edge.GetAddr(connID)
172 assert.NoError(t, err)
173 assert.NotNil(t, addr)
174
175 // If the same connection requests another address, it should get the same one.
176 addr2, err := edge.GetAddr(connID)
177 assert.NoError(t, err)
178 assert.Equal(t, addr, addr2)
179}
180
181func TestGetDifferentAddr(t *testing.T) {
182 edge := MockEdge(&testLogger, []*allregions.EdgeAddr{&addr0, &addr1, &addr2, &addr3})
183
184 // Give this connection an address
185 assert.Equal(t, 4, edge.AvailableAddrs())
186 const connID = 0
187 addr, err := edge.GetAddr(connID)
188 assert.NoError(t, err)
189 assert.NotNil(t, addr)
190 assert.Equal(t, 3, edge.AvailableAddrs())
191
192 // If the same connection requests another address, it should get the same one.
193 addr2, err := edge.GetDifferentAddr(connID)
194 assert.NoError(t, err)
195 assert.NotEqual(t, addr, addr2)
196 assert.Equal(t, 3, edge.AvailableAddrs())
197}
198