fix(openai): start responses websocket keepalive after upgrade

- Start a connection-scoped downstream Ping keepalive loop immediately after upgrading the Responses WebSocket connection instead of waiting for stream forwarding to begin.
- Guard background Ping writes with non-blocking mutex acquisition so active data writes are not contended while blocked Ping writes are still interrupted on terminal close.
- Preserve the socket cancellation cause in response forwarding and add regression coverage for post-upgrade, upstream-bootstrap, and blocked-Ping close paths.

Closes: #7407
Co-authored-by: Dylan <1990016@gmail.com>
Co-authored-by: lzt404 <2596933790@qq.com>
This commit is contained in:
Luis Pater
2026-11-10 17:34:58 +08:00
parent 1855209dcd
commit 46d48eb5af
3 changed files with 435 additions and 249 deletions

View File

@@ -133,8 +133,8 @@ func newResponsesWebsocketWriter(conn *websocket.Conn) *responsesWebsocketWriter
}
// closeForUpstreamError sends a best-effort close frame without waiting behind
// an active downstream data writer. If a data write already owns writeMu, the
// connection is closed immediately so the blocked writer and session can exit.
// an active downstream writer. If a data or Ping write already owns writeMu,
// the connection is closed immediately so the blocked writer and session can exit.
func (w *responsesWebsocketWriter) closeForUpstreamError(err error) (bool, error) {
if w == nil || w.conn == nil {
return false, nil
@@ -173,7 +173,15 @@ func (w *responsesWebsocketWriter) writePing() error {
if w == nil || w.conn == nil {
return errors.New("responses websocket: writer is nil")
}
w.writeMu.Lock()
if w.closing.Load() {
return websocket.ErrCloseSent
}
if !w.writeMu.TryLock() {
if w.closing.Load() {
return websocket.ErrCloseSent
}
return nil
}
defer w.writeMu.Unlock()
if w.closing.Load() {
return websocket.ErrCloseSent
@@ -181,6 +189,56 @@ func (w *responsesWebsocketWriter) writePing() error {
return w.conn.WriteControl(websocket.PingMessage, nil, time.Time{})
}
func (w *responsesWebsocketWriter) keepAlive(ctx context.Context, cancel context.CancelCauseFunc, intervals <-chan time.Duration) {
if errPing := runResponsesWebsocketKeepAlive(ctx, intervals, w.writePing); errPing != nil {
cancel(errPing)
_, _ = w.closeWithoutError()
}
}
func runResponsesWebsocketKeepAlive(ctx context.Context, intervals <-chan time.Duration, ping func() error) error {
var ticker *time.Ticker
var ticks <-chan time.Time
defer func() {
if ticker != nil {
ticker.Stop()
}
}()
for {
select {
case <-ctx.Done():
return nil
case interval := <-intervals:
if interval <= 0 {
if ticker != nil {
ticker.Stop()
}
ticks = nil
continue
}
if ticker == nil {
ticker = time.NewTicker(interval)
} else {
ticker.Reset(interval)
}
ticks = ticker.C
case <-ticks:
if errPing := ping(); errPing != nil {
return errPing
}
}
}
}
func queueResponsesWebsocketKeepAliveInterval(intervals chan time.Duration, interval time.Duration) {
// A single producer replaces a pending interval without waiting for a Ping write.
select {
case <-intervals:
default:
}
intervals <- interval
}
func (w *responsesWebsocketWriter) closeWithPayload(payload []byte) (bool, error) {
if w == nil || w.conn == nil {
return false, nil
@@ -374,6 +432,25 @@ func (h *OpenAIResponsesAPIHandler) ResponsesWebsocket(c *gin.Context) {
defer cancelSocket(nil)
c.Request = c.Request.WithContext(socketCtx)
upgradeRequest := c.Request.Clone(socketCtx)
// Start Ping at upgrade, before opening an upstream stream can block.
var keepAliveIntervals chan time.Duration
var keepAliveInterval time.Duration
updateKeepAlive := func() {
if h == nil {
return
}
interval := handlers.StreamingKeepAliveInterval(h.CurrentConfig())
if interval == keepAliveInterval {
return
}
keepAliveInterval = interval
if keepAliveIntervals == nil {
keepAliveIntervals = make(chan time.Duration, 1)
go writer.keepAlive(socketCtx, cancelSocket, keepAliveIntervals)
}
queueResponsesWebsocketKeepAliveInterval(keepAliveIntervals, interval)
}
updateKeepAlive()
// The reader owns the client socket so an in-flight interrupt is not stuck
// behind the response currently being forwarded.
requestLogEnabled := false
@@ -568,6 +645,7 @@ func (h *OpenAIResponsesAPIHandler) ResponsesWebsocket(c *gin.Context) {
if msgType != websocket.TextMessage && msgType != websocket.BinaryMessage {
continue
}
updateKeepAlive()
// log.Infof(
// "responses websocket: downstream_in id=%s type=%d event=%s payload=%s",
// passthroughSessionID,

View File

@@ -28,7 +28,6 @@ type responsesWebsocketForwardOptions struct {
duplexStream func() bool
toolCacheTurn *responsesWebsocketToolCacheTurn
suppressError func(*interfaces.ErrorMessage) bool
keepAliveInterval *time.Duration
localInterrupt *responsesLocalInterrupt
// websocketOwned reports whether this turn runs on an upstream
// websocket. While true, no interrupt may claim the local HTTP path.
@@ -66,20 +65,6 @@ func (h *OpenAIResponsesAPIHandler) forwardResponsesWebsocket(
downstreamSessionKey = websocketDownstreamSessionKey(c.Request)
}
var keepAliveTicker *time.Ticker
var keepAliveC <-chan time.Time
keepAliveInterval := time.Duration(0)
if h != nil {
keepAliveInterval = handlers.StreamingKeepAliveInterval(h.CurrentConfig())
}
if opts.keepAliveInterval != nil {
keepAliveInterval = *opts.keepAliveInterval
}
if keepAliveInterval > 0 {
keepAliveTicker = time.NewTicker(keepAliveInterval)
defer keepAliveTicker.Stop()
keepAliveC = keepAliveTicker.C
}
if opts.localInterrupt != nil {
websocketOwned := opts.websocketOwned != nil && opts.websocketOwned()
opts.localInterrupt.begin(websocketOwned)
@@ -155,13 +140,9 @@ func (h *OpenAIResponsesAPIHandler) forwardResponsesWebsocket(
}
return completeResponsesWebsocketLocalInterrupt(writer, wsTimelineLog, cancel, interruptPayload, outputItemsByIndex, outputItemsFallback, pendingToolCallIDs)
case <-c.Request.Context().Done():
cancel(c.Request.Context().Err())
return completedOutput, completedResponseID, sortedStringSet(pendingToolCallIDs), nil, c.Request.Context().Err()
case <-keepAliveC:
if errPing := writer.writePing(); errPing != nil {
cancel(errPing)
return completedOutput, completedResponseID, sortedStringSet(pendingToolCallIDs), nil, errPing
}
cause := context.Cause(c.Request.Context())
cancel(cause)
return completedOutput, completedResponseID, sortedStringSet(pendingToolCallIDs), nil, cause
case errMsg, ok := <-errs:
if !ok {
errs = nil
@@ -212,9 +193,6 @@ func (h *OpenAIResponsesAPIHandler) forwardResponsesWebsocket(
cancel(nil)
return completedOutput, completedResponseID, sortedStringSet(pendingToolCallIDs), nil, nil
}
if keepAliveTicker != nil && keepAliveInterval > 0 {
keepAliveTicker.Reset(keepAliveInterval)
}
// A queued local interrupt belongs to an in-flight HTTP turn:
// consume it before forwarding more upstream payload. Once the

View File

@@ -1,6 +1,7 @@
package openai
import (
"bufio"
"bytes"
"context"
"encoding/json"
@@ -8,6 +9,7 @@ import (
"fmt"
"io"
"maps"
"net"
"net/http"
"net/http/httptest"
"runtime"
@@ -16,6 +18,7 @@ import (
"sync"
"sync/atomic"
"testing"
"testing/synctest"
"time"
"unicode/utf8"
@@ -7502,195 +7505,111 @@ func TestNormalizeSubsequentRequestAssistantInputTriggersTranscriptReplacement(t
}
}
func TestForwardResponsesWebsocketEmitsPeriodicPingControlFrames(t *testing.T) {
gin.SetMode(gin.TestMode)
serverErrCh := make(chan error, 1)
data := make(chan []byte)
errCh := make(chan *interfaces.ErrorMessage)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := responsesWebsocketUpgrader.Upgrade(w, r, nil)
if err != nil {
serverErrCh <- err
return
}
defer func() { _ = conn.Close() }()
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = r
cfg := &sdkconfig.SDKConfig{
Streaming: sdkconfig.StreamingConfig{
KeepAliveSeconds: 1,
},
}
h := NewOpenAIResponsesAPIHandler(handlers.NewBaseAPIHandlers(cfg, nil))
_, _, _, errMsg, errForward := h.forwardResponsesWebsocket(
ctx,
newResponsesWebsocketWriter(conn),
func(...interface{}) {},
data,
errCh,
newInMemoryWebsocketTimelineLog(),
"session-keepalive-test",
)
if errMsg != nil {
serverErrCh <- fmt.Errorf("unexpected error message: %v", errMsg.Error)
return
}
if errForward != nil {
serverErrCh <- fmt.Errorf("unexpected forward error: %v", errForward)
return
}
serverErrCh <- nil
}))
defer server.Close()
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
clientConn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
if err != nil {
t.Fatalf("dial websocket: %v", err)
}
defer func() { _ = clientConn.Close() }()
pingReceived := make(chan struct{}, 1)
clientConn.SetPingHandler(func(appData string) error {
select {
case pingReceived <- struct{}{}:
default:
}
return clientConn.WriteControl(websocket.PongMessage, []byte(appData), time.Now().Add(time.Second))
})
clientDone := make(chan struct{})
go func() {
defer close(clientDone)
for {
_, _, errRead := clientConn.ReadMessage()
if errRead != nil {
return
}
}
}()
select {
case <-pingReceived:
// Received expected Ping control frame while upstream is waiting.
case <-time.After(1500 * time.Millisecond):
t.Fatal("expected websocket Ping control frame during upstream wait, got none")
}
// Unblock forwardResponsesWebsocket with terminal completion.
data <- []byte(`{"type":"response.done","response":{"id":"resp-ping-1","output":[]}}`)
close(data)
close(errCh)
select {
case serverErr := <-serverErrCh:
if serverErr != nil {
t.Fatalf("server error: %v", serverErr)
}
case <-time.After(2 * time.Second):
t.Fatal("server timed out completing forwardResponsesWebsocket")
}
<-clientDone
type websocketKeepAliveBootstrapExecutor struct {
websocketCaptureExecutor
started chan struct{}
release chan struct{}
}
func TestForwardResponsesWebsocketPingKeepAliveOptionsOverride(t *testing.T) {
func (e *websocketKeepAliveBootstrapExecutor) ExecuteStream(ctx context.Context, auth *coreauth.Auth, req coreexecutor.Request, opts coreexecutor.Options) (*coreexecutor.StreamResult, error) {
close(e.started)
select {
case <-e.release:
return e.websocketCaptureExecutor.ExecuteStream(ctx, auth, req, opts)
case <-ctx.Done():
return nil, ctx.Err()
}
}
func TestResponsesWebsocketPingsBeforeUpstreamStreamIsReady(t *testing.T) {
gin.SetMode(gin.TestMode)
executor := &websocketKeepAliveBootstrapExecutor{
started: make(chan struct{}),
release: make(chan struct{}),
}
manager := coreauth.NewManager(nil, nil, nil)
manager.RegisterExecutor(executor)
auth := &coreauth.Auth{ID: "auth-ws-keepalive", Provider: executor.Identifier(), Status: coreauth.StatusActive}
if _, err := manager.Register(context.Background(), auth); err != nil {
t.Fatalf("register auth: %v", err)
}
const model = "ws-keepalive-test-model"
registry.GetGlobalRegistry().RegisterClient(auth.ID, auth.Provider, []*registry.ModelInfo{{ID: model}})
t.Cleanup(func() { registry.GetGlobalRegistry().UnregisterClient(auth.ID) })
serverErrCh := make(chan error, 1)
data := make(chan []byte)
errCh := make(chan *interfaces.ErrorMessage)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := responsesWebsocketUpgrader.Upgrade(w, r, nil)
if err != nil {
serverErrCh <- err
return
}
defer func() { _ = conn.Close() }()
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = r
interval := 20 * time.Millisecond
h := NewOpenAIResponsesAPIHandler(handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, nil))
_, _, _, errMsg, errForward := h.forwardResponsesWebsocket(
ctx,
newResponsesWebsocketWriter(conn),
func(...interface{}) {},
data,
errCh,
newInMemoryWebsocketTimelineLog(),
"session-keepalive-override",
responsesWebsocketForwardOptions{
keepAliveInterval: &interval,
},
)
if errMsg != nil {
serverErrCh <- fmt.Errorf("unexpected error message: %v", errMsg.Error)
return
}
if errForward != nil {
serverErrCh <- fmt.Errorf("unexpected forward error: %v", errForward)
return
}
serverErrCh <- nil
}))
cfg := &sdkconfig.SDKConfig{Streaming: sdkconfig.StreamingConfig{KeepAliveSeconds: 1}}
h := NewOpenAIResponsesAPIHandler(handlers.NewBaseAPIHandlers(cfg, manager))
router := gin.New()
router.GET("/v1/responses", h.ResponsesWebsocket)
server := httptest.NewServer(router)
defer server.Close()
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
clientConn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
wsURL := "ws" + strings.TrimPrefix(server.URL, "http") + "/v1/responses"
conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
if err != nil {
t.Fatalf("dial websocket: %v", err)
}
defer func() { _ = clientConn.Close() }()
defer func() { _ = conn.Close() }()
pingReceived := make(chan struct{}, 1)
clientConn.SetPingHandler(func(appData string) error {
pings := make(chan bool, 1)
pong := conn.PingHandler()
conn.SetPingHandler(func(payload string) error {
started := false
select {
case pingReceived <- struct{}{}:
case <-executor.started:
started = true
default:
}
return clientConn.WriteControl(websocket.PongMessage, []byte(appData), time.Now().Add(time.Second))
select {
case pings <- started:
default:
}
return pong(payload)
})
clientDone := make(chan struct{})
completed := make(chan error, 1)
go func() {
defer close(clientDone)
for {
_, _, errRead := clientConn.ReadMessage()
if errRead != nil {
return
}
_, payload, errRead := conn.ReadMessage()
if errRead == nil && ojson.GetBytesNoCopy(payload, "type").String() != wsEventTypeCompleted {
errRead = fmt.Errorf("expected response.completed, got %s", payload)
}
completed <- errRead
}()
select {
case <-pingReceived:
case <-time.After(500 * time.Millisecond):
t.Fatal("expected websocket Ping control frame via option override, got none")
case <-pings:
case errRead := <-completed:
t.Fatalf("websocket ended before the first turn: %v", errRead)
case <-time.After(5 * time.Second):
t.Fatal("expected Ping after upgrade, before sending a turn")
}
data <- []byte(`{"type":"response.done","response":{"id":"resp-override","output":[]}}`)
close(data)
close(errCh)
select {
case serverErr := <-serverErrCh:
if serverErr != nil {
t.Fatalf("server error: %v", serverErr)
if errWrite := conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.create","model":"ws-keepalive-test-model","input":[]}`)); errWrite != nil {
t.Fatalf("write websocket request: %v", errWrite)
}
deadline := time.After(5 * time.Second)
waitForBootstrapPing:
for {
select {
case started := <-pings:
if started {
break waitForBootstrapPing
}
case errRead := <-completed:
t.Fatalf("websocket ended before the upstream stream was released: %v", errRead)
case <-deadline:
t.Fatal("expected Ping while the upstream stream is blocked")
}
case <-time.After(2 * time.Second):
t.Fatal("server timed out completing forwardResponsesWebsocket")
}
<-clientDone
close(executor.release)
select {
case errRead := <-completed:
if errRead != nil {
t.Fatalf("read completed response: %v", errRead)
}
case <-time.After(5 * time.Second):
t.Fatal("expected response.completed after releasing the upstream stream")
}
}
func TestResponsesWebsocketWriterWritePing(t *testing.T) {
@@ -7709,6 +7628,23 @@ func TestResponsesWebsocketWriterWritePing(t *testing.T) {
defer func() { _ = conn.Close() }()
writer := newResponsesWebsocketWriter(conn)
// A background Ping must skip rather than block behind an active data write.
writer.writeMu.Lock()
pingDone := make(chan error, 1)
go func() { pingDone <- writer.writePing() }()
select {
case errPing := <-pingDone:
writer.writeMu.Unlock()
if errPing != nil {
t.Errorf("writePing() while data write active = %v, want nil", errPing)
}
case <-time.After(time.Second):
writer.writeMu.Unlock()
<-pingDone
t.Error("Ping waited for the data write mutex")
return
}
if errPing := writer.writePing(); errPing != nil {
t.Errorf("writePing() error = %v, want nil", errPing)
}
@@ -7751,81 +7687,275 @@ func TestResponsesWebsocketWriterWritePing(t *testing.T) {
}
}
func TestForwardResponsesWebsocketPingWriteFailureAbortsSession(t *testing.T) {
gin.SetMode(gin.TestMode)
type blockingWebsocketWriteConn struct {
net.Conn
blockWrites atomic.Bool
writeBlock chan struct{}
closed chan struct{}
closeOnce sync.Once
}
serverErrCh := make(chan error, 1)
cancelledCh := make(chan error, 1)
data := make(chan []byte)
errCh := make(chan *interfaces.ErrorMessage)
func newBlockingWebsocketWriteConn(conn net.Conn) *blockingWebsocketWriteConn {
return &blockingWebsocketWriteConn{
Conn: conn,
writeBlock: make(chan struct{}, 1),
closed: make(chan struct{}),
}
}
func (c *blockingWebsocketWriteConn) Write(b []byte) (int, error) {
if c.blockWrites.Load() {
select {
case c.writeBlock <- struct{}{}:
default:
}
<-c.closed
return 0, net.ErrClosed
}
return c.Conn.Write(b)
}
func (c *blockingWebsocketWriteConn) Close() error {
c.closeOnce.Do(func() {
close(c.closed)
})
return c.Conn.Close()
}
type hijackableWebsocketResponseWriter struct {
header http.Header
conn net.Conn
}
func newHijackableWebsocketResponseWriter(conn net.Conn) *hijackableWebsocketResponseWriter {
return &hijackableWebsocketResponseWriter{
header: make(http.Header),
conn: conn,
}
}
func (w *hijackableWebsocketResponseWriter) Header() http.Header { return w.header }
func (w *hijackableWebsocketResponseWriter) Write(b []byte) (int, error) { return w.conn.Write(b) }
func (w *hijackableWebsocketResponseWriter) WriteHeader(int) {}
func (w *hijackableWebsocketResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
return w.conn, bufio.NewReadWriter(bufio.NewReader(w.conn), bufio.NewWriter(w.conn)), nil
}
func TestResponsesWebsocketWriterCloseInterruptsBlockedPing(t *testing.T) {
cases := []struct {
name string
close func(*responsesWebsocketWriter) error
}{
{
name: "closeForUpstreamError",
close: func(w *responsesWebsocketWriter) error {
matched, errClose := w.closeForUpstreamError(&websocket.CloseError{
Code: websocket.CloseMessageTooBig,
Text: "message too big",
})
if !matched && errClose == nil {
return errors.New("message-too-big error did not match")
}
return errClose
},
},
{
name: "closeWithPayload",
close: func(w *responsesWebsocketWriter) error {
_, errClose := w.closeWithPayload([]byte(`{"type":"error","status":400}`))
return errClose
},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
clientRaw, serverRaw := net.Pipe()
defer func() { _ = clientRaw.Close() }()
blockingServer := newBlockingWebsocketWriteConn(serverRaw)
defer func() { _ = blockingServer.Close() }()
serverConnCh := make(chan *websocket.Conn, 1)
serverErrCh := make(chan error, 1)
go func() {
req, errReq := http.NewRequest(http.MethodGet, "http://example.com/v1/responses", nil)
if errReq != nil {
serverErrCh <- errReq
return
}
req.Header.Set("Connection", "Upgrade")
req.Header.Set("Upgrade", "websocket")
req.Header.Set("Sec-WebSocket-Version", "13")
req.Header.Set("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
rw := newHijackableWebsocketResponseWriter(blockingServer)
conn, errUpgrade := responsesWebsocketUpgrader.Upgrade(rw, req, nil)
if errUpgrade != nil {
serverErrCh <- errUpgrade
return
}
serverConnCh <- conn
}()
// Drain the HTTP 101 Switching Protocols response on the client side of the pipe.
buf := make([]byte, 512)
if _, errRead := clientRaw.Read(buf); errRead != nil {
t.Fatalf("read upgrade response: %v", errRead)
}
var serverConn *websocket.Conn
select {
case serverConn = <-serverConnCh:
case errUpgrade := <-serverErrCh:
t.Fatalf("upgrade websocket: %v", errUpgrade)
case <-time.After(time.Second):
t.Fatal("timed out waiting for websocket upgrade")
}
writer := newResponsesWebsocketWriter(serverConn)
blockingServer.blockWrites.Store(true)
pingDone := make(chan error, 1)
go func() {
pingDone <- writer.writePing()
}()
select {
case <-blockingServer.writeBlock:
case <-time.After(time.Second):
t.Fatal("timed out waiting for writePing to enter blocked network write")
}
closeDone := make(chan error, 1)
go func() {
closeDone <- tc.close(writer)
}()
select {
case errClose := <-closeDone:
if errClose != nil {
t.Fatalf("close returned error: %v", errClose)
}
case <-time.After(time.Second):
t.Fatal("terminal close blocked behind stuck Ping write")
}
select {
case errPing := <-pingDone:
if !errors.Is(errPing, net.ErrClosed) {
t.Fatalf("writePing error = %v, want net.ErrClosed", errPing)
}
case <-time.After(time.Second):
t.Fatal("writePing did not exit after connection close")
}
})
}
}
func TestResponsesWebsocketKeepAliveUpdatesInterval(t *testing.T) {
synctest.Test(t, func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
intervals := make(chan time.Duration, 1)
queueResponsesWebsocketKeepAliveInterval(intervals, time.Second)
queueResponsesWebsocketKeepAliveInterval(intervals, 20*time.Millisecond)
pings := 0
done := make(chan error, 1)
go func() {
done <- runResponsesWebsocketKeepAlive(ctx, intervals, func() error {
pings++
return nil
})
}()
synctest.Wait()
time.Sleep(20 * time.Millisecond)
synctest.Wait()
if pings != 1 {
t.Fatalf("pings after replacing pending interval = %d, want 1", pings)
}
queueResponsesWebsocketKeepAliveInterval(intervals, 10*time.Millisecond)
synctest.Wait()
time.Sleep(10 * time.Millisecond)
synctest.Wait()
if pings != 2 {
t.Fatalf("pings after shortening interval = %d, want 2", pings)
}
queueResponsesWebsocketKeepAliveInterval(intervals, 0)
synctest.Wait()
time.Sleep(time.Second)
synctest.Wait()
if pings != 2 {
t.Fatalf("pings after disabling keepalive = %d, want 2", pings)
}
queueResponsesWebsocketKeepAliveInterval(intervals, 10*time.Millisecond)
synctest.Wait()
time.Sleep(10 * time.Millisecond)
synctest.Wait()
if pings != 3 {
t.Fatalf("pings after re-enabling keepalive = %d, want 3", pings)
}
cancel()
if err := <-done; err != nil {
t.Fatalf("keepalive did not shut down cleanly: %v", err)
}
})
}
func TestForwardResponsesWebsocketPreservesPingFailureCause(t *testing.T) {
requestCtx, cancelSocket := context.WithCancelCause(context.Background())
cancelSocket(net.ErrClosed)
c, _ := gin.CreateTestContext(httptest.NewRecorder())
c.Request = httptest.NewRequest(http.MethodGet, "/v1/responses", nil).WithContext(requestCtx)
var canceledWith error
_, _, _, _, err := (*OpenAIResponsesAPIHandler)(nil).forwardResponsesWebsocket(
c, nil, func(args ...interface{}) {
canceledWith, _ = args[0].(error)
}, nil, nil, nil, "ping-write-failure",
)
if !errors.Is(err, net.ErrClosed) || !errors.Is(canceledWith, net.ErrClosed) {
t.Fatalf("forward error = %v, cancellation cause = %v, want closed connection", err, canceledWith)
}
}
func TestResponsesWebsocketKeepAliveCancelsOnPingFailure(t *testing.T) {
serverErr := make(chan error, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := responsesWebsocketUpgrader.Upgrade(w, r, nil)
if err != nil {
serverErrCh <- err
serverErr <- err
return
}
defer func() { _ = conn.Close() }()
_ = conn.Close()
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = r
interval := 10 * time.Millisecond
h := NewOpenAIResponsesAPIHandler(handlers.NewBaseAPIHandlers(&sdkconfig.SDKConfig{}, nil))
_, _, _, errMsg, errForward := h.forwardResponsesWebsocket(
ctx,
newResponsesWebsocketWriter(conn),
func(errs ...interface{}) {
if len(errs) > 0 {
if errVal, ok := errs[0].(error); ok {
cancelledCh <- errVal
return
}
}
cancelledCh <- nil
},
data,
errCh,
newInMemoryWebsocketTimelineLog(),
"session-ping-fail",
responsesWebsocketForwardOptions{
keepAliveInterval: &interval,
},
)
if errMsg != nil {
serverErrCh <- fmt.Errorf("unexpected error message: %v", errMsg.Error)
return
}
serverErrCh <- errForward
ctx, cancel := context.WithCancelCause(r.Context())
defer cancel(nil)
intervals := make(chan time.Duration, 1)
intervals <- 10 * time.Millisecond
newResponsesWebsocketWriter(conn).keepAlive(ctx, cancel, intervals)
serverErr <- context.Cause(ctx)
}))
defer server.Close()
wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
clientConn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
if err != nil {
t.Fatalf("dial websocket: %v", err)
}
// Close client connection immediately so the next server Ping write fails.
_ = clientConn.Close()
defer func() { _ = conn.Close() }()
select {
case serverErr := <-serverErrCh:
if serverErr == nil {
t.Fatal("expected error on server ping write failure, got nil")
case errKeepAlive := <-serverErr:
if !errors.Is(errKeepAlive, net.ErrClosed) {
t.Fatalf("keepalive cancellation cause = %v, want closed connection", errKeepAlive)
}
case <-time.After(2 * time.Second):
t.Fatal("server timed out awaiting ping write abort")
}
select {
case cancelErr := <-cancelledCh:
if cancelErr == nil {
t.Fatal("expected cancel callback to be invoked with ping error, got nil")
}
case <-time.After(time.Second):
t.Fatal("timed out awaiting cancel callback on ping write failure")
t.Fatal("timed out awaiting cancellation after Ping failed")
}
}