Repository navigation
Expand file tree
/
Copy pathhandler_test.go
More file actions
438 lines (416 loc) · 13.9 KB
/
Copy pathhandler_test.go
File metadata and controls
438 lines (416 loc) · 13.9 KB
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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
//go:build linux || darwin || dragonfly || freebsd || netbsd || openbsd || windows
package websocket
import (
"bufio"
"bytes"
"crypto/sha1"
"encoding/base64"
"errors"
"fmt"
"io"
"net"
stdhttp "net/http"
"sync"
"sync/atomic"
"testing"
"time"
fib "github.com/lesismal/fib"
)
func TestServerHandshakeEchoPingAndClose(t *testing.T) {
handler := NewHandler(HandlerFuncs{
Message: func(c *Connection, opcode Opcode, payload []byte) {
if err := c.WriteMessage(opcode, payload); err != nil {
t.Error(err)
}
},
})
config := fib.DefaultConfig()
server, err := fib.New(config, fib.Binding{Addr: "127.0.0.1:0", Handler: handler})
if err != nil {
t.Fatal(err)
}
addr, err := server.LocalAddr()
if err != nil {
t.Fatal(err)
}
runDone := make(chan error, 1)
go func() { runDone <- server.Run() }()
defer func() {
server.Stop()
<-runDone
_ = server.Close()
}()
conn, err := net.DialTimeout("tcp4", addr.String(), 5*time.Second)
if err != nil {
t.Fatal(err)
}
defer conn.Close()
_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
key := base64.StdEncoding.EncodeToString([]byte("0123456789abcdef"))
request := "GET /chat HTTP/1.1\r\nHost: test\r\nUpgrade: websocket\r\nConnection: keep-alive, Upgrade\r\n" +
"Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: " + key + "\r\n\r\n"
if _, err = io.WriteString(conn, request); err != nil {
t.Fatal(err)
}
reader := bufio.NewReader(conn)
response, err := stdhttp.ReadResponse(reader, &stdhttp.Request{Method: stdhttp.MethodGet})
if err != nil {
t.Fatal(err)
}
sum := sha1.Sum([]byte(key + websocketGUID))
wantAccept := base64.StdEncoding.EncodeToString(sum[:])
if response.StatusCode != stdhttp.StatusSwitchingProtocols ||
response.Header.Get("Sec-WebSocket-Accept") != wantAccept {
t.Fatalf("invalid handshake: status=%d accept=%q", response.StatusCode, response.Header.Get("Sec-WebSocket-Accept"))
}
frames := append(clientFrame(Text, true, []byte("hello")), clientFrame(Ping, true, []byte("p"))...)
frames = append(frames, clientFrame(Close, true, []byte{0x03, 0xe8})...)
if _, err = conn.Write(frames); err != nil {
t.Fatal(err)
}
for _, expected := range []Opcode{Text, Pong, Close} {
opcode, _, err := readServerFrame(reader)
if err != nil {
t.Fatal(err)
}
if opcode != expected {
t.Fatalf("opcode = %d, want %d", opcode, expected)
}
}
}
func BenchmarkMinimalServerHandshake(b *testing.B) {
handler := NewHandler(HandlerFuncs{Message: func(*Connection, Opcode, []byte) {}})
b.ReportAllocs()
b.SetBytes(int64(len(benchmarkHandshakeRequest)))
for i := 0; i < b.N; i++ {
key, _, remainder, complete, err := handler.validateMinimalHandshake(benchmarkHandshakeRequest)
if err != nil || !complete || len(key) != 24 || len(remainder) != 0 {
b.Fatalf("minimal handshake: key=%q remainder=%d complete=%v err=%v", key, len(remainder), complete, err)
}
}
}
func readServerFrame(reader *bufio.Reader) (Opcode, []byte, error) {
header := make([]byte, 2)
if _, err := io.ReadFull(reader, header); err != nil {
return 0, nil, err
}
length := uint64(header[1] & 0x7f)
if length == 126 {
size := make([]byte, 2)
if _, err := io.ReadFull(reader, size); err != nil {
return 0, nil, err
}
length = uint64(size[0])<<8 | uint64(size[1])
} else if length == 127 {
size := make([]byte, 8)
if _, err := io.ReadFull(reader, size); err != nil {
return 0, nil, err
}
length = 0
for _, value := range size {
length = length<<8 | uint64(value)
}
}
payload := make([]byte, int(length))
_, err := io.ReadFull(reader, payload)
return Opcode(header[0] & 0xf), payload, err
}
// dialUpgraded opens a connection and completes the WebSocket handshake.
func dialUpgraded(tb testing.TB, addr string) (net.Conn, *bufio.Reader) {
tb.Helper()
conn, err := net.DialTimeout("tcp4", addr, 5*time.Second)
if err != nil {
tb.Fatal(err)
}
_ = conn.SetDeadline(time.Now().Add(60 * time.Second))
key := base64.StdEncoding.EncodeToString([]byte("0123456789abcdef"))
request := "GET /chat HTTP/1.1\r\nHost: test\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" +
"Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: " + key + "\r\n\r\n"
if _, err = io.WriteString(conn, request); err != nil {
tb.Fatal(err)
}
reader := bufio.NewReader(conn)
response, err := stdhttp.ReadResponse(reader, &stdhttp.Request{Method: stdhttp.MethodGet})
if err != nil {
tb.Fatal(err)
}
if response.StatusCode != stdhttp.StatusSwitchingProtocols {
tb.Fatalf("handshake status = %d, want %d", response.StatusCode, stdhttp.StatusSwitchingProtocols)
}
return conn, reader
}
// BenchmarkServerEcho1KiB drives the server the way a load generator does:
// several connections each keeping messages in flight, so one read usually
// carries more than one frame and one round answers more than one message. It
// covers parsing and the reply write path together, which per-frame benchmarks
// cannot. Client and server share the process, so treat the result as a
// relative measure rather than an absolute server cost.
func BenchmarkServerEcho1KiB(b *testing.B) {
const connections = 8
handler := NewHandler(HandlerFuncs{
Message: func(c *Connection, opcode Opcode, payload []byte) {
_ = c.WriteMessage(opcode, payload)
},
})
config := fib.DefaultConfig()
server, err := fib.New(config, fib.Binding{Addr: "127.0.0.1:0", Handler: handler})
if err != nil {
b.Fatal(err)
}
addr, err := server.LocalAddr()
if err != nil {
b.Fatal(err)
}
runDone := make(chan error, 1)
go func() { runDone <- server.Run() }()
defer func() {
server.Stop()
<-runDone
_ = server.Close()
}()
frame := clientFrame(Binary, true, make([]byte, 1024))
perConnection := (b.N + connections - 1) / connections
conns := make([]net.Conn, connections)
readers := make([]*bufio.Reader, connections)
for i := range conns {
conns[i], readers[i] = dialUpgraded(b, addr.String())
defer conns[i].Close()
}
b.SetBytes(1024)
b.ResetTimer()
var wg sync.WaitGroup
for i := 0; i < connections; i++ {
wg.Add(2)
go func(conn net.Conn) {
defer wg.Done()
for sent := 0; sent < perConnection; sent++ {
if _, err := conn.Write(frame); err != nil {
b.Error(err)
return
}
}
}(conns[i])
go func(reader *bufio.Reader) {
defer wg.Done()
for received := 0; received < perConnection; received++ {
if _, _, err := readServerFrame(reader); err != nil {
b.Error(err)
return
}
}
}(readers[i])
}
wg.Wait()
b.StopTimer()
}
// dialWebSocket opens a connection and completes the handshake, returning the
// connection and the buffered reader the handshake response was read through.
// Anything the server sends afterwards has to be read through that reader,
// since it may already hold the first bytes of it.
func dialWebSocket(t *testing.T, addr string) (net.Conn, *bufio.Reader) {
t.Helper()
conn, err := net.DialTimeout("tcp4", addr, 5*time.Second)
if err != nil {
t.Fatal(err)
}
if err = conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
t.Fatal(err)
}
key := base64.StdEncoding.EncodeToString([]byte("0123456789abcdef"))
request := "GET /chat HTTP/1.1\r\nHost: test\r\nUpgrade: websocket\r\nConnection: keep-alive, Upgrade\r\n" +
"Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: " + key + "\r\n\r\n"
if _, err = io.WriteString(conn, request); err != nil {
conn.Close()
t.Fatal(err)
}
reader := bufio.NewReader(conn)
response, err := stdhttp.ReadResponse(reader, &stdhttp.Request{Method: stdhttp.MethodGet})
if err != nil {
conn.Close()
t.Fatal(err)
}
if response.StatusCode != stdhttp.StatusSwitchingProtocols {
conn.Close()
t.Fatalf("handshake status = %d, want %d", response.StatusCode, stdhttp.StatusSwitchingProtocols)
}
return conn, reader
}
// A peer that only ever sends must not be able to make the server read without
// limit. Its replies cannot leave, so they queue; once that queue crosses the
// write watermark the server has to stop reading this connection and let the
// backlog push back through TCP to the peer itself. Reading on regardless is
// what turns one silent peer into unbounded memory on the server.
//
// The pause is only correct if it is a pause, so the test carries on past it:
// once the peer starts reading, the server has to pick its connection back up
// on its own.
func TestReadsPauseForPeerThatNeverReadsAndResumeWhenItDoes(t *testing.T) {
const (
watermark = 64 << 10
payloadSize = 8 << 10
// Far more than the watermark and both kernel socket buffers together,
// so reaching it means nothing ever stopped the server reading.
maxWrite = 64 << 20
)
var received atomic.Int64
// What the server saw go wrong, for a failure to explain itself.
var serverSaw atomic.Value
handler := NewHandler(HandlerFuncs{
Message: func(c *Connection, opcode Opcode, payload []byte) {
received.Add(int64(len(payload)))
if err := c.WriteMessage(opcode, payload); err != nil {
serverSaw.CompareAndSwap(nil, "write failed: "+err.Error())
_ = c.Close(CloseInternalError, "write failed")
}
},
Close: func(_ *Connection, code uint16, reason string, err error) {
serverSaw.CompareAndSwap(nil, fmt.Sprintf("closed: code %d, reason %q, error %v", code, reason, err))
},
})
config := fib.DefaultConfig()
config.WriteBufferHighWatermark = watermark
// Leave the server-wide budget off, so the per-connection watermark is the
// only thing that can stop these reads.
config.MaxPendingBytes = 0
server, err := fib.New(config, fib.Binding{Addr: "127.0.0.1:0", Handler: handler})
if err != nil {
t.Fatal(err)
}
addr, err := server.LocalAddr()
if err != nil {
t.Fatal(err)
}
runDone := make(chan error, 1)
go func() { runDone <- server.Run() }()
defer func() {
server.Stop()
<-runDone
_ = server.Close()
}()
conn, reader := dialWebSocket(t, addr.String())
defer conn.Close()
// Send, and never read. Every reply the server produces stays in its queue
// and in the socket buffers between the two.
frame := clientFrame(Binary, true, bytes.Repeat([]byte{'x'}, payloadSize))
written := 0
blocked := false
for written < maxWrite {
if err = conn.SetWriteDeadline(time.Now().Add(3 * time.Second)); err != nil {
t.Fatal(err)
}
n, writeErr := conn.Write(frame)
written += n
if writeErr == nil {
continue
}
var netErr net.Error
if errors.As(writeErr, &netErr) && netErr.Timeout() {
blocked = true
break
}
t.Fatalf("after %d bytes: %v", written, writeErr)
}
if !blocked {
t.Fatalf("wrote %d bytes without ever blocking: the server never stopped reading (it read %d, and saw: %v)",
written, received.Load(), serverSaw.Load())
}
if received.Load() == 0 {
t.Fatal("the server read nothing at all; the test never exercised the pause")
}
// Blocked on write means the pushback reached this end, so the server is
// not reading this connection any more. It must stay that way while the
// peer keeps ignoring its replies.
paused := received.Load()
time.Sleep(500 * time.Millisecond)
if grown := received.Load(); grown != paused {
t.Fatalf("server read %d more bytes while the peer was not reading, want the reads to stay paused",
grown-paused)
}
// Now drain. The replies leave, the queue falls back under the watermark,
// and the server has to resume reading what the peer already sent. The
// peer reads until the test is done, through any quiet spell: one that
// gave up after a second of silence could stop draining while a loaded
// server was slow to send, and leave it paused on the peer's account.
var drained atomic.Int64
drainDone := make(chan struct{})
go func() {
defer close(drainDone)
buf := make([]byte, 32<<10)
for {
if err := conn.SetReadDeadline(time.Now().Add(time.Second)); err != nil {
return
}
n, err := reader.Read(buf)
drained.Add(int64(n))
var netErr net.Error
if err != nil && !(errors.As(err, &netErr) && netErr.Timeout()) {
return
}
}
}()
deadline := time.Now().Add(10 * time.Second)
for received.Load() == paused && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
conn.Close()
<-drainDone
if resumed := received.Load(); resumed == paused {
t.Fatalf("server read nothing more after pausing at %d bytes, while the peer drained %d bytes of replies; the pause never lifted",
paused, drained.Load())
}
}
// TestServerDeliversFramesToFrameHandler drives a server whose handler takes
// frames: every frame of a fragmented message reaches Frame as it arrives,
// carrying the message's opcode and its fin, and Message is not called at all.
func TestServerDeliversFramesToFrameHandler(t *testing.T) {
handler := NewHandler(HandlerFuncs{
Message: func(*Connection, Opcode, []byte) {
t.Error("Message ran for a handler that takes frames")
},
Frame: func(c *Connection, opcode Opcode, fin bool, payload []byte) {
reply := make([]byte, 0, len(payload)+1)
if fin {
reply = append(reply, '1')
} else {
reply = append(reply, '0')
}
if err := c.WriteMessage(opcode, append(reply, payload...)); err != nil {
t.Error(err)
}
},
})
config := fib.DefaultConfig()
server, err := fib.New(config, fib.Binding{Addr: "127.0.0.1:0", Handler: handler})
if err != nil {
t.Fatal(err)
}
addr, err := server.LocalAddr()
if err != nil {
t.Fatal(err)
}
runDone := make(chan error, 1)
go func() { runDone <- server.Run() }()
defer func() {
server.Stop()
<-runDone
_ = server.Close()
}()
conn, reader := dialUpgraded(t, addr.String())
defer conn.Close()
frames := clientFrame(Text, false, []byte("hel"))
frames = append(frames, clientFrame(Continuation, false, []byte("lo "))...)
frames = append(frames, clientFrame(Continuation, true, []byte("world"))...)
frames = append(frames, clientFrame(Text, true, []byte("!"))...)
if _, err = conn.Write(frames); err != nil {
t.Fatal(err)
}
for _, want := range []string{"0hel", "0lo ", "1world", "1!"} {
opcode, payload, err := readServerFrame(reader)
if err != nil {
t.Fatal(err)
}
if opcode != Text || string(payload) != want {
t.Fatalf("frame = opcode %d %q, want Text %q", opcode, payload, want)
}
}
}