feat(transport): negotiate bounded automatic message chunking

This commit is contained in:
cabbage committed 2026-11-09 08:50:51 +00:00
1 parent 474afb3484
commit 8acffac985
20 files changed
+1332 -38

No files matched your search

@@ -0,0 +1,116 @@
package session
import (
"bytes"
"context"
"sync/atomic"
"testing"
"time"
"github.com/rvbox/rvbox/internal/agentwire"
)
func TestChunkedWriterPreemptionAndBarrier_RACE_CHUNK_02(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
queue := NewWriterQueue(8, 2, 4)
defer queue.Close()
data := bytes.Repeat([]byte{0x51}, 128<<10)
priority := bytes.Repeat([]byte{0x52}, 48<<10)
dataWritten, controlWritten := make(chan struct{}), make(chan struct{})
queue.EnqueueData(Frame{Kind: FrameData, Payload: data, Written: dataWritten})
writer := &blockedPacketWriter{packets: make(chan []byte, 32), gate: make(chan struct{})}
done := make(chan struct{})
started := time.Now()
go func() {
defer close(done)
(&AgentServer{}).writeLoop(ctx, writer, queue, newSynchronizedHeartbeat(time.Millisecond, time.Second, 0), started)
}()
var first []byte
select {
case first = <-writer.packets:
case <-ctx.Done():
t.Fatal("first packet not written")
}
if err := queue.EnqueueControl(Frame{Kind: FrameControl, Payload: []byte("ack")}); err != nil {
t.Fatal(err)
}
if err := queue.EnqueueControl(Frame{Kind: FrameControl, Payload: priority, Written: controlWritten}); err != nil {
t.Fatal(err)
}
select {
case <-dataWritten:
t.Fatal("dispatch barrier opened on a partial message")
default:
}
time.Sleep(2 * time.Millisecond) // Cross the heartbeat idle boundary.
close(writer.gate)
decoder := agentwire.Decoder{Maximum: 1 << 20}
if value, err := decoder.Push(first); err != nil || value != nil {
t.Fatal("invalid first partial packet")
}
var received [][]byte
for len(received) < 3 {
select {
case packet := <-writer.packets:
value, err := decoder.Push(packet)
if err != nil {
t.Fatal(err)
}
if value != nil {
received = append(received, value)
}
case <-ctx.Done():
t.Fatal("preempted writer stalled")
}
}
if !bytes.Equal(received[0], []byte("ack")) || !bytes.Equal(received[1], priority) || !bytes.Equal(received[2], data) {
t.Fatal("control did not preempt partial data intact")
}
select {
case <-dataWritten:
case <-ctx.Done():
t.Fatal("completed data barrier never opened")
}
select {
case <-controlWritten:
default:
t.Fatal("completed control barrier never opened")
}
cancel()
<-done
if writer.pings.Load() == 0 {
t.Fatal("heartbeat skipped during chunked transfer")
}
}
type blockedPacketWriter struct {
packets chan []byte
gate chan struct{}
writes int
pings atomic.Uint32
}
func (writer *blockedPacketWriter) Encode(payload []byte, priority bool) (*agentwire.Encoder, error) {
return agentwire.NewEncoder(payload, 1<<20, true, priority)
}
func (writer *blockedPacketWriter) WritePacket(ctx context.Context, packet []byte) error {
select {
case writer.packets <- bytes.Clone(packet):
case <-ctx.Done():
return ctx.Err()
}
writer.writes++
if writer.writes == 1 {
select {
case <-writer.gate:
case <-ctx.Done():
return ctx.Err()
}
}
return nil
}
func (writer *blockedPacketWriter) Ping(context.Context) error { writer.pings.Add(1); return nil }