feat(transport): negotiate bounded automatic message chunking
This commit is contained in:
1 parent
474afb3484
commit
8acffac985
20 files changed
+1332
-38
No files matched your search
@@ -0,0 +1,216 @@
|
||||
package agentwire
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/coder/websocket"
|
||||
)
|
||||
|
||||
func TestNegotiationFallbackAndBackgroundPong_HP_CHUNK_02(t *testing.T) {
|
||||
t.Parallel()
|
||||
for _, scenario := range []struct {
|
||||
name string
|
||||
server, client bool
|
||||
}{
|
||||
{"both", true, true}, {"old server", false, true}, {"old client", true, false},
|
||||
} {
|
||||
t.Run(scenario.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
payload := bytes.Repeat([]byte{0x53}, 64<<10)
|
||||
pong := make(chan error, 1)
|
||||
var activity atomic.Uint32
|
||||
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
options := &websocket.AcceptOptions{}
|
||||
if scenario.server {
|
||||
options.Subprotocols = []string{Subprotocol}
|
||||
}
|
||||
raw, err := websocket.Accept(w, r, options)
|
||||
if err != nil {
|
||||
pong <- err
|
||||
return
|
||||
}
|
||||
connection, err := Wrap(raw, 1<<20, func() { activity.Add(1) })
|
||||
if err != nil {
|
||||
_ = raw.CloseNow()
|
||||
pong <- err
|
||||
return
|
||||
}
|
||||
defer connection.CloseNow()
|
||||
_, got, err := connection.Read(ctx)
|
||||
if err == nil && !bytes.Equal(got, payload) {
|
||||
err = errors.New("payload changed")
|
||||
}
|
||||
if err == nil {
|
||||
err = connection.Write(ctx, websocket.MessageBinary, got)
|
||||
}
|
||||
if err == nil {
|
||||
err = connection.Ping(ctx)
|
||||
}
|
||||
pong <- err
|
||||
_, _, _ = connection.Read(ctx)
|
||||
}))
|
||||
defer server.Close()
|
||||
options := &websocket.DialOptions{HTTPClient: server.Client()}
|
||||
if scenario.client {
|
||||
options.Subprotocols = []string{Subprotocol}
|
||||
}
|
||||
raw, _, err := websocket.Dial(ctx, "wss"+strings.TrimPrefix(server.URL, "https"), options)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
connection, err := Wrap(raw, 1<<20, nil)
|
||||
if err != nil {
|
||||
_ = raw.CloseNow()
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer connection.Close(websocket.StatusNormalClosure, "")
|
||||
if connection.chunked != (scenario.client && scenario.server) {
|
||||
t.Fatal("wrong negotiated mode")
|
||||
}
|
||||
if err := connection.Write(ctx, websocket.MessageBinary, payload); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Do not call Read yet: the read pump must still service Ping while
|
||||
// the echoed complete message waits for the application.
|
||||
select {
|
||||
case err := <-pong:
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
case <-ctx.Done():
|
||||
t.Fatal("Ping blocked behind application read")
|
||||
}
|
||||
_, got, err := connection.Read(ctx)
|
||||
if err != nil || !bytes.Equal(got, payload) {
|
||||
t.Fatalf("echo bytes=%d error=%v", len(got), err)
|
||||
}
|
||||
if connection.chunked && activity.Load() <= 1 {
|
||||
t.Fatal("large message was not chunked")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestConcurrentLogicalWrites_RACE_CHUNK_01(t *testing.T) {
|
||||
t.Parallel()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
|
||||
defer cancel()
|
||||
result := make(chan error, 1)
|
||||
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
raw, err := websocket.Accept(w, r, &websocket.AcceptOptions{Subprotocols: []string{Subprotocol}})
|
||||
if err != nil {
|
||||
result <- err
|
||||
return
|
||||
}
|
||||
connection, err := Wrap(raw, 1<<20, nil)
|
||||
if err != nil {
|
||||
_ = raw.CloseNow()
|
||||
result <- err
|
||||
return
|
||||
}
|
||||
defer connection.CloseNow()
|
||||
seen := map[byte]bool{}
|
||||
for len(seen) < 8 {
|
||||
_, payload, err := connection.Read(ctx)
|
||||
if err != nil {
|
||||
result <- err
|
||||
return
|
||||
}
|
||||
if len(payload) != 128<<10 || seen[payload[0]] || !bytes.Equal(payload, bytes.Repeat(payload[:1], len(payload))) {
|
||||
result <- errors.New("concurrent messages interleaved or duplicated")
|
||||
return
|
||||
}
|
||||
seen[payload[0]] = true
|
||||
}
|
||||
result <- nil
|
||||
}))
|
||||
defer server.Close()
|
||||
raw, _, err := websocket.Dial(ctx, "wss"+strings.TrimPrefix(server.URL, "https"), &websocket.DialOptions{HTTPClient: server.Client(), Subprotocols: []string{Subprotocol}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
connection, err := Wrap(raw, 1<<20, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer connection.CloseNow()
|
||||
var workers sync.WaitGroup
|
||||
for i := byte(0); i < 8; i++ {
|
||||
workers.Go(func() {
|
||||
if err := connection.Write(ctx, websocket.MessageBinary, bytes.Repeat([]byte{i}, 128<<10)); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
workers.Wait()
|
||||
select {
|
||||
case err := <-result:
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
case <-ctx.Done():
|
||||
t.Fatal("concurrent write test stalled")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInterruptedPacketNeverDelivered_REC_CHUNK_02(t *testing.T) {
|
||||
t.Parallel()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
result := make(chan incoming, 2)
|
||||
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
raw, err := websocket.Accept(w, r, &websocket.AcceptOptions{Subprotocols: []string{Subprotocol}})
|
||||
if err != nil {
|
||||
result <- incoming{err: err}
|
||||
return
|
||||
}
|
||||
connection, err := Wrap(raw, 1<<20, nil)
|
||||
if err != nil {
|
||||
_ = raw.CloseNow()
|
||||
result <- incoming{err: err}
|
||||
return
|
||||
}
|
||||
defer connection.CloseNow()
|
||||
_, payload, err := connection.Read(ctx)
|
||||
result <- incoming{payload: payload, err: err}
|
||||
}))
|
||||
defer server.Close()
|
||||
connect := func() *websocket.Conn {
|
||||
t.Helper()
|
||||
connection, _, err := websocket.Dial(ctx, "wss"+strings.TrimPrefix(server.URL, "https"), &websocket.DialOptions{HTTPClient: server.Client(), Subprotocols: []string{Subprotocol}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return connection
|
||||
}
|
||||
payload := bytes.Repeat([]byte{0x55}, 64<<10)
|
||||
first := connect()
|
||||
if err := first.Write(ctx, websocket.MessageBinary, packets(t, payload, false)[0]); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_ = first.CloseNow()
|
||||
if got := <-result; got.err == nil || got.payload != nil {
|
||||
t.Fatal("partial message delivered")
|
||||
}
|
||||
second := connect()
|
||||
defer second.CloseNow()
|
||||
for _, packet := range packets(t, payload, false) {
|
||||
if err := second.Write(ctx, websocket.MessageBinary, packet); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if got := <-result; got.err != nil || !bytes.Equal(got.payload, payload) {
|
||||
t.Fatalf("replay: %v", got.err)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user