Skip to content

Modern Docker Management, Designed for Everyone

fix: surface container shell close reasons and drop websocket compression

Kyle Mendell30e1bb590a34
diff --git a/backend/api/ws/exec.go b/backend/api/ws/exec.go
index 28625bc42..337098200 100644
--- a/backend/api/ws/exec.go
+++ b/backend/api/ws/exec.go
@@ -14,6 +14,7 @@ import (
"github.com/coder/websocket"
"github.com/labstack/echo/v5"
+ wshub "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/ws"
systemtypes "github.com/getarcaneapp/arcane/types/v2/system"
)
@@ -43,37 +44,35 @@ func (h *WebSocketHandler) ContainerExec(c *echo.Context) error {
return nil
}
defer unregister()
- defer func() {
- if err := conn.CloseNow(); err != nil {
- slog.Debug("Failed to close container exec websocket connection", "containerID", containerID, "error", err)
- }
- }()
+ defer func() { _ = conn.CloseNow() }()
// Allow large terminal pastes; coder/websocket's default limit is 32KB.
conn.SetReadLimit(1 << 20)
- ctx, cancel := context.WithCancel(c.Request().Context())
- defer cancel()
+ ctx, cancel := context.WithCancelCause(c.Request().Context())
+ defer cancel(nil)
// The pong is serviced by the concurrent stdin reader.
- go keepWSConnAliveInternal(ctx, cancel, conn, 54*time.Second)
+ go keepWSConnAliveInternal(ctx, func() { cancel(errors.New("websocket ping failed")) }, conn, 54*time.Second)
h.runContainerExecInternal(ctx, cancel, conn, containerID, shell)
return nil
}
-func (h *WebSocketHandler) runContainerExecInternal(ctx context.Context, cancel context.CancelFunc, conn *websocket.Conn, containerID, shell string) {
- // Create exec instance
+func (h *WebSocketHandler) runContainerExecInternal(ctx context.Context, cancel context.CancelCauseFunc, conn *websocket.Conn, containerID, shell string) {
+ started := time.Now()
+
execID, err := h.containerService.CreateExec(ctx, containerID, []string{shell})
if err != nil {
h.writeExecErrorInternal(ctx, conn, errors.WithMessage(err, "Error creating exec"))
+ closeExecInternal(ctx, conn, containerID, "", started, errors.WithMessage(err, "create exec"))
return
}
- // Attach to exec
execSession, err := h.containerService.AttachExec(ctx, containerID, execID)
if err != nil {
h.writeExecErrorInternal(ctx, conn, errors.WithMessage(err, "Error attaching to exec"))
+ closeExecInternal(ctx, conn, containerID, execID, started, errors.WithMessage(err, "attach exec"))
return
}
// Cleanup must proceed even if the parent ctx is canceled, and must also
@@ -93,11 +92,15 @@ func (h *WebSocketHandler) runContainerExecInternal(ctx context.Context, cancel
cleanup()
}()
- done := make(chan struct{})
- go h.pipeExecOutputInternal(ctx, conn, execSession.Stdout(), execID, containerID, done)
- go h.pipeExecInputInternal(ctx, cancel, conn, execSession.Stdin(), execID, containerID)
+ done := make(chan error, 1)
+ go h.pipeExecOutputInternal(ctx, conn, execSession.Stdout(), done)
+ go h.pipeExecInputInternal(ctx, cancel, conn, execSession.Stdin())
- <-done
+ cause := <-done
+ if ctxCause := context.Cause(ctx); ctxCause != nil {
+ cause = ctxCause
+ }
+ closeExecInternal(ctx, conn, containerID, execID, started, cause)
}
func (h *WebSocketHandler) writeExecErrorInternal(ctx context.Context, conn *websocket.Conn, err error) {
@@ -106,40 +109,72 @@ func (h *WebSocketHandler) writeExecErrorInternal(ctx context.Context, conn *web
_ = conn.Write(wctx, websocket.MessageText, []byte(err.Error()+"\r\n"))
}
-func (h *WebSocketHandler) pipeExecOutputInternal(ctx context.Context, conn *websocket.Conn, stdout io.Reader, execID, containerID string, done chan<- struct{}) {
- defer close(done)
+// closeExecInternal completes the close handshake with a status and reason
+// derived from the terminating cause, so the browser can show why the
+// session ended, and logs the outcome with the session duration.
+func closeExecInternal(ctx context.Context, conn *websocket.Conn, containerID, execID string, started time.Time, cause error) {
+ status, reason, level := websocket.StatusNormalClosure, "shell exited", slog.LevelInfo
+ switch {
+ case cause == nil:
+ case wshub.IsExpectedClose(cause):
+ reason, level = "", slog.LevelDebug
+ case errors.Is(cause, context.Canceled):
+ status, reason = websocket.StatusGoingAway, "server shutting down"
+ default:
+ status, reason, level = websocket.StatusInternalError, cause.Error(), slog.LevelWarn
+ }
+ if len(reason) > 123 {
+ reason = reason[:123]
+ }
+ closeErr := conn.Close(status, reason)
+ slog.Log(ctx, level, "Container exec session ended",
+ "containerID", containerID,
+ "execID", execID,
+ "status", int(status),
+ "reason", reason,
+ "cause", cause,
+ "duration", time.Since(started),
+ "closeError", closeErr,
+ )
+}
+
+func (h *WebSocketHandler) pipeExecOutputInternal(ctx context.Context, conn *websocket.Conn, stdout io.Reader, done chan<- error) {
buf := make([]byte, 4096)
for {
select {
case <-ctx.Done():
+ done <- context.Cause(ctx)
return
default:
}
n, err := stdout.Read(buf)
if err != nil {
- slog.Debug("Exec stdout read error", "execID", execID, "containerID", containerID, "error", err)
+ if errors.Is(err, io.EOF) {
+ done <- nil
+ } else {
+ done <- errors.WithMessage(err, "exec output read")
+ }
return
}
if n > 0 {
if err := conn.Write(ctx, websocket.MessageBinary, buf[:n]); err != nil {
- slog.Debug("Exec websocket write error", "execID", execID, "containerID", containerID, "error", err)
+ done <- errors.WithMessage(err, "websocket write")
return
}
}
}
}
-func (h *WebSocketHandler) pipeExecInputInternal(ctx context.Context, cancel context.CancelFunc, conn *websocket.Conn, stdin io.Writer, execID, containerID string) {
+func (h *WebSocketHandler) pipeExecInputInternal(ctx context.Context, cancel context.CancelCauseFunc, conn *websocket.Conn, stdin io.Writer) {
for {
_, data, err := conn.Read(ctx)
if err != nil {
- slog.Debug("Exec websocket read error", "execID", execID, "containerID", containerID, "error", err)
- cancel()
+ cancel(errors.WithMessage(err, "websocket read"))
return
}
if _, err := stdin.Write(data); err != nil {
- slog.Debug("Exec stdin write error", "execID", execID, "containerID", containerID, "error", err)
+ cancel(errors.WithMessage(err, "exec input write"))
return
}
}
diff --git a/backend/pkg/libarcane/edge/ws_proxy.go b/backend/pkg/libarcane/edge/ws_proxy.go
index 217308397..14f3def05 100644
--- a/backend/pkg/libarcane/edge/ws_proxy.go
+++ b/backend/pkg/libarcane/edge/ws_proxy.go
@@ -164,7 +164,17 @@ func handleAgentMessage(ctx context.Context, streamCtx context.Context, clientWS
case MessageTypeWebSocketData, MessageTypeStreamData:
return false, writeWebSocketData(streamCtx, clientWS, msg)
case MessageTypeWebSocketClose, MessageTypeStreamClose, MessageTypeStreamEnd:
- slog.DebugContext(ctx, "Agent closed WebSocket stream", "stream_id", streamID)
+ slog.DebugContext(ctx, "Agent closed WebSocket stream", "stream_id", streamID, "error", msg.Error)
+ status, reason := websocket.StatusNormalClosure, msg.Error
+ if reason != "" {
+ status = websocket.StatusInternalError
+ if len(reason) > 123 {
+ reason = reason[:123]
+ }
+ }
+ if err := clientWS.Close(status, reason); err != nil {
+ slog.DebugContext(ctx, "Failed to close client WebSocket", "stream_id", streamID, "status", int(status), "error", err)
+ }
return true, nil
case MessageTypeRequest,
MessageTypeResponse,
diff --git a/backend/pkg/libarcane/ws/accept.go b/backend/pkg/libarcane/ws/accept.go
index a1304cfbd..e7a4fe878 100644
--- a/backend/pkg/libarcane/ws/accept.go
+++ b/backend/pkg/libarcane/ws/accept.go
@@ -18,7 +18,6 @@ func Accept(w http.ResponseWriter, r *http.Request, checkOrigin func(*http.Reque
}
return websocket.Accept(w, r, &websocket.AcceptOptions{
InsecureSkipVerify: true, // origin validated above
- CompressionMode: websocket.CompressionContextTakeover,
})
}
diff --git a/backend/pkg/libarcane/ws/proxy.go b/backend/pkg/libarcane/ws/proxy.go
index 4ae6efc76..591850536 100644
--- a/backend/pkg/libarcane/ws/proxy.go
+++ b/backend/pkg/libarcane/ws/proxy.go
@@ -71,6 +71,7 @@ func ProxyHTTP(w http.ResponseWriter, r *http.Request, remoteWS string, header h
for {
mt, msg, err := clientConn.Read(pumpCtx)
if err != nil {
+ relayCloseInternal(remoteConn, err)
return
}
if err := remoteConn.Write(pumpCtx, mt, msg); err != nil {
@@ -85,6 +86,7 @@ func ProxyHTTP(w http.ResponseWriter, r *http.Request, remoteWS string, header h
for {
mt, msg, err := remoteConn.Read(pumpCtx)
if err != nil {
+ relayCloseInternal(clientConn, err)
return
}
if err := clientConn.Write(pumpCtx, mt, msg); err != nil {
@@ -96,3 +98,19 @@ func ProxyHTTP(w http.ResponseWriter, r *http.Request, remoteWS string, header h
<-errc
return nil
}
+
+// relayCloseInternal forwards a peer's close status to the other side of the
+// bridge so the terminating reason survives the proxy hop.
+func relayCloseInternal(conn *websocket.Conn, err error) {
+ var ce websocket.CloseError
+ if !errors.As(err, &ce) {
+ return
+ }
+ code := ce.Code
+ if code == websocket.StatusNoStatusRcvd {
+ code = websocket.StatusNormalClosure
+ }
+ if closeErr := conn.Close(code, ce.Reason); closeErr != nil {
+ slog.Debug("failed to relay websocket close", "status", int(code), "err", closeErr)
+ }
+}
diff --git a/backend/pkg/libarcane/ws/proxy_test.go b/backend/pkg/libarcane/ws/proxy_test.go
index 5a36f1c85..f8ab9ab14 100644
--- a/backend/pkg/libarcane/ws/proxy_test.go
+++ b/backend/pkg/libarcane/ws/proxy_test.go
@@ -102,6 +102,7 @@ func TestProxyHTTP_RemoteClose(t *testing.T) {
defer func() {
_ = clientConn.CloseNow()
}()
+ clientConn.CloseRead(t.Context())
// The proxy should complete (not hang)
select {
diff --git a/frontend/src/lib/components/terminal/terminal.svelte b/frontend/src/lib/components/terminal/terminal.svelte
index 028375897..763112da6 100644
--- a/frontend/src/lib/components/terminal/terminal.svelte
+++ b/frontend/src/lib/components/terminal/terminal.svelte
@@ -23,6 +23,7 @@
let fitAddon: FitAddon | null = null;
let ws: WebSocket | null = null;
let isReconnecting = false;
+ let openedAt = 0;
let resizeObserver: ResizeObserver | null = null;
let isReady = $state(false);
@@ -126,6 +127,7 @@
ws.binaryType = 'arraybuffer';
ws.onopen = () => {
+ openedAt = Date.now();
onConnected?.();
};
@@ -150,7 +152,12 @@
if (!isReconnecting && terminal) {
// Surface the close code so reports of unexpected disconnects
// carry the reason (server 1000/1006, proxy 1001, ...) — see #3536.
- console.warn('Terminal websocket closed', { code: event.code, reason: event.reason, wasClean: event.wasClean });
+ console.warn('Terminal websocket closed', {
+ code: event.code,
+ reason: event.reason,
+ wasClean: event.wasClean,
+ durationMs: openedAt ? Date.now() - openedAt : null
+ });
const detail = event.reason ? `${event.code}: ${event.reason}` : `${event.code}`;
terminal.writeln(`\r\n\x1b[33m${m.terminal_connection_closed()} (${detail})\x1b[0m`);
onDisconnected?.();