forked from quic-go/quic-go
Move proxy/ to new tools/ folder
This commit is contained in:
Lucas Clemente
227
integrationtests/tools/proxy/proxy.go
Normal file
227
integrationtests/tools/proxy/proxy.go
Normal file
@@ -0,0 +1,227 @@
|
||||
package quicproxy
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"net"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/lucas-clemente/quic-go"
|
||||
"github.com/lucas-clemente/quic-go/protocol"
|
||||
)
|
||||
|
||||
// Connection is a UDP connection
|
||||
type connection struct {
|
||||
ClientAddr *net.UDPAddr // Address of the client
|
||||
ServerConn *net.UDPConn // UDP connection to server
|
||||
|
||||
incomingPacketCounter uint64
|
||||
outgoingPacketCounter uint64
|
||||
}
|
||||
|
||||
// Direction is the direction a packet is sent.
|
||||
type Direction int
|
||||
|
||||
const (
|
||||
// DirectionIncoming is the direction from the client to the server.
|
||||
DirectionIncoming Direction = iota
|
||||
// DirectionOutgoing is the direction from the server to the client.
|
||||
DirectionOutgoing
|
||||
)
|
||||
|
||||
// DropCallback is a callback that determines which packet gets dropped.
|
||||
type DropCallback func(Direction, protocol.PacketNumber) bool
|
||||
|
||||
// NoDropper doesn't drop packets.
|
||||
var NoDropper DropCallback = func(Direction, protocol.PacketNumber) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
// DelayCallback is a callback that determines how much delay to apply to a packet.
|
||||
type DelayCallback func(Direction, protocol.PacketNumber) time.Duration
|
||||
|
||||
// NoDelay doesn't apply a delay.
|
||||
var NoDelay DelayCallback = func(Direction, protocol.PacketNumber) time.Duration {
|
||||
return 0
|
||||
}
|
||||
|
||||
// Opts are proxy options.
|
||||
type Opts struct {
|
||||
// The address this proxy proxies packets to.
|
||||
RemoteAddr string
|
||||
// DropPacket determines whether a packet gets dropped.
|
||||
DropPacket DropCallback
|
||||
// DelayPacket determines how long a packet gets delayed. This allows
|
||||
// simulating a connection with non-zero RTTs.
|
||||
// Note that the RTT is the sum of the delay for the incoming and the outgoing packet.
|
||||
DelayPacket DelayCallback
|
||||
}
|
||||
|
||||
// QuicProxy is a QUIC proxy that can drop and delay packets.
|
||||
type QuicProxy struct {
|
||||
mutex sync.Mutex
|
||||
|
||||
conn *net.UDPConn
|
||||
serverAddr *net.UDPAddr
|
||||
|
||||
dropPacket DropCallback
|
||||
delayPacket DelayCallback
|
||||
|
||||
// Mapping from client addresses (as host:port) to connection
|
||||
clientDict map[string]*connection
|
||||
}
|
||||
|
||||
// NewQuicProxy creates a new UDP proxy
|
||||
func NewQuicProxy(local string, opts Opts) (*QuicProxy, error) {
|
||||
laddr, err := net.ResolveUDPAddr("udp", local)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
conn, err := net.ListenUDP("udp", laddr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
raddr, err := net.ResolveUDPAddr("udp", opts.RemoteAddr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
packetDropper := NoDropper
|
||||
if opts.DropPacket != nil {
|
||||
packetDropper = opts.DropPacket
|
||||
}
|
||||
|
||||
packetDelayer := NoDelay
|
||||
if opts.DelayPacket != nil {
|
||||
packetDelayer = opts.DelayPacket
|
||||
}
|
||||
|
||||
p := QuicProxy{
|
||||
clientDict: make(map[string]*connection),
|
||||
conn: conn,
|
||||
serverAddr: raddr,
|
||||
dropPacket: packetDropper,
|
||||
delayPacket: packetDelayer,
|
||||
}
|
||||
|
||||
go p.runProxy()
|
||||
return &p, nil
|
||||
}
|
||||
|
||||
// Close stops the UDP Proxy
|
||||
func (p *QuicProxy) Close() error {
|
||||
return p.conn.Close()
|
||||
}
|
||||
|
||||
// LocalAddr is the address the proxy is listening on.
|
||||
func (p *QuicProxy) LocalAddr() net.Addr {
|
||||
return p.conn.LocalAddr()
|
||||
}
|
||||
|
||||
func (p *QuicProxy) LocalPort() int {
|
||||
return p.conn.LocalAddr().(*net.UDPAddr).Port
|
||||
}
|
||||
|
||||
func (p *QuicProxy) newConnection(cliAddr *net.UDPAddr) (*connection, error) {
|
||||
srvudp, err := net.DialUDP("udp", nil, p.serverAddr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &connection{
|
||||
ClientAddr: cliAddr,
|
||||
ServerConn: srvudp,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// runProxy listens on the proxy address and handles incoming packets.
|
||||
func (p *QuicProxy) runProxy() error {
|
||||
for {
|
||||
buffer := make([]byte, protocol.MaxPacketSize)
|
||||
n, cliaddr, err := p.conn.ReadFromUDP(buffer)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
raw := buffer[0:n]
|
||||
|
||||
saddr := cliaddr.String()
|
||||
p.mutex.Lock()
|
||||
conn, ok := p.clientDict[saddr]
|
||||
|
||||
if !ok {
|
||||
conn, err = p.newConnection(cliaddr)
|
||||
if err != nil {
|
||||
p.mutex.Unlock()
|
||||
return err
|
||||
}
|
||||
p.clientDict[saddr] = conn
|
||||
go p.runConnection(conn)
|
||||
}
|
||||
p.mutex.Unlock()
|
||||
|
||||
atomic.AddUint64(&conn.incomingPacketCounter, 1)
|
||||
|
||||
r := bytes.NewReader(raw)
|
||||
hdr, err := quic.ParsePublicHeader(r, protocol.PerspectiveClient)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if p.dropPacket(DirectionIncoming, hdr.PacketNumber) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Send the packet to the server
|
||||
delay := p.delayPacket(DirectionIncoming, hdr.PacketNumber)
|
||||
if delay != 0 {
|
||||
time.AfterFunc(delay, func() {
|
||||
// TODO: handle error
|
||||
_, _ = conn.ServerConn.Write(raw)
|
||||
})
|
||||
} else {
|
||||
_, err := conn.ServerConn.Write(raw)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// runConnection handles packets from server to a single client
|
||||
func (p *QuicProxy) runConnection(conn *connection) error {
|
||||
for {
|
||||
buffer := make([]byte, protocol.MaxPacketSize)
|
||||
n, err := conn.ServerConn.Read(buffer)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
raw := buffer[0:n]
|
||||
|
||||
// TODO: Switch back to using the public header once Chrome properly sets the type byte.
|
||||
// r := bytes.NewReader(raw)
|
||||
// , err := quic.ParsePublicHeader(r, protocol.PerspectiveServer)
|
||||
// if err != nil {
|
||||
// return err
|
||||
// }
|
||||
|
||||
v := atomic.AddUint64(&conn.outgoingPacketCounter, 1)
|
||||
|
||||
packetNumber := protocol.PacketNumber(v)
|
||||
if p.dropPacket(DirectionOutgoing, packetNumber) {
|
||||
continue
|
||||
}
|
||||
|
||||
delay := p.delayPacket(DirectionOutgoing, packetNumber)
|
||||
if delay != 0 {
|
||||
time.AfterFunc(delay, func() {
|
||||
// TODO: handle error
|
||||
_, _ = p.conn.WriteToUDP(raw, conn.ClientAddr)
|
||||
})
|
||||
} else {
|
||||
_, err := p.conn.WriteToUDP(raw, conn.ClientAddr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
13
integrationtests/tools/proxy/proxy_suite_test.go
Normal file
13
integrationtests/tools/proxy/proxy_suite_test.go
Normal file
@@ -0,0 +1,13 @@
|
||||
package quicproxy
|
||||
|
||||
import (
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestQuicGo(t *testing.T) {
|
||||
RegisterFailHandler(Fail)
|
||||
RunSpecs(t, "QUIC Proxy")
|
||||
}
|
||||
348
integrationtests/tools/proxy/proxy_test.go
Normal file
348
integrationtests/tools/proxy/proxy_test.go
Normal file
@@ -0,0 +1,348 @@
|
||||
package quicproxy
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"net"
|
||||
"strconv"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"fmt"
|
||||
|
||||
"github.com/lucas-clemente/quic-go"
|
||||
"github.com/lucas-clemente/quic-go/protocol"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
type packetData []byte
|
||||
|
||||
var _ = Describe("QUIC Proxy", func() {
|
||||
var serverAddr string
|
||||
|
||||
makePacket := func(p protocol.PacketNumber, payload []byte) []byte {
|
||||
b := &bytes.Buffer{}
|
||||
hdr := quic.PublicHeader{
|
||||
PacketNumber: p,
|
||||
PacketNumberLen: protocol.PacketNumberLen6,
|
||||
ConnectionID: 1337,
|
||||
TruncateConnectionID: false,
|
||||
}
|
||||
hdr.Write(b, protocol.VersionWhatever, protocol.PerspectiveServer)
|
||||
raw := b.Bytes()
|
||||
raw = append(raw, payload...)
|
||||
return raw
|
||||
}
|
||||
|
||||
BeforeEach(func() {
|
||||
serverAddr = "localhost:7331"
|
||||
})
|
||||
|
||||
Context("Proxy setup and teardown", func() {
|
||||
It("sets up the UDPProxy", func() {
|
||||
proxy, err := NewQuicProxy("localhost:0", Opts{RemoteAddr: serverAddr})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(proxy.clientDict).To(HaveLen(0))
|
||||
|
||||
// check that the proxy port is in use
|
||||
addr, err := net.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(proxy.LocalPort()))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
_, err = net.ListenUDP("udp", addr)
|
||||
Expect(err).To(MatchError(fmt.Sprintf("listen udp 127.0.0.1:%d: bind: address already in use", proxy.LocalPort())))
|
||||
Expect(proxy.Close()).To(Succeed()) // stopping is tested in the next test
|
||||
})
|
||||
|
||||
It("stops the UDPProxy", func() {
|
||||
proxy, err := NewQuicProxy("localhost:0", Opts{RemoteAddr: serverAddr})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
port := proxy.LocalPort()
|
||||
err = proxy.Close()
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
// check that the proxy port is not in use anymore
|
||||
addr, err := net.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(port))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
// sometimes it takes a while for the OS to free the port
|
||||
Eventually(func() error {
|
||||
ln, err := net.ListenUDP("udp", addr)
|
||||
defer ln.Close()
|
||||
return err
|
||||
}).ShouldNot(HaveOccurred())
|
||||
})
|
||||
|
||||
It("has the correct LocalAddr and LocalPort", func() {
|
||||
proxy, err := NewQuicProxy("localhost:0", Opts{RemoteAddr: serverAddr})
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
Expect(proxy.LocalAddr().String()).To(Equal("127.0.0.1:" + strconv.Itoa(proxy.LocalPort())))
|
||||
Expect(proxy.LocalPort()).ToNot(BeZero())
|
||||
|
||||
Expect(proxy.Close()).To(Succeed())
|
||||
})
|
||||
})
|
||||
|
||||
Context("Proxy tests", func() {
|
||||
var (
|
||||
serverConn *net.UDPConn
|
||||
serverReceivedPackets []packetData
|
||||
serverNumPacketsSent int
|
||||
clientConn *net.UDPConn
|
||||
proxy *QuicProxy
|
||||
)
|
||||
|
||||
startProxy := func(opts Opts) {
|
||||
var err error
|
||||
proxy, err = NewQuicProxy("localhost:0", opts)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
clientConn, err = net.DialUDP("udp", nil, proxy.LocalAddr().(*net.UDPAddr))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
}
|
||||
|
||||
BeforeEach(func() {
|
||||
serverReceivedPackets = serverReceivedPackets[:0]
|
||||
serverNumPacketsSent = 0
|
||||
|
||||
// setup a dump UDP server on port 7331
|
||||
// in production this would be a QUIC server
|
||||
raddr, err := net.ResolveUDPAddr("udp", serverAddr)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
serverConn, err = net.ListenUDP("udp", raddr)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
go func() {
|
||||
for {
|
||||
buf := make([]byte, protocol.MaxPacketSize)
|
||||
// the ReadFromUDP will error as soon as the UDP conn is closed
|
||||
n, addr, err2 := serverConn.ReadFromUDP(buf)
|
||||
if err2 != nil {
|
||||
return
|
||||
}
|
||||
data := buf[0:n]
|
||||
serverReceivedPackets = append(serverReceivedPackets, packetData(data))
|
||||
// echo the packet
|
||||
serverConn.WriteToUDP(data, addr)
|
||||
serverNumPacketsSent++
|
||||
}
|
||||
}()
|
||||
})
|
||||
|
||||
AfterEach(func() {
|
||||
err := proxy.Close()
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
err = serverConn.Close()
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
err = clientConn.Close()
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
})
|
||||
|
||||
Context("no packet drop", func() {
|
||||
It("relays packets from the client to the server", func() {
|
||||
startProxy(Opts{RemoteAddr: serverAddr})
|
||||
// send the first packet
|
||||
_, err := clientConn.Write(makePacket(1, []byte("foobar")))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
Eventually(func() map[string]*connection { return proxy.clientDict }).Should(HaveLen(1))
|
||||
var conn *connection
|
||||
for _, conn = range proxy.clientDict {
|
||||
Expect(atomic.LoadUint64(&conn.incomingPacketCounter)).To(Equal(uint64(1)))
|
||||
}
|
||||
|
||||
// send the second packet
|
||||
_, err = clientConn.Write(makePacket(2, []byte("decafbad")))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(2))
|
||||
Expect(proxy.clientDict).To(HaveLen(1))
|
||||
Expect(string(serverReceivedPackets[0])).To(ContainSubstring("foobar"))
|
||||
Expect(string(serverReceivedPackets[1])).To(ContainSubstring("decafbad"))
|
||||
})
|
||||
|
||||
It("relays packets from the server to the client", func() {
|
||||
startProxy(Opts{RemoteAddr: serverAddr})
|
||||
// send the first packet
|
||||
_, err := clientConn.Write(makePacket(1, []byte("foobar")))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
Eventually(func() map[string]*connection { return proxy.clientDict }).Should(HaveLen(1))
|
||||
var key string
|
||||
var conn *connection
|
||||
for key, conn = range proxy.clientDict {
|
||||
Eventually(func() uint64 { return atomic.LoadUint64(&conn.outgoingPacketCounter) }).Should(Equal(uint64(1)))
|
||||
}
|
||||
|
||||
// send the second packet
|
||||
_, err = clientConn.Write(makePacket(2, []byte("decafbad")))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
|
||||
Expect(proxy.clientDict).To(HaveLen(1))
|
||||
Eventually(func() uint64 { return proxy.clientDict[key].outgoingPacketCounter }).Should(BeEquivalentTo(2))
|
||||
|
||||
var clientReceivedPackets []packetData
|
||||
// receive the packets echoed by the server on client side
|
||||
go func() {
|
||||
for {
|
||||
buf := make([]byte, protocol.MaxPacketSize)
|
||||
// the ReadFromUDP will error as soon as the UDP conn is closed
|
||||
n, _, err2 := clientConn.ReadFromUDP(buf)
|
||||
if err2 != nil {
|
||||
return
|
||||
}
|
||||
data := buf[0:n]
|
||||
clientReceivedPackets = append(clientReceivedPackets, packetData(data))
|
||||
}
|
||||
}()
|
||||
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(2))
|
||||
Expect(serverReceivedPackets).To(HaveLen(2))
|
||||
Expect(serverNumPacketsSent).To(Equal(2))
|
||||
Eventually(func() []packetData { return clientReceivedPackets }).Should(HaveLen(2))
|
||||
Expect(string(clientReceivedPackets[0])).To(ContainSubstring("foobar"))
|
||||
Expect(string(clientReceivedPackets[1])).To(ContainSubstring("decafbad"))
|
||||
})
|
||||
})
|
||||
|
||||
Context("Drop Callbacks", func() {
|
||||
It("drops incoming packets", func() {
|
||||
opts := Opts{
|
||||
RemoteAddr: serverAddr,
|
||||
DropPacket: func(d Direction, p protocol.PacketNumber) bool {
|
||||
return d == DirectionIncoming && p%2 == 0
|
||||
},
|
||||
}
|
||||
startProxy(opts)
|
||||
|
||||
// send 6 packets
|
||||
for i := 1; i <= 6; i++ {
|
||||
_, err := clientConn.Write(makePacket(protocol.PacketNumber(i), []byte("foobar"+strconv.Itoa(i))))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
}
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(3))
|
||||
Consistently(func() []packetData { return serverReceivedPackets }).Should(HaveLen(3))
|
||||
})
|
||||
|
||||
It("drops outgoing packets", func() {
|
||||
opts := Opts{
|
||||
RemoteAddr: serverAddr,
|
||||
DropPacket: func(d Direction, p protocol.PacketNumber) bool {
|
||||
return d == DirectionOutgoing && p%2 == 0
|
||||
},
|
||||
}
|
||||
startProxy(opts)
|
||||
|
||||
var clientReceivedPackets []packetData
|
||||
// receive the packets echoed by the server on client side
|
||||
go func() {
|
||||
for {
|
||||
buf := make([]byte, protocol.MaxPacketSize)
|
||||
// the ReadFromUDP will error as soon as the UDP conn is closed
|
||||
n, _, err2 := clientConn.ReadFromUDP(buf)
|
||||
if err2 != nil {
|
||||
return
|
||||
}
|
||||
data := buf[0:n]
|
||||
clientReceivedPackets = append(clientReceivedPackets, packetData(data))
|
||||
}
|
||||
}()
|
||||
|
||||
// send 6 packets
|
||||
for i := 1; i <= 6; i++ {
|
||||
_, err := clientConn.Write(makePacket(protocol.PacketNumber(i), []byte("foobar"+strconv.Itoa(i))))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
}
|
||||
|
||||
Eventually(func() []packetData { return clientReceivedPackets }).Should(HaveLen(3))
|
||||
Consistently(func() []packetData { return clientReceivedPackets }).Should(HaveLen(3))
|
||||
})
|
||||
})
|
||||
|
||||
Context("Delay Callback", func() {
|
||||
expectDelay := func(startTime time.Time, rtt time.Duration, numRTTs int) {
|
||||
expectedReceiveTime := startTime.Add(time.Duration(numRTTs) * rtt)
|
||||
Expect(time.Now()).To(SatisfyAll(
|
||||
BeTemporally(">=", expectedReceiveTime),
|
||||
BeTemporally("<", expectedReceiveTime.Add(rtt/2)),
|
||||
))
|
||||
}
|
||||
|
||||
It("delays incoming packets", func() {
|
||||
delay := 300 * time.Millisecond
|
||||
opts := Opts{
|
||||
RemoteAddr: serverAddr,
|
||||
// delay packet 1 by 200 ms
|
||||
// delay packet 2 by 400 ms
|
||||
// ...
|
||||
DelayPacket: func(d Direction, p protocol.PacketNumber) time.Duration {
|
||||
if d == DirectionOutgoing {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(p) * delay
|
||||
},
|
||||
}
|
||||
startProxy(opts)
|
||||
|
||||
// send 3 packets
|
||||
start := time.Now()
|
||||
for i := 1; i <= 3; i++ {
|
||||
_, err := clientConn.Write(makePacket(protocol.PacketNumber(i), []byte("foobar"+strconv.Itoa(i))))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
}
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(1))
|
||||
expectDelay(start, delay, 1)
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(2))
|
||||
expectDelay(start, delay, 2)
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(3))
|
||||
expectDelay(start, delay, 3)
|
||||
})
|
||||
|
||||
It("delays outgoing packets", func() {
|
||||
delay := 300 * time.Millisecond
|
||||
opts := Opts{
|
||||
RemoteAddr: serverAddr,
|
||||
// delay packet 1 by 200 ms
|
||||
// delay packet 2 by 400 ms
|
||||
// ...
|
||||
DelayPacket: func(d Direction, p protocol.PacketNumber) time.Duration {
|
||||
if d == DirectionIncoming {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(p) * delay
|
||||
},
|
||||
}
|
||||
startProxy(opts)
|
||||
|
||||
var clientReceivedPackets []packetData
|
||||
// receive the packets echoed by the server on client side
|
||||
go func() {
|
||||
for {
|
||||
buf := make([]byte, protocol.MaxPacketSize)
|
||||
// the ReadFromUDP will error as soon as the UDP conn is closed
|
||||
n, _, err2 := clientConn.ReadFromUDP(buf)
|
||||
if err2 != nil {
|
||||
return
|
||||
}
|
||||
data := buf[0:n]
|
||||
clientReceivedPackets = append(clientReceivedPackets, packetData(data))
|
||||
}
|
||||
}()
|
||||
|
||||
// send 3 packets
|
||||
start := time.Now()
|
||||
for i := 1; i <= 3; i++ {
|
||||
_, err := clientConn.Write(makePacket(protocol.PacketNumber(i), []byte("foobar"+strconv.Itoa(i))))
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
}
|
||||
// the packets should have arrived immediately at the server
|
||||
Eventually(func() []packetData { return serverReceivedPackets }).Should(HaveLen(3))
|
||||
expectDelay(start, delay, 0)
|
||||
Eventually(func() []packetData { return clientReceivedPackets }).Should(HaveLen(1))
|
||||
expectDelay(start, delay, 1)
|
||||
Eventually(func() []packetData { return clientReceivedPackets }).Should(HaveLen(2))
|
||||
expectDelay(start, delay, 2)
|
||||
Eventually(func() []packetData { return clientReceivedPackets }).Should(HaveLen(3))
|
||||
expectDelay(start, delay, 3)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user