Skip to content

Secure, Fast, and Extensible Sandbox runtime for AI agents.

test(execd): hold the takeover holder's pump in a write deterministically

Maohaoafdd85e719a3
diff --git a/components/execd/pkg/web/controller/pty_ws_test.go b/components/execd/pkg/web/controller/pty_ws_test.go
index 4962fd57c..82a335f55 100644
--- a/components/execd/pkg/web/controller/pty_ws_test.go
+++ b/components/execd/pkg/web/controller/pty_ws_test.go
@@ -18,10 +18,12 @@
package controller
import (
+ "context"
"encoding/binary"
"encoding/json"
"errors"
"fmt"
+ "net"
"net/http"
"net/http/httptest"
"strings"
@@ -587,50 +589,91 @@ func TestPTYWS_TakeoverEvictsHolder(t *testing.T) {
ptyOutputContains(t, conn2, "SAMESHELL_alive", 8*time.Second)
}
+// pipeListener hands the server one end of a net.Pipe per dial. With no socket
+// buffers in between, a server write blocks until the client reads it.
+type pipeListener struct {
+ conns chan net.Conn
+ done chan struct{}
+ closeOnce sync.Once
+}
+
+func newPipeListener() *pipeListener {
+ return &pipeListener{conns: make(chan net.Conn), done: make(chan struct{})}
+}
+
+func (l *pipeListener) Accept() (net.Conn, error) {
+ select {
+ case c := <-l.conns:
+ return c, nil
+ case <-l.done:
+ return nil, net.ErrClosed
+ }
+}
+
+func (l *pipeListener) Close() error {
+ l.closeOnce.Do(func() { close(l.done) })
+ return nil
+}
+
+func (l *pipeListener) Addr() net.Addr { return &net.UnixAddr{Name: "pipe", Net: "pipe"} }
+
+func (l *pipeListener) DialContext(ctx context.Context, _, _ string) (net.Conn, error) {
+ client, server := net.Pipe()
+ select {
+ case l.conns <- server:
+ return client, nil
+ case <-l.done:
+ case <-ctx.Done():
+ }
+ _ = client.Close()
+ _ = server.Close()
+ return nil, net.ErrClosed
+}
+
// TestPTYWS_TakeoverClosesBusyHolderWithCloseCode verifies that a holder whose
// output pump is in the middle of a write still gets the WSCloseTakenOver close
-// frame, rather than a bare TCP close (1006). The holder reads slowly until the
-// takeover handshake completes, so the pump is blocked writing when it is evicted.
+// frame, rather than a bare close (1006). The holder is connected over a pipe and
+// stops reading while it floods output, so the pump is blocked writing when the
+// takeover evicts it.
func TestPTYWS_TakeoverClosesBusyHolderWithCloseCode(t *testing.T) {
requireBash(t)
srv := newPTYTestServer(t)
defer srv.Close()
+ pl := newPipeListener()
+ pipeSrv := &http.Server{Handler: buildPTYRouter()}
+ go func() { _ = pipeSrv.Serve(pl) }()
+ defer pipeSrv.Close()
+
id := ptyCreateSession(t, srv)
+ // Delete the session to stop the flood: the new holder never reads its replay,
+ // so a Ctrl-C sent through it would never be handled.
+ runner := codeRunner
+ t.Cleanup(func() { _ = runner.DeletePTYSession(id) })
- conn1 := wsDialPTY(t, srv.URL, "/pty/"+id+"/ws", "")
+ dialer := websocket.Dialer{NetDialContext: pl.DialContext}
+ conn1, _, err := dialer.Dial("ws://pipe/pty/"+id+"/ws", nil)
+ require.NoError(t, err)
+ defer conn1.Close()
ptyWaitFrame(t, conn1, "connected", 10*time.Second)
ptyWriteStdin(t, conn1, "yes flood_output\n")
+ time.Sleep(100 * time.Millisecond)
- var readSlowly atomic.Bool
- readSlowly.Store(true)
- closeErrCh := make(chan *websocket.CloseError, 1)
- go func() {
- var closeErr *websocket.CloseError
- for {
- if _, _, err := conn1.ReadMessage(); err != nil {
- _ = errors.As(err, &closeErr)
- closeErrCh <- closeErr
- return
- }
- if readSlowly.Load() {
- time.Sleep(time.Millisecond)
- }
- }
- }()
- time.Sleep(500 * time.Millisecond)
-
- conn2 := wsDialPTY(t, srv.URL, "/pty/"+id+"/ws", "takeover=1")
- readSlowly.Store(false)
- defer ptyWriteStdin(t, conn2, "\x03")
+ _ = wsDialPTY(t, srv.URL, "/pty/"+id+"/ws", "takeover=1")
+ // The server evicts the holder right after the upgrade. Read again only once
+ // that is under way, well within wsTakeoverCloseTimeout.
+ time.Sleep(50 * time.Millisecond)
- select {
- case closeErr := <-closeErrCh:
- require.NotNil(t, closeErr, "holder should be closed with a WS CloseError after takeover")
- require.Equal(t, model.WSCloseTakenOver, closeErr.Code)
- case <-time.After(8 * time.Second):
- t.Fatal("holder was not closed after takeover")
+ var closeErr *websocket.CloseError
+ deadline := time.Now().Add(8 * time.Second)
+ for time.Now().Before(deadline) {
+ if _, _, err := conn1.ReadMessage(); err != nil {
+ _ = errors.As(err, &closeErr)
+ break
+ }
}
+ require.NotNil(t, closeErr, "holder should be closed with a WS CloseError after takeover")
+ require.Equal(t, model.WSCloseTakenOver, closeErr.Code)
}
// TestPTYWS_TakeoverOnFreeSessionConnects verifies ?takeover=1 is a no-op when the