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

+75 -27
View File
@@ -16,6 +16,7 @@ import (
"github.com/coder/websocket"
rvboxv1 "github.com/rvbox/rvbox/gen/go/rvbox/v1"
"github.com/rvbox/rvbox/internal/agentproto"
"github.com/rvbox/rvbox/internal/agentwire"
"github.com/rvbox/rvbox/internal/domain"
"github.com/rvbox/rvbox/internal/observability"
"github.com/rvbox/rvbox/internal/server/store"
@@ -78,8 +79,9 @@ func (server *AgentServer) ServeHTTP(response http.ResponseWriter, request *http
}
started := time.Now()
heartbeat := newSynchronizedHeartbeat(server.heartbeatIdle(), server.livenessTimeout(), 0)
connection, err := websocket.Accept(response, request, &websocket.AcceptOptions{
raw, err := websocket.Accept(response, request, &websocket.AcceptOptions{
CompressionMode: websocket.CompressionDisabled,
Subprotocols: []string{agentwire.Subprotocol},
// coder/websocket consumes control frames inside Read. Count ping and
// pong callbacks as inbound activity so a healthy, otherwise idle agent
// is not mistaken for a dead peer; application Read results are observed
@@ -95,16 +97,20 @@ func (server *AgentServer) ServeHTTP(response http.ResponseWriter, request *http
if err != nil {
return
}
connection.SetReadLimit(int64(server.limits().MaxEnvelopeBytes))
connection, err := agentwire.Wrap(raw, server.limits().MaxEnvelopeBytes, func() { heartbeat.Observe(time.Since(started)) })
if err != nil {
_ = raw.CloseNow()
return
}
server.incMetric("agent_connection")
defer connection.CloseNow()
server.serveConnection(request.Context(), connection, heartbeat, started)
}
func (server *AgentServer) serveConnection(parent context.Context, connection *websocket.Conn, heartbeat *synchronizedHeartbeat, started time.Time) {
func (server *AgentServer) serveConnection(parent context.Context, connection *agentwire.Conn, heartbeat *synchronizedHeartbeat, started time.Time) {
messageType, payload, err := connection.Read(parent)
if err != nil {
if errors.Is(err, websocket.ErrMessageTooBig) {
if errors.Is(err, websocket.ErrMessageTooBig) || errors.Is(err, agentwire.ErrMessageTooBig) {
server.incMetric("agent_message_too_big")
}
server.logSessionError("", 0, "hello-read", err)
@@ -255,7 +261,7 @@ func (server *AgentServer) serveConnection(parent context.Context, connection *w
for {
messageType, payload, err = connection.Read(sessionContext)
if err != nil {
if errors.Is(err, websocket.ErrMessageTooBig) {
if errors.Is(err, websocket.ErrMessageTooBig) || errors.Is(err, agentwire.ErrMessageTooBig) {
server.incMetric("agent_message_too_big")
}
server.logSessionError(hello.GetClientId(), registration.Generation, "read", err)
@@ -784,39 +790,81 @@ func (server *AgentServer) closeForDispatchFailure(cancel context.CancelFunc) {
}
}
func (server *AgentServer) writeLoop(ctx context.Context, connection *websocket.Conn, queue *WriterQueue, heartbeat *synchronizedHeartbeat, started time.Time) {
type packetWriter interface {
Encode([]byte, bool) (*agentwire.Encoder, error)
WritePacket(context.Context, []byte) error
Ping(context.Context) error
}
func (server *AgentServer) writeLoop(ctx context.Context, connection packetWriter, queue *WriterQueue, heartbeat *synchronizedHeartbeat, started time.Time) {
checkHeartbeat := func() error {
switch heartbeat.Check(time.Since(started)) {
case HeartbeatPing:
pingContext, cancel := context.WithTimeout(ctx, server.writeDeadline())
defer cancel()
return connection.Ping(pingContext)
case HeartbeatClose:
server.incMetric("heartbeat_timeout")
return ErrSessionClosed
}
return ctx.Err()
}
var writeFrame func(Frame) error
writeFrame = func(frame Frame) error {
encoder, err := connection.Encode(frame.Payload, frame.Kind == FrameControl)
if err != nil {
return err
}
for {
packet, last := encoder.Next()
writeContext, cancel := context.WithTimeout(ctx, server.writeDeadline())
err := connection.WritePacket(writeContext, packet)
cancel()
if err != nil {
return err
}
if err := checkHeartbeat(); err != nil {
return err
}
if last {
break
}
if frame.Kind == FrameData {
// A bounded control burst may overtake a partial data message.
// Its independent fragment lane cannot corrupt data reassembly.
for burst := uint32(0); burst < queue.controlBurst; burst++ {
priority, ok := queue.TryControl()
if !ok {
break
}
if err := writeFrame(priority); err != nil {
return err
}
}
}
}
if frame.Written != nil {
close(frame.Written)
}
if frame.OnWritten != nil {
frame.OnWritten()
}
return nil
}
for {
frameContext, cancel := context.WithTimeout(ctx, server.heartbeatPollInterval())
frame, err := queue.Next(frameContext)
cancel()
if err == nil {
writeContext, writeCancel := context.WithTimeout(ctx, server.writeDeadline())
err = connection.Write(writeContext, websocket.MessageBinary, frame.Payload)
writeCancel()
if err != nil {
if err := writeFrame(frame); err != nil {
return
}
if frame.Written != nil {
close(frame.Written)
}
if frame.OnWritten != nil {
frame.OnWritten()
}
continue
}
if !errors.Is(err, context.DeadlineExceeded) {
return
}
switch heartbeat.Check(time.Since(started)) {
case HeartbeatPing:
pingContext, pingCancel := context.WithTimeout(ctx, server.writeDeadline())
err = connection.Ping(pingContext)
pingCancel()
if err != nil {
return
}
case HeartbeatClose:
server.incMetric("heartbeat_timeout")
if err := checkHeartbeat(); err != nil {
return
}
}
@@ -834,7 +882,7 @@ func (server *AgentServer) observeMetric(name string, duration time.Duration) {
}
}
func (server *AgentServer) close(connection *websocket.Conn, status websocket.StatusCode, reason string) {
func (server *AgentServer) close(connection *agentwire.Conn, status websocket.StatusCode, reason string) {
_ = connection.Close(status, reason)
}