Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: edge tunnel go routine leak (#3073)
Kyle Mendella087f1d83da2
diff --git a/backend/pkg/libarcane/edge/client.go b/backend/pkg/libarcane/edge/client.goindex 42c9c3b79..fa7b2d585 100644--- a/backend/pkg/libarcane/edge/client.go+++ b/backend/pkg/libarcane/edge/client.go@@ -11,6 +11,7 @@ import ("net/http""strings""sync"+ "sync/atomic""time""github.com/google/uuid"@@ -37,6 +38,7 @@ const (// activeWSStream tracks an active WebSocket stream on the agent side.type activeWSStream struct {ws *websocket.Conn+ conn TunnelConnection // tunnel connection the stream was opened oncancel context.CancelFuncdataCh chan wsPayloadmu sync.Mutex@@ -60,7 +62,7 @@ type TunnelClient struct {managerGRPCAddr stringlocalPort string // Port the agent is running on locallyhttpClient *http.Client- conn TunnelConnection+ conn atomic.Pointer[connBox]stopCh chan struct{}requestTimeout time.DurationactiveStreams sync.Map // map[string]*activeWSStream@@ -70,6 +72,29 @@ type TunnelClient struct {sessionID string}+// connBox wraps the active TunnelConnection so it can be swapped atomically on+// reconnect. The wrapper is required because the gRPC and WebSocket connections+// are different concrete types; a bare atomic.Value would panic on the type+// change, whereas an atomic.Pointer to a fixed box type does not.+type connBox struct {+ conn TunnelConnection+}++// setConn stores the active tunnel connection. The connection is reassigned on+// every (re)connect while goroutines (heartbeat, request handlers, stream send+// helpers) read it, so access goes through an atomic swap.+func (c *TunnelClient) setConn(conn TunnelConnection) {+ c.conn.Store(&connBox{conn: conn})+}++// getConn returns the active tunnel connection, or nil if none is established.+func (c *TunnelClient) getConn() TunnelConnection {+ if box := c.conn.Load(); box != nil {+ return box.conn+ }+ return nil+}+// NewTunnelClient creates a new tunnel clientfunc NewTunnelClient(cfg *Config, handler http.Handler) *TunnelClient {reconnectInterval := time.Duration(cfg.EdgeReconnectInterval) * time.Second@@ -359,10 +384,13 @@ func (c *TunnelClient) registerMessageInternal() *TunnelMessage {}func (c *TunnelClient) awaitRegistrationInternal(ctx context.Context) (*TunnelMessage, error) {- if c == nil || c.conn == nil {+ if c == nil {+ return nil, errors.New("edge tunnel connection is not initialized")+ }+ conn := c.getConn()+ if conn == nil {return nil, errors.New("edge tunnel connection is not initialized")}- conn := c.conntype registrationResult struct {msg *TunnelMessage@@ -414,7 +442,8 @@ func (c *TunnelClient) heartbeatLoop(ctx context.Context) {case <-ctx.Done():returncase <-ticker.C:- if c.conn == nil || c.conn.IsClosed() {+ conn := c.getConn()+ if conn == nil || conn.IsClosed() {return}@@ -423,10 +452,10 @@ func (c *TunnelClient) heartbeatLoop(ctx context.Context) {Type: MessageTypeHeartbeat,}- if err := c.conn.Send(msg); err != nil {+ if err := conn.Send(msg); err != nil {slog.WarnContext(ctx, "Failed to send heartbeat", "error", err)// Force reconnect so the manager does not keep stale state without heartbeats.- if closeErr := c.conn.Close(); closeErr != nil {+ if closeErr := conn.Close(); closeErr != nil {slog.DebugContext(ctx, "Failed to close tunnel connection after heartbeat failure", "error", closeErr)}return@@ -438,25 +467,30 @@ func (c *TunnelClient) heartbeatLoop(ctx context.Context) {// messageLoop processes incoming messages from the managerfunc (c *TunnelClient) messageLoop(ctx context.Context) error {+ // Tear down any streams opened on this connection when the loop exits so a+ // reconnect does not leak goroutines, local sockets, or activeStreams entries.+ defer c.closeAllStreams()++ conn := c.getConn()for {select {case <-ctx.Done():return ctx.Err()default:- msg, err := c.conn.Receive()+ msg, err := conn.Receive()if err != nil {return fmt.Errorf("failed to receive message: %w", err)}switch msg.Type {case MessageTypeRequest:- go c.handleRequest(ctx, msg)+ go c.handleRequest(ctx, conn, msg)case MessageTypeCommandRequest:- go c.handleCommandRequest(ctx, msg)+ go c.handleCommandRequest(ctx, conn, msg)case MessageTypeWebSocketStart:- c.handleWebSocketStart(ctx, msg)+ c.handleWebSocketStart(ctx, conn, msg)case MessageTypeStreamOpen:- c.handleStreamOpen(ctx, msg)+ c.handleStreamOpen(ctx, conn, msg)case MessageTypeWebSocketData:c.handleWebSocketData(ctx, msg)case MessageTypeStreamData:@@ -488,12 +522,15 @@ func (c *TunnelClient) messageLoop(ctx context.Context) error {}}-func (c *TunnelClient) handleCommandRequest(ctx context.Context, msg *TunnelMessage) {+func (c *TunnelClient) handleCommandRequest(ctx context.Context, conn TunnelConnection, msg *TunnelMessage) {if !ValidateEdgeCommand(msg.Command, msg.Method, msg.Path, false) {- c.sendCommandComplete(msg.ID, http.StatusBadRequest, nil, nil, "unsupported edge command", false)+ c.sendCommandComplete(conn, msg.ID, http.StatusBadRequest, nil, nil, "unsupported edge command", false)+ return+ }+ if conn == nil {return}- if err := c.conn.Send(&TunnelMessage{ID: msg.ID, Type: MessageTypeCommandAck, Command: msg.Command}); err != nil {+ if err := conn.Send(&TunnelMessage{ID: msg.ID, Type: MessageTypeCommandAck, Command: msg.Command}); err != nil {slog.WarnContext(ctx, "Failed to acknowledge edge command", "id", msg.ID, "command", msg.Command, "error", err)return}@@ -503,11 +540,11 @@ func (c *TunnelClient) handleCommandRequest(ctx context.Context, msg *TunnelMessreq, err := c.buildLocalHTTPRequest(reqCtx, msg)if err != nil {- c.sendCommandComplete(msg.ID, http.StatusInternalServerError, nil, nil, fmt.Sprintf("failed to create request: %v", err), false)+ c.sendCommandComplete(conn, msg.ID, http.StatusInternalServerError, nil, nil, fmt.Sprintf("failed to create request: %v", err), false)return}- recorder := newCommandResponseRecorderInternal(msg.ID, msg.Command, c.conn)+ recorder := newCommandResponseRecorderInternal(msg.ID, msg.Command, conn)c.handler.ServeHTTP(recorder, req)if err := recorder.Close(); err != nil {slog.WarnContext(reqCtx, "Failed to finalize command response", "id", msg.ID, "command", msg.Command, "error", err)@@ -550,9 +587,9 @@ func (c *TunnelClient) buildLocalHTTPRequest(ctx context.Context, msg *TunnelMes}// handleRequest processes an incoming request and sends back a response-func (c *TunnelClient) handleRequest(ctx context.Context, msg *TunnelMessage) {- if c.isGRPCConnectionInternal() {- c.handleRequestStreaming(ctx, msg)+func (c *TunnelClient) handleRequest(ctx context.Context, conn TunnelConnection, msg *TunnelMessage) {+ if isGRPCConnection(conn) {+ c.handleRequestStreaming(ctx, conn, msg)return}@@ -577,7 +614,7 @@ func (c *TunnelClient) handleRequest(ctx context.Context, msg *TunnelMessage) {req, err := http.NewRequestWithContext(reqCtx, msg.Method, path, body)if err != nil {- c.sendErrorResponse(msg.ID, http.StatusInternalServerError, fmt.Sprintf("failed to create request: %v", err))+ c.sendErrorResponse(conn, msg.ID, http.StatusInternalServerError, fmt.Sprintf("failed to create request: %v", err))return}@@ -622,22 +659,22 @@ func (c *TunnelClient) handleRequest(ctx context.Context, msg *TunnelMessage) {Body: rw.body.Bytes(),}- if err := c.conn.Send(resp); err != nil {+ if err := conn.Send(resp); err != nil {slog.ErrorContext(reqCtx, "Failed to send response", "id", msg.ID, "error", err)} else {slog.DebugContext(reqCtx, "Sent tunneled response", "id", msg.ID, "status", rw.statusCode)}}-func (c *TunnelClient) isGRPCConnectionInternal() bool {- if c == nil || c.conn == nil {+func isGRPCConnection(conn TunnelConnection) bool {+ if conn == nil {return false}- _, isGRPC := c.conn.(*GRPCAgentTunnelConn)+ _, isGRPC := conn.(*GRPCAgentTunnelConn)return isGRPC}-func (c *TunnelClient) handleRequestStreaming(ctx context.Context, msg *TunnelMessage) {+func (c *TunnelClient) handleRequestStreaming(ctx context.Context, conn TunnelConnection, msg *TunnelMessage) {reqCtx, cancel := context.WithTimeout(ctx, c.requestTimeout)defer cancel()reqCtx = withInternalTunnelRequestInternal(reqCtx)@@ -658,7 +695,7 @@ func (c *TunnelClient) handleRequestStreaming(ctx context.Context, msg *TunnelMereq, err := http.NewRequestWithContext(reqCtx, msg.Method, path, body)if err != nil {- c.sendErrorResponse(msg.ID, http.StatusInternalServerError, fmt.Sprintf("failed to create request: %v", err))+ c.sendErrorResponse(conn, msg.ID, http.StatusInternalServerError, fmt.Sprintf("failed to create request: %v", err))return}@@ -678,7 +715,7 @@ func (c *TunnelClient) handleRequestStreaming(ctx context.Context, msg *TunnelMereq.Header.Set(k, v)}- recorder := newStreamingResponseRecorder(msg.ID, c.conn)+ recorder := newStreamingResponseRecorder(msg.ID, conn)c.handler.ServeHTTP(recorder, req)if err := recorder.Close(); err != nil {@@ -687,7 +724,7 @@ func (c *TunnelClient) handleRequestStreaming(ctx context.Context, msg *TunnelMe}// handleWebSocketStart handles a WebSocket stream start request from the manager.-func (c *TunnelClient) handleWebSocketStart(ctx context.Context, msg *TunnelMessage) {+func (c *TunnelClient) handleWebSocketStart(ctx context.Context, conn TunnelConnection, msg *TunnelMessage) {if msg.Command == "" {if commandName, ok := ResolveEdgeCommandName(http.MethodGet, msg.Path, true); ok {msg.Command = commandName@@ -716,24 +753,24 @@ func (c *TunnelClient) handleWebSocketStart(ctx context.Context, msg *TunnelMess}}slog.ErrorContext(ctx, "Failed to dial local WebSocket", attrs...)- c.sendWebSocketClose(streamID)+ c.sendWebSocketClose(conn, streamID)return}streamCtx, cancel := context.WithCancel(ctx)- stream := c.registerStream(streamID, ws, cancel)+ stream := c.registerStream(conn, streamID, ws, cancel)go c.startLocalWebSocketReadLoop(ctx, streamCtx, streamID, ws, stream)go c.startLocalWebSocketWriteLoop(ctx, streamCtx, ws, stream, cancel)}-func (c *TunnelClient) handleStreamOpen(ctx context.Context, msg *TunnelMessage) {+func (c *TunnelClient) handleStreamOpen(ctx context.Context, conn TunnelConnection, msg *TunnelMessage) {if !ValidateEdgeCommand(msg.Command, http.MethodGet, msg.Path, true) {- c.sendStreamCloseMessage(msg.ID, "unsupported edge stream")+ c.sendStreamCloseMessage(conn, msg.ID, "unsupported edge stream")return}- c.handleWebSocketStart(ctx, &TunnelMessage{+ c.handleWebSocketStart(ctx, conn, &TunnelMessage{ID: msg.ID,Type: MessageTypeWebSocketStart,Command: msg.Command,@@ -834,9 +871,10 @@ func (c *TunnelClient) dialLocalWebSocket(ctx context.Context, localURL string,return dialer.DialContext(ctx, localURL, headers)}-func (c *TunnelClient) registerStream(streamID string, ws *websocket.Conn, cancel context.CancelFunc) *activeWSStream {+func (c *TunnelClient) registerStream(conn TunnelConnection, streamID string, ws *websocket.Conn, cancel context.CancelFunc) *activeWSStream {stream := &activeWSStream{ws: ws,+ conn: conn,cancel: cancel,dataCh: make(chan wsPayload, 100),}@@ -859,6 +897,23 @@ func (c *TunnelClient) closeWebSocketStream(streamID string, stream *activeWSStrc.activeStreams.Delete(streamID)}+// closeAllStreams tears down every active WebSocket stream. It is called when+// the message loop exits so a reconnect cannot leak stream goroutines, local+// sockets, or activeStreams entries. closeWebSocketStream is idempotent, so it+// is safe to race a concurrent manager-driven stream close.+func (c *TunnelClient) closeAllStreams() {+ c.activeStreams.Range(func(key, value any) bool {+ streamID, ok := key.(string)+ if !ok {+ return true+ }+ if stream, ok := value.(*activeWSStream); ok {+ c.closeWebSocketStream(streamID, stream)+ }+ return true+ })+}+func (c *TunnelClient) startLocalWebSocketReadLoop(ctx context.Context, streamCtx context.Context, streamID string, ws *websocket.Conn, stream *activeWSStream) {defer func() {c.closeWebSocketStream(streamID, stream)@@ -877,11 +932,11 @@ func (c *TunnelClient) startLocalWebSocketReadLoop(ctx context.Context, streamCtwebsocket.CloseNoStatusReceived) {slog.DebugContext(ctx, "Local WebSocket read error", "error", err)}- c.sendWebSocketClose(streamID)+ c.sendWebSocketClose(stream.conn, streamID)return}- if err := c.sendWebSocketData(streamID, msgType, data); err != nil {+ if err := c.sendWebSocketData(stream.conn, streamID, msgType, data); err != nil {slog.DebugContext(ctx, "Failed to send WebSocket data to manager", "error", err)return}@@ -911,27 +966,33 @@ func (c *TunnelClient) startLocalWebSocketWriteLoop(ctx context.Context, streamC}}-func (c *TunnelClient) sendWebSocketData(streamID string, msgType int, data []byte) error {+func (c *TunnelClient) sendWebSocketData(conn TunnelConnection, streamID string, msgType int, data []byte) error {+ if conn == nil {+ return ErrNoActiveAgentTunnel+ }wsDataMsg := &TunnelMessage{ID: streamID,Type: MessageTypeWebSocketData,Body: data,WSMessageType: msgType,}- return c.conn.Send(wsDataMsg)+ return conn.Send(wsDataMsg)}-func (c *TunnelClient) sendWebSocketClose(streamID string) {- c.sendStreamCloseMessage(streamID, "")+func (c *TunnelClient) sendWebSocketClose(conn TunnelConnection, streamID string) {+ c.sendStreamCloseMessage(conn, streamID, "")}-func (c *TunnelClient) sendStreamCloseMessage(streamID string, message string) {+func (c *TunnelClient) sendStreamCloseMessage(conn TunnelConnection, streamID string, message string) {+ if conn == nil {+ return+ }closeMsg := &TunnelMessage{ID: streamID,Type: MessageTypeStreamClose,Error: message,}- _ = c.conn.Send(closeMsg)+ _ = conn.Send(closeMsg)}// handleWebSocketData handles incoming WebSocket data from the manager.@@ -983,18 +1044,24 @@ func (c *TunnelClient) handleStreamClose(ctx context.Context, msg *TunnelMessage}// sendErrorResponse sends an error response-func (c *TunnelClient) sendErrorResponse(requestID string, status int, message string) {+func (c *TunnelClient) sendErrorResponse(conn TunnelConnection, requestID string, status int, message string) {+ if conn == nil {+ return+ }resp := &TunnelMessage{ID: requestID,Type: MessageTypeResponse,Status: status,Body: []byte(message),}- _ = c.conn.Send(resp)+ _ = conn.Send(resp)}-func (c *TunnelClient) sendCommandComplete(commandID string, status int, headers map[string]string, body []byte, message string, streaming bool) {- _ = c.conn.Send(&TunnelMessage{+func (c *TunnelClient) sendCommandComplete(conn TunnelConnection, commandID string, status int, headers map[string]string, body []byte, message string, streaming bool) {+ if conn == nil {+ return+ }+ _ = conn.Send(&TunnelMessage{ID: commandID,Type: MessageTypeCommandComplete,Status: status,diff --git a/backend/pkg/libarcane/edge/client_test.go b/backend/pkg/libarcane/edge/client_test.goindex e214dc67e..62430f8b1 100644--- a/backend/pkg/libarcane/edge/client_test.go+++ b/backend/pkg/libarcane/edge/client_test.go@@ -6,6 +6,7 @@ import ("errors""fmt""io"+ "log/slog""maps""net""net/http"@@ -21,6 +22,7 @@ import (httputil "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx""github.com/gorilla/websocket""github.com/labstack/echo/v4"+ slogecho "github.com/samber/slog-echo""github.com/stretchr/testify/assert""github.com/stretchr/testify/require""golang.org/x/net/http2"@@ -187,6 +189,123 @@ func TestTunnelClient_WebSocketProxy(t *testing.T) {time.Sleep(100 * time.Millisecond)}+// TestTunnelClient_WebSocket_ReconnectClosesStreams verifies that a reconnect+// reclaims the goroutines, local sockets, and activeStreams entries opened on+// the previous connection instead of leaking them. Run under -race it also+// exercises concurrent c.conn access across the reassignment on reconnect.+func TestTunnelClient_WebSocket_ReconnectClosesStreams(t *testing.T) {+ // Local WS echo server the agent proxies to.+ localServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ upgrader := websocket.Upgrader{}+ conn, err := upgrader.Upgrade(w, r, nil)+ if err != nil {+ return+ }+ defer func() { _ = conn.Close() }()+ for {+ mt, data, err := conn.ReadMessage()+ if err != nil {+ return+ }+ _ = conn.WriteMessage(mt, append([]byte("local echo: "), data...))+ }+ }))+ defer localServer.Close()+ localPort := strings.Split(localServer.Listener.Addr().String(), ":")[1]++ var connCount atomic.Int32+ firstStreamLive := make(chan struct{})+ closeFirstConn := make(chan struct{})+ stopManager := make(chan struct{})++ managerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ upgrader := websocket.Upgrader{}+ conn, err := upgrader.Upgrade(w, r, nil)+ if err != nil {+ return+ }+ defer func() { _ = conn.Close() }()++ // Every connection registers first.+ if _, _, err := conn.ReadMessage(); err != nil {+ return+ }+ registerResp, _ := json.Marshal(&TunnelMessage{+ Type: MessageTypeRegisterResponse,+ Accepted: true,+ SessionID: "session-1",+ })+ _ = conn.WriteMessage(websocket.TextMessage, registerResp)++ if connCount.Add(1) > 1 {+ // Post-reconnect connection: stay up so the agent stops reconnecting+ // and the test can assert a stable, empty stream set.+ <-stopManager+ return+ }++ // First connection: open a stream and prove it is live by round-tripping+ // data through the local echo server, then force a disconnect.+ startMsg, _ := json.Marshal(&TunnelMessage{ID: "ws-1", Type: MessageTypeWebSocketStart, Path: "/"})+ _ = conn.WriteMessage(websocket.TextMessage, startMsg)+ dataMsg, _ := json.Marshal(&TunnelMessage{+ ID: "ws-1",+ Type: MessageTypeWebSocketData,+ Body: []byte("hello"),+ WSMessageType: websocket.TextMessage,+ })+ _ = conn.WriteMessage(websocket.TextMessage, dataMsg)++ _, respData, err := conn.ReadMessage()+ if err != nil {+ return+ }+ var resp TunnelMessage+ _ = json.Unmarshal(respData, &resp)+ assert.Equal(t, MessageTypeWebSocketData, resp.Type)+ assert.Equal(t, "local echo: hello", string(resp.Body))++ close(firstStreamLive)+ <-closeFirstConn // returning closes the conn, forcing the agent to reconnect+ }))+ defer managerServer.Close()++ cfg := &Config{+ EdgeTransport: EdgeTransportWebSocket,+ ManagerApiUrl: managerServer.URL,+ AgentToken: "test-token",+ Port: localPort,+ }+ client := NewTunnelClient(cfg, http.NotFoundHandler())+ client.managerURL = "ws" + strings.TrimPrefix(managerServer.URL, "http")+ client.reconnectInterval = 50 * time.Millisecond++ countStreams := func() int {+ n := 0+ client.activeStreams.Range(func(_, _ any) bool { n++; return true })+ return n+ }++ ctx, cancel := context.WithCancel(context.Background())+ defer cancel()+ defer close(stopManager)+ go client.StartWithErrorChan(ctx, nil)++ // The stream is registered while the first connection is live.+ select {+ case <-firstStreamLive:+ case <-time.After(5 * time.Second):+ t.Fatal("timed out waiting for the first stream to come up")+ }+ assert.Equal(t, 1, countStreams(), "expected one active stream during the first connection")++ // Force the disconnect; the reconnect must reclaim the stream.+ close(closeFirstConn)+ require.Eventually(t, func() bool {+ return connCount.Load() >= 2 && countStreams() == 0+ }, 5*time.Second, 20*time.Millisecond, "stream leaked across reconnect")+}+func TestTunnelClient_HandleRequest_Errors(t *testing.T) {// Setup Mock ManagermanagerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {@@ -279,17 +398,18 @@ func TestTunnelClient_InternalHelpers(t *testing.T) {}defer func() { _ = conn.Close() }()- client.conn = NewTunnelConn(conn)+ tunnelConn := NewTunnelConn(conn)+ client.setConn(tunnelConn)// Test sendWebSocketData- err = client.sendWebSocketData("stream-1", websocket.TextMessage, []byte("data"))+ err = client.sendWebSocketData(tunnelConn, "stream-1", websocket.TextMessage, []byte("data"))require.NoError(t, err)// Test sendWebSocketClose- client.sendWebSocketClose("stream-1")+ client.sendWebSocketClose(tunnelConn, "stream-1")// Test sendErrorResponse- client.sendErrorResponse("req-1", 500, "error")+ client.sendErrorResponse(tunnelConn, "req-1", 500, "error")}func TestTunnelClient_BuildLocalWebSocketURL(t *testing.T) {@@ -527,18 +647,15 @@ func TestTunnelClient_DialLocalWebSocket_StripsForwardedBrowserHeaders(t *testinfunc TestTunnelClient_IsGRPCConnectionInternal(t *testing.T) {t.Run("nil connection", func(t *testing.T) {- client := &TunnelClient{}- assert.False(t, client.isGRPCConnectionInternal())+ assert.False(t, isGRPCConnection(nil))})t.Run("grpc connection", func(t *testing.T) {- client := &TunnelClient{conn: NewGRPCAgentTunnelConn(nil)}- assert.True(t, client.isGRPCConnectionInternal())+ assert.True(t, isGRPCConnection(NewGRPCAgentTunnelConn(nil)))})t.Run("non-grpc connection", func(t *testing.T) {- client := &TunnelClient{conn: &fakeTunnelConnForTransportCheck{}}- assert.False(t, client.isGRPCConnectionInternal())+ assert.False(t, isGRPCConnection(&fakeTunnelConnForTransportCheck{}))})}@@ -554,9 +671,9 @@ func TestTunnelClient_HandleRequest_GRPCConfigWithWebSocketConnUsesNonStreamingREdgeTransport: EdgeTransportGRPC,}, localHandler)conn := &capturingTunnelConnForHandleRequest{}- client.conn = conn+ client.setConn(conn)- client.handleRequest(context.Background(), &TunnelMessage{+ client.handleRequest(context.Background(), conn, &TunnelMessage{ID: "req-fallback-1",Type: MessageTypeRequest,Method: http.MethodGet,@@ -572,9 +689,9 @@ func TestTunnelClient_HandleRequest_GRPCConfigWithWebSocketConnUsesNonStreamingRfunc TestTunnelClient_HeartbeatLoop_ClosesConnectionOnSendFailure(t *testing.T) {conn := &failingHeartbeatConn{}client := &TunnelClient{- conn: conn,heartbeatInterval: 5 * time.Millisecond,}+ client.setConn(conn)ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)defer cancel()@@ -949,7 +1066,7 @@ func TestTunnelClient_connectAndServeGRPC_TimesOutWithoutRegisterResponse(t *tesrequire.Error(t, err)assert.Contains(t, err.Error(), "timed out waiting for tunnel registration response")assert.EqualValues(t, 1, service.connectCount.Load())- assert.True(t, client.conn == nil || client.conn.IsClosed())+ assert.True(t, client.getConn() == nil || client.getConn().IsClosed())}func TestTunnelClient_awaitGRPCRegistrationInternal_ClosesConnOnContextDone(t *testing.T) {@@ -958,9 +1075,9 @@ func TestTunnelClient_awaitGRPCRegistrationInternal_ClosesConnOnContextDone(t *tconn := newBlockingRegistrationConnInternal()client := &TunnelClient{- conn: conn,grpcRegistrationTimeout: time.Second,}+ client.setConn(conn)msg, err := client.awaitGRPCRegistrationInternal(ctx)require.Nil(t, msg)@@ -981,9 +1098,9 @@ func TestTunnelClient_awaitGRPCRegistrationInternal_ClosesAttemptConnWhenClientC})client := &TunnelClient{- conn: firstConn,grpcRegistrationTimeout: time.Second,}+ client.setConn(firstConn)type registrationResult struct {msg *TunnelMessage@@ -1001,7 +1118,7 @@ func TestTunnelClient_awaitGRPCRegistrationInternal_ClosesAttemptConnWhenClientCt.Fatal("registration receive did not start")}- client.conn = secondConn+ client.setConn(secondConn)cancel()select {@@ -1916,3 +2033,170 @@ func (f roundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) {}return f(req)}++func TestTunnelClient_InternalRequestSkipsSlogEcho(t *testing.T) {+ tests := []struct {+ name string+ run func(t *testing.T, client *TunnelClient)+ }{+ {+ name: "legacy response",+ run: func(t *testing.T, client *TunnelClient) {+ conn := &capturingTunnelConnForHandleRequest{}+ client.setConn(conn)++ client.handleRequest(context.Background(), conn, &TunnelMessage{+ ID: "req-legacy",+ Type: MessageTypeRequest,+ Method: http.MethodGet,+ Path: "/local/api",+ })++ require.Len(t, conn.sent, 1)+ assert.Equal(t, MessageTypeResponse, conn.sent[0].Type)+ assert.Equal(t, http.StatusOK, conn.sent[0].Status)+ assert.Equal(t, "local response", string(conn.sent[0].Body))+ },+ },+ {+ name: "streaming response",+ run: func(t *testing.T, client *TunnelClient) {+ conn := &fakeTunnelConn{}+ client.setConn(conn)++ client.handleRequestStreaming(context.Background(), conn, &TunnelMessage{+ ID: "req-stream",+ Type: MessageTypeRequest,+ Method: http.MethodGet,+ Path: "/local/api",+ })++ require.Len(t, conn.msgs, 3)+ assert.Equal(t, MessageTypeResponse, conn.msgs[0].Type)+ assert.Equal(t, http.StatusOK, conn.msgs[0].Status)+ assert.Equal(t, MessageTypeStreamData, conn.msgs[1].Type)+ assert.Equal(t, "local response", string(conn.msgs[1].Body))+ assert.Equal(t, MessageTypeStreamEnd, conn.msgs[2].Type)+ },+ },+ }++ for _, testCase := range tests {+ t.Run(testCase.name, func(t *testing.T) {+ var sawInternalTunnelRequest bool+ loggerMiddleware := slogecho.New(slog.Default())++ router := echo.New()+ router.Use(func(next echo.HandlerFunc) echo.HandlerFunc {+ return func(c echo.Context) error {+ if IsInternalTunnelRequest(c.Request().Context()) {+ sawInternalTunnelRequest = true+ return next(c)+ }+ return loggerMiddleware(next)(c)+ }+ })+ router.GET("/local/api", func(c echo.Context) error {+ return c.String(http.StatusOK, "local response")+ })++ client := NewTunnelClient(&Config{}, router)+ testCase.run(t, client)++ assert.True(t, sawInternalTunnelRequest)+ })+ }+}++type fakeTunnelConn struct {+ mu sync.Mutex+ msgs []*TunnelMessage+ closed bool+ sendErr error+}++func (f *fakeTunnelConn) Send(msg *TunnelMessage) error {+ f.mu.Lock()+ defer f.mu.Unlock()+ if f.sendErr != nil {+ return f.sendErr+ }+ copyMsg := *msg+ if msg.Headers != nil {+ copyMsg.Headers = cloneHeaderMap(msg.Headers)+ }+ if msg.Body != nil {+ copyMsg.Body = append([]byte(nil), msg.Body...)+ }+ f.msgs = append(f.msgs, ©Msg)+ return nil+}++func (f *fakeTunnelConn) Receive() (*TunnelMessage, error) {+ return nil, errors.New("not implemented")+}++func (f *fakeTunnelConn) IsExpectedReceiveError(error) bool {+ return false+}++func (f *fakeTunnelConn) Close() error {+ f.mu.Lock()+ defer f.mu.Unlock()+ f.closed = true+ return nil+}++func (f *fakeTunnelConn) IsClosed() bool {+ f.mu.Lock()+ defer f.mu.Unlock()+ return f.closed+}++func (f *fakeTunnelConn) SendRequest(_ context.Context, _ *TunnelMessage, _ *sync.Map) (*TunnelMessage, error) {+ return nil, errors.New("not implemented")+}++func TestStreamingResponseRecorder_Sequence(t *testing.T) {+ conn := &fakeTunnelConn{}+ r := newStreamingResponseRecorder("req-1", conn)++ r.Header().Set("Content-Type", "text/plain")++ n, err := r.Write([]byte("hello"))+ require.NoError(t, err)+ assert.Equal(t, 5, n)++ n, err = r.Write([]byte(" world"))+ require.NoError(t, err)+ assert.Equal(t, 6, n)++ require.NoError(t, r.Close())++ require.Len(t, conn.msgs, 4)+ assert.Equal(t, MessageTypeResponse, conn.msgs[0].Type)+ assert.Equal(t, "req-1", conn.msgs[0].ID)+ assert.Equal(t, "text/plain", conn.msgs[0].Headers["Content-Type"])+ assert.Equal(t, "1", conn.msgs[0].Headers["X-Arcane-Tunnel-Stream"])++ assert.Equal(t, MessageTypeStreamData, conn.msgs[1].Type)+ assert.Equal(t, "hello", string(conn.msgs[1].Body))++ assert.Equal(t, MessageTypeStreamData, conn.msgs[2].Type)+ assert.Equal(t, " world", string(conn.msgs[2].Body))++ assert.Equal(t, MessageTypeStreamEnd, conn.msgs[3].Type)+}++func TestStreamingResponseRecorder_WriteHeaderAndClose(t *testing.T) {+ conn := &fakeTunnelConn{}+ r := newStreamingResponseRecorder("req-2", conn)++ r.WriteHeader(http.StatusCreated)+ require.NoError(t, r.Close())++ require.Len(t, conn.msgs, 2)+ assert.Equal(t, MessageTypeResponse, conn.msgs[0].Type)+ assert.Equal(t, http.StatusCreated, conn.msgs[0].Status)+ assert.Equal(t, MessageTypeStreamEnd, conn.msgs[1].Type)+}diff --git a/backend/pkg/libarcane/edge/client_transport_grpc.go b/backend/pkg/libarcane/edge/client_transport_grpc.goindex fdb2c10ad..5ff3d0946 100644--- a/backend/pkg/libarcane/edge/client_transport_grpc.go+++ b/backend/pkg/libarcane/edge/client_transport_grpc.go@@ -81,10 +81,11 @@ func (c *TunnelClient) connectAndServeGRPC(ctx context.Context) error {return fmt.Errorf("failed to open tunnel stream: %w", err)}- c.conn = NewGRPCAgentTunnelConn(stream, streamCancel)- setActiveAgentTunnelConn(c.conn)- defer clearActiveAgentTunnelConn(c.conn)- if err := c.conn.Send(c.registerMessageInternal()); err != nil {+ tunnelConn := NewGRPCAgentTunnelConn(stream, streamCancel)+ c.setConn(tunnelConn)+ setActiveAgentTunnelConn(tunnelConn)+ defer clearActiveAgentTunnelConn(tunnelConn)+ if err := tunnelConn.Send(c.registerMessageInternal()); err != nil {return fmt.Errorf("failed to send register message: %w", err)}@@ -99,11 +100,11 @@ func (c *TunnelClient) connectAndServeGRPC(ctx context.Context) error {)c.markTransportConnectedInternal(EdgeTransportGRPC)- heartbeatCtx, heartbeatCancel := context.WithCancel(ctx)- defer heartbeatCancel()- go c.heartbeatLoop(heartbeatCtx)+ connCtx, connCancel := context.WithCancel(ctx)+ defer connCancel()+ go c.heartbeatLoop(connCtx)- return c.messageLoop(ctx)+ return c.messageLoop(connCtx)}func (c *TunnelClient) waitForGRPCReadyInternal(ctx context.Context, conn *grpc.ClientConn) error {diff --git a/backend/pkg/libarcane/edge/grpc_tunnel_integration_test.go b/backend/pkg/libarcane/edge/client_transport_grpc_test.gosimilarity index 100%rename from backend/pkg/libarcane/edge/grpc_tunnel_integration_test.gorename to backend/pkg/libarcane/edge/client_transport_grpc_test.godiff --git a/backend/pkg/libarcane/edge/client_transport_websocket.go b/backend/pkg/libarcane/edge/client_transport_websocket.goindex 1183abf32..f116d88c4 100644--- a/backend/pkg/libarcane/edge/client_transport_websocket.go+++ b/backend/pkg/libarcane/edge/client_transport_websocket.go@@ -50,10 +50,11 @@ func (c *TunnelClient) connectAndServeWebSocket(ctx context.Context) error {}defer func() { _ = conn.Close() }()- c.conn = NewTunnelConn(conn)- setActiveAgentTunnelConn(c.conn)- defer clearActiveAgentTunnelConn(c.conn)- if err := c.conn.Send(c.registerMessageInternal()); err != nil {+ tunnelConn := NewTunnelConn(conn)+ c.setConn(tunnelConn)+ setActiveAgentTunnelConn(tunnelConn)+ defer clearActiveAgentTunnelConn(tunnelConn)+ if err := tunnelConn.Send(c.registerMessageInternal()); err != nil {return fmt.Errorf("failed to send websocket register message: %w", err)}registerMsg, err := c.awaitRegistrationInternal(ctx)@@ -67,9 +68,9 @@ func (c *TunnelClient) connectAndServeWebSocket(ctx context.Context) error {)c.markTransportConnectedInternal(EdgeTransportWebSocket)- heartbeatCtx, heartbeatCancel := context.WithCancel(ctx)- defer heartbeatCancel()- go c.heartbeatLoop(heartbeatCtx)+ connCtx, connCancel := context.WithCancel(ctx)+ defer connCancel()+ go c.heartbeatLoop(connCtx)- return c.messageLoop(ctx)+ return c.messageLoop(connCtx)}diff --git a/backend/pkg/libarcane/edge/internal_tunnel_request_test.go b/backend/pkg/libarcane/edge/internal_tunnel_request_test.godeleted file mode 100644index 9f95bee1c..000000000--- a/backend/pkg/libarcane/edge/internal_tunnel_request_test.go+++ /dev/null@@ -1,87 +0,0 @@-package edge--import (- "context"- "log/slog"- "net/http"- "testing"-- "github.com/labstack/echo/v4"- slogecho "github.com/samber/slog-echo"- "github.com/stretchr/testify/assert"- "github.com/stretchr/testify/require"-)--func TestTunnelClient_InternalRequestSkipsSlogEcho(t *testing.T) {- tests := []struct {- name string- run func(t *testing.T, client *TunnelClient)- }{- {- name: "legacy response",- run: func(t *testing.T, client *TunnelClient) {- conn := &capturingTunnelConnForHandleRequest{}- client.conn = conn-- client.handleRequest(context.Background(), &TunnelMessage{- ID: "req-legacy",- Type: MessageTypeRequest,- Method: http.MethodGet,- Path: "/local/api",- })-- require.Len(t, conn.sent, 1)- assert.Equal(t, MessageTypeResponse, conn.sent[0].Type)- assert.Equal(t, http.StatusOK, conn.sent[0].Status)- assert.Equal(t, "local response", string(conn.sent[0].Body))- },- },- {- name: "streaming response",- run: func(t *testing.T, client *TunnelClient) {- conn := &fakeTunnelConn{}- client.conn = conn-- client.handleRequestStreaming(context.Background(), &TunnelMessage{- ID: "req-stream",- Type: MessageTypeRequest,- Method: http.MethodGet,- Path: "/local/api",- })-- require.Len(t, conn.msgs, 3)- assert.Equal(t, MessageTypeResponse, conn.msgs[0].Type)- assert.Equal(t, http.StatusOK, conn.msgs[0].Status)- assert.Equal(t, MessageTypeStreamData, conn.msgs[1].Type)- assert.Equal(t, "local response", string(conn.msgs[1].Body))- assert.Equal(t, MessageTypeStreamEnd, conn.msgs[2].Type)- },- },- }-- for _, testCase := range tests {- t.Run(testCase.name, func(t *testing.T) {- var sawInternalTunnelRequest bool- loggerMiddleware := slogecho.New(slog.Default())-- router := echo.New()- router.Use(func(next echo.HandlerFunc) echo.HandlerFunc {- return func(c echo.Context) error {- if IsInternalTunnelRequest(c.Request().Context()) {- sawInternalTunnelRequest = true- return next(c)- }- return loggerMiddleware(next)(c)- }- })- router.GET("/local/api", func(c echo.Context) error {- return c.String(http.StatusOK, "local response")- })-- client := NewTunnelClient(&Config{}, router)- testCase.run(t, client)-- assert.True(t, sawInternalTunnelRequest)- })- }-}diff --git a/backend/pkg/libarcane/edge/proxy_headers_test.go b/backend/pkg/libarcane/edge/proxy_headers_test.godeleted file mode 100644index b4e961ecd..000000000--- a/backend/pkg/libarcane/edge/proxy_headers_test.go+++ /dev/null@@ -1,350 +0,0 @@-package edge--import (- "bytes"- "context"- "encoding/json"- "net/http"- "net/http/httptest"- "testing"-- "github.com/gorilla/websocket"- "github.com/labstack/echo/v4"- "github.com/stretchr/testify/assert"- "github.com/stretchr/testify/require"-)--func TestIsBrowserSecurityHeader(t *testing.T) {- browserHeaders := []string{- "Origin",- "Referer",- "Cookie",- "Access-Control-Request-Method",- "Access-Control-Request-Headers",- "Sec-Fetch-Mode",- "Sec-Fetch-Site",- "Sec-Fetch-Dest",- }-- for _, h := range browserHeaders {- assert.True(t, isBrowserSecurityHeader(h), "expected %q to be a browser security header", h)- }-- nonBrowserHeaders := []string{- "Content-Type",- "Authorization",- "X-Custom-Header",- "X-Arcane-Agent-Token",- "X-API-Key",- "Accept",- }-- for _, h := range nonBrowserHeaders {- assert.False(t, isBrowserSecurityHeader(h), "expected %q to NOT be a browser security header", h)- }-}--func TestProxyHTTPRequest_StripsBrowserHeaders(t *testing.T) {- var receivedHeaders map[string]string-- server, tunnel := setupMockAgentServer(t, func(msg *TunnelMessage) *TunnelMessage {- receivedHeaders = msg.Headers- return &TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusOK,- Headers: map[string]string{"Content-Type": "application/json"},- Body: []byte(`{"ok":true}`),- }- })- defer server.Close()- defer func() { _ = tunnel.Close() }()-- e := echo.New()- w := httptest.NewRecorder()- req := httptest.NewRequest(http.MethodPost, "/test", bytes.NewBufferString(`{"name":"test"}`))-- req.Header.Set("Origin", "http://192.168.1.42:30258")- req.Header.Set("Referer", "http://192.168.1.42:30258/projects/new")- req.Header.Set("Cookie", "token=some-jwt-token")- req.Header.Set("Sec-Fetch-Mode", "cors")- req.Header.Set("Sec-Fetch-Site", "same-origin")- req.Header.Set("Sec-Fetch-Dest", "empty")- req.Header.Set("Access-Control-Request-Method", "POST")- req.Header.Set("Access-Control-Request-Headers", "Content-Type")-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("X-Arcane-Agent-Token", "agent-tok-123")- req.Header.Set("X-API-Key", "agent-tok-123")- req.Header.Set("Authorization", "Bearer jwt-token")- c := e.NewContext(req, w)-- _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")-- assert.Equal(t, http.StatusOK, w.Code)-- // Browser security headers should NOT be present on the agent side- assert.Empty(t, receivedHeaders["Origin"], "Origin header should be stripped")- assert.Empty(t, receivedHeaders["Referer"], "Referer header should be stripped")- assert.Empty(t, receivedHeaders["Cookie"], "Cookie header should be stripped")- assert.Empty(t, receivedHeaders["Sec-Fetch-Mode"], "Sec-Fetch-Mode header should be stripped")- assert.Empty(t, receivedHeaders["Sec-Fetch-Site"], "Sec-Fetch-Site header should be stripped")- assert.Empty(t, receivedHeaders["Sec-Fetch-Dest"], "Sec-Fetch-Dest header should be stripped")- assert.Empty(t, receivedHeaders["Access-Control-Request-Method"], "Access-Control-Request-Method should be stripped")- assert.Empty(t, receivedHeaders["Access-Control-Request-Headers"], "Access-Control-Request-Headers should be stripped")-- // Important headers SHOULD still be forwarded- assert.Equal(t, "application/json", receivedHeaders["Content-Type"])- assert.Equal(t, "agent-tok-123", receivedHeaders["X-Arcane-Agent-Token"])- assert.Equal(t, "agent-tok-123", receivedHeaders["X-Api-Key"])- assert.Equal(t, "Bearer jwt-token", receivedHeaders["Authorization"])-}--func TestProxyHTTPRequest_ForwardsBodyCorrectly(t *testing.T) {- var receivedBody []byte- var receivedMethod string-- server, tunnel := setupMockAgentServer(t, func(msg *TunnelMessage) *TunnelMessage {- receivedBody = msg.Body- receivedMethod = msg.Method- return &TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusCreated,- Headers: map[string]string{"Content-Type": "application/json"},- Body: []byte(`{"id":"proj-1","name":"test"}`),- }- })- defer server.Close()- defer func() { _ = tunnel.Close() }()-- requestBody := `{"name":"My Project"}`-- e := echo.New()- w := httptest.NewRecorder()- req := httptest.NewRequest(http.MethodPost, "/api/environments/abc/projects", bytes.NewBufferString(requestBody))- req.Header.Set("Content-Type", "application/json")- req.Header.Set("X-Arcane-Agent-Token", "tok")- c := e.NewContext(req, w)-- _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")-- assert.Equal(t, http.StatusCreated, w.Code)- assert.Equal(t, http.MethodPost, receivedMethod)- assert.Equal(t, requestBody, string(receivedBody), "Request body should be forwarded intact through the tunnel")-}--func TestHandleRequest_SetsHostField(t *testing.T) {- localHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- // Verify Host is properly set from the tunneled headers- assert.Equal(t, "my-agent-host:3552", r.Host, "Host field should be set from tunnel message headers")- w.WriteHeader(http.StatusOK)- _, _ = w.Write([]byte("ok"))- })-- client := NewTunnelClient(&Config{}, localHandler)- conn := &capturingTunnelConnForHandleRequest{}- client.conn = conn-- client.handleRequest(context.Background(), &TunnelMessage{- ID: "req-host-1",- Type: MessageTypeRequest,- Method: http.MethodGet,- Path: "/api/test",- Headers: map[string]string{- "Host": "my-agent-host:3552",- "X-Arcane-Agent-Token": "tok-123",- "Content-Type": "application/json",- },- })-- require.Len(t, conn.sent, 1)- assert.Equal(t, http.StatusOK, conn.sent[0].Status)-}--func TestHandleRequest_ForwardsBody(t *testing.T) {- requestBody := `{"name":"My Project"}`- var receivedBody string-- localHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- body := make([]byte, r.ContentLength)- _, _ = r.Body.Read(body)- receivedBody = string(body)- w.WriteHeader(http.StatusCreated)- _, _ = w.Write([]byte(`{"id":"p1"}`))- })-- client := NewTunnelClient(&Config{}, localHandler)- conn := &capturingTunnelConnForHandleRequest{}- client.conn = conn-- client.handleRequest(context.Background(), &TunnelMessage{- ID: "req-body-1",- Type: MessageTypeRequest,- Method: http.MethodPost,- Path: "/api/environments/0/projects",- Headers: map[string]string{- "Content-Type": "application/json",- "X-Arcane-Agent-Token": "tok-123",- },- Body: []byte(requestBody),- })-- require.Len(t, conn.sent, 1)- assert.Equal(t, http.StatusCreated, conn.sent[0].Status)- assert.Equal(t, requestBody, receivedBody, "Request body should be forwarded to the local handler")-}--func TestHandleRequest_NoBrowserHeadersInTunnelMessage(t *testing.T) {- // Verify that if somehow browser headers leaked into a tunnel message,- // they are still forwarded as-is (stripping happens on the proxy side, not the client side).- // This test documents that the client sets all received headers.- var receivedOrigin string-- localHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- receivedOrigin = r.Header.Get("Origin")- w.WriteHeader(http.StatusOK)- })-- client := NewTunnelClient(&Config{}, localHandler)- conn := &capturingTunnelConnForHandleRequest{}- client.conn = conn-- // Simulate an old manager that doesn't strip Origin- client.handleRequest(context.Background(), &TunnelMessage{- ID: "req-origin-1",- Type: MessageTypeRequest,- Method: http.MethodPost,- Path: "/test",- Headers: map[string]string{- "Origin": "http://bad-origin:1234",- },- })-- // The client doesn't strip - it passes whatever it gets to the handler- assert.Equal(t, "http://bad-origin:1234", receivedOrigin,- "Client should forward all headers; stripping is the proxy's responsibility")-}--func TestProxyHTTPRequest_EndToEnd_BrowserOriginStripped(t *testing.T) {- // Full end-to-end test: browser sends POST with Origin header via edge tunnel.- // The agent should NOT receive the Origin header.-- // This handler simulates what the agent's handler would do.- // In a real scenario, if Origin is present and doesn't match allowed origins,- // CORS middleware would return 403 before this handler runs.- agentHandlerCalled := false- agentHandler := func(msg *TunnelMessage) *TunnelMessage {- agentHandlerCalled = true- // If Origin is present, that would cause a 403 in real life- if msg.Headers["Origin"] != "" {- return &TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusForbidden,- Body: []byte("Origin header should have been stripped"),- }- }- return &TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusCreated,- Headers: map[string]string{"Content-Type": "application/json"},- Body: []byte(`{"id":"project-1"}`),- }- }-- server, tunnel := setupMockAgentServer(t, agentHandler)- defer server.Close()- defer func() { _ = tunnel.Close() }()-- e := echo.New()- w := httptest.NewRecorder()- body := `{"name":"New Project"}`- req := httptest.NewRequest(http.MethodPost, "/api/environments/env-123/projects", bytes.NewBufferString(body))- req.Header.Set("Origin", "http://192.168.1.42:30258")- req.Header.Set("Referer", "http://192.168.1.42:30258/projects/new")- req.Header.Set("Content-Type", "application/json")- req.Header.Set("X-Arcane-Agent-Token", "agent-tok")- c := e.NewContext(req, w)-- _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")-- assert.True(t, agentHandlerCalled, "Agent handler should have been called")- assert.Equal(t, http.StatusCreated, w.Code, "Request should succeed because Origin was stripped")- assert.Contains(t, w.Body.String(), "project-1")-}--func TestProxyHTTPRequest_BodyPreservation_WebSocket(t *testing.T) {- // Test that a POST body survives WebSocket JSON serialization round-trip- var receivedBody string-- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- upgrader := websocket.Upgrader{}- conn, err := upgrader.Upgrade(w, r, nil)- if err != nil {- return- }- defer func() { _ = conn.Close() }()-- for {- _, data, err := conn.ReadMessage()- if err != nil {- return- }-- var msg TunnelMessage- _ = json.Unmarshal(data, &msg)-- if msg.Type == MessageTypeRequest || msg.Type == MessageTypeCommandRequest {- receivedBody = string(msg.Body)- resp := &TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusCreated,- Headers: map[string]string{"Content-Type": "application/json"},- Body: []byte(`{"ok":true}`),- }- respData, _ := json.Marshal(resp)- _ = conn.WriteMessage(websocket.TextMessage, respData)- }- }- }))- defer server.Close()-- url := "ws" + server.URL[4:]- wsConn, resp, err := websocket.DefaultDialer.Dial(url, nil)- require.NoError(t, err)- if resp != nil {- defer func() { _ = resp.Body.Close() }()- }-- tunnel := newWebSocketAgentTunnel("env-body-test", wsConn)- defer func() { _ = tunnel.Close() }()-- go func() {- for {- msg, err := tunnel.Conn.Receive()- if err != nil {- return- }- if req, ok := tunnel.Pending.Load(msg.ID); ok {- pendingReq := req.(*PendingRequest)- pendingReq.ResponseCh <- msg- }- }- }()-- requestBody := `{"name":"My Project","description":"A test project with special chars: <>&\""}`-- e := echo.New()- w := httptest.NewRecorder()- req := httptest.NewRequest(http.MethodPost, "/test", bytes.NewBufferString(requestBody))- req.Header.Set("Content-Type", "application/json")- c := e.NewContext(req, w)-- _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")-- assert.Equal(t, http.StatusCreated, w.Code)- assert.Equal(t, requestBody, receivedBody, "Request body should survive WebSocket JSON serialization round-trip")-}diff --git a/backend/pkg/libarcane/edge/proxy_test.go b/backend/pkg/libarcane/edge/proxy_test.goindex 476ac9120..1091dbef1 100644--- a/backend/pkg/libarcane/edge/proxy_test.go+++ b/backend/pkg/libarcane/edge/proxy_test.go@@ -296,3 +296,338 @@ func TestIsHopByHopHeader(t *testing.T) {assert.False(t, isHopByHopHeader("Content-Type"))assert.False(t, isHopByHopHeader("X-Custom-Header"))}++func TestIsBrowserSecurityHeader(t *testing.T) {+ browserHeaders := []string{+ "Origin",+ "Referer",+ "Cookie",+ "Access-Control-Request-Method",+ "Access-Control-Request-Headers",+ "Sec-Fetch-Mode",+ "Sec-Fetch-Site",+ "Sec-Fetch-Dest",+ }++ for _, h := range browserHeaders {+ assert.True(t, isBrowserSecurityHeader(h), "expected %q to be a browser security header", h)+ }++ nonBrowserHeaders := []string{+ "Content-Type",+ "Authorization",+ "X-Custom-Header",+ "X-Arcane-Agent-Token",+ "X-API-Key",+ "Accept",+ }++ for _, h := range nonBrowserHeaders {+ assert.False(t, isBrowserSecurityHeader(h), "expected %q to NOT be a browser security header", h)+ }+}++func TestProxyHTTPRequest_StripsBrowserHeaders(t *testing.T) {+ var receivedHeaders map[string]string++ server, tunnel := setupMockAgentServer(t, func(msg *TunnelMessage) *TunnelMessage {+ receivedHeaders = msg.Headers+ return &TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusOK,+ Headers: map[string]string{"Content-Type": "application/json"},+ Body: []byte(`{"ok":true}`),+ }+ })+ defer server.Close()+ defer func() { _ = tunnel.Close() }()++ e := echo.New()+ w := httptest.NewRecorder()+ req := httptest.NewRequest(http.MethodPost, "/test", bytes.NewBufferString(`{"name":"test"}`))++ req.Header.Set("Origin", "http://192.168.1.42:30258")+ req.Header.Set("Referer", "http://192.168.1.42:30258/projects/new")+ req.Header.Set("Cookie", "token=some-jwt-token")+ req.Header.Set("Sec-Fetch-Mode", "cors")+ req.Header.Set("Sec-Fetch-Site", "same-origin")+ req.Header.Set("Sec-Fetch-Dest", "empty")+ req.Header.Set("Access-Control-Request-Method", "POST")+ req.Header.Set("Access-Control-Request-Headers", "Content-Type")++ req.Header.Set("Content-Type", "application/json")+ req.Header.Set("X-Arcane-Agent-Token", "agent-tok-123")+ req.Header.Set("X-API-Key", "agent-tok-123")+ req.Header.Set("Authorization", "Bearer jwt-token")+ c := e.NewContext(req, w)++ _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")++ assert.Equal(t, http.StatusOK, w.Code)++ // Browser security headers should NOT be present on the agent side+ assert.Empty(t, receivedHeaders["Origin"], "Origin header should be stripped")+ assert.Empty(t, receivedHeaders["Referer"], "Referer header should be stripped")+ assert.Empty(t, receivedHeaders["Cookie"], "Cookie header should be stripped")+ assert.Empty(t, receivedHeaders["Sec-Fetch-Mode"], "Sec-Fetch-Mode header should be stripped")+ assert.Empty(t, receivedHeaders["Sec-Fetch-Site"], "Sec-Fetch-Site header should be stripped")+ assert.Empty(t, receivedHeaders["Sec-Fetch-Dest"], "Sec-Fetch-Dest header should be stripped")+ assert.Empty(t, receivedHeaders["Access-Control-Request-Method"], "Access-Control-Request-Method should be stripped")+ assert.Empty(t, receivedHeaders["Access-Control-Request-Headers"], "Access-Control-Request-Headers should be stripped")++ // Important headers SHOULD still be forwarded+ assert.Equal(t, "application/json", receivedHeaders["Content-Type"])+ assert.Equal(t, "agent-tok-123", receivedHeaders["X-Arcane-Agent-Token"])+ assert.Equal(t, "agent-tok-123", receivedHeaders["X-Api-Key"])+ assert.Equal(t, "Bearer jwt-token", receivedHeaders["Authorization"])+}++func TestProxyHTTPRequest_ForwardsBodyCorrectly(t *testing.T) {+ var receivedBody []byte+ var receivedMethod string++ server, tunnel := setupMockAgentServer(t, func(msg *TunnelMessage) *TunnelMessage {+ receivedBody = msg.Body+ receivedMethod = msg.Method+ return &TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusCreated,+ Headers: map[string]string{"Content-Type": "application/json"},+ Body: []byte(`{"id":"proj-1","name":"test"}`),+ }+ })+ defer server.Close()+ defer func() { _ = tunnel.Close() }()++ requestBody := `{"name":"My Project"}`++ e := echo.New()+ w := httptest.NewRecorder()+ req := httptest.NewRequest(http.MethodPost, "/api/environments/abc/projects", bytes.NewBufferString(requestBody))+ req.Header.Set("Content-Type", "application/json")+ req.Header.Set("X-Arcane-Agent-Token", "tok")+ c := e.NewContext(req, w)++ _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")++ assert.Equal(t, http.StatusCreated, w.Code)+ assert.Equal(t, http.MethodPost, receivedMethod)+ assert.Equal(t, requestBody, string(receivedBody), "Request body should be forwarded intact through the tunnel")+}++func TestHandleRequest_SetsHostField(t *testing.T) {+ localHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ // Verify Host is properly set from the tunneled headers+ assert.Equal(t, "my-agent-host:3552", r.Host, "Host field should be set from tunnel message headers")+ w.WriteHeader(http.StatusOK)+ _, _ = w.Write([]byte("ok"))+ })++ client := NewTunnelClient(&Config{}, localHandler)+ conn := &capturingTunnelConnForHandleRequest{}+ client.setConn(conn)++ client.handleRequest(context.Background(), conn, &TunnelMessage{+ ID: "req-host-1",+ Type: MessageTypeRequest,+ Method: http.MethodGet,+ Path: "/api/test",+ Headers: map[string]string{+ "Host": "my-agent-host:3552",+ "X-Arcane-Agent-Token": "tok-123",+ "Content-Type": "application/json",+ },+ })++ require.Len(t, conn.sent, 1)+ assert.Equal(t, http.StatusOK, conn.sent[0].Status)+}++func TestHandleRequest_ForwardsBody(t *testing.T) {+ requestBody := `{"name":"My Project"}`+ var receivedBody string++ localHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ body := make([]byte, r.ContentLength)+ _, _ = r.Body.Read(body)+ receivedBody = string(body)+ w.WriteHeader(http.StatusCreated)+ _, _ = w.Write([]byte(`{"id":"p1"}`))+ })++ client := NewTunnelClient(&Config{}, localHandler)+ conn := &capturingTunnelConnForHandleRequest{}+ client.setConn(conn)++ client.handleRequest(context.Background(), conn, &TunnelMessage{+ ID: "req-body-1",+ Type: MessageTypeRequest,+ Method: http.MethodPost,+ Path: "/api/environments/0/projects",+ Headers: map[string]string{+ "Content-Type": "application/json",+ "X-Arcane-Agent-Token": "tok-123",+ },+ Body: []byte(requestBody),+ })++ require.Len(t, conn.sent, 1)+ assert.Equal(t, http.StatusCreated, conn.sent[0].Status)+ assert.Equal(t, requestBody, receivedBody, "Request body should be forwarded to the local handler")+}++func TestHandleRequest_NoBrowserHeadersInTunnelMessage(t *testing.T) {+ // Verify that if somehow browser headers leaked into a tunnel message,+ // they are still forwarded as-is (stripping happens on the proxy side, not the client side).+ // This test documents that the client sets all received headers.+ var receivedOrigin string++ localHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ receivedOrigin = r.Header.Get("Origin")+ w.WriteHeader(http.StatusOK)+ })++ client := NewTunnelClient(&Config{}, localHandler)+ conn := &capturingTunnelConnForHandleRequest{}+ client.setConn(conn)++ // Simulate an old manager that doesn't strip Origin+ client.handleRequest(context.Background(), conn, &TunnelMessage{+ ID: "req-origin-1",+ Type: MessageTypeRequest,+ Method: http.MethodPost,+ Path: "/test",+ Headers: map[string]string{+ "Origin": "http://bad-origin:1234",+ },+ })++ // The client doesn't strip - it passes whatever it gets to the handler+ assert.Equal(t, "http://bad-origin:1234", receivedOrigin,+ "Client should forward all headers; stripping is the proxy's responsibility")+}++func TestProxyHTTPRequest_EndToEnd_BrowserOriginStripped(t *testing.T) {+ // Full end-to-end test: browser sends POST with Origin header via edge tunnel.+ // The agent should NOT receive the Origin header.++ // This handler simulates what the agent's handler would do.+ // In a real scenario, if Origin is present and doesn't match allowed origins,+ // CORS middleware would return 403 before this handler runs.+ agentHandlerCalled := false+ agentHandler := func(msg *TunnelMessage) *TunnelMessage {+ agentHandlerCalled = true+ // If Origin is present, that would cause a 403 in real life+ if msg.Headers["Origin"] != "" {+ return &TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusForbidden,+ Body: []byte("Origin header should have been stripped"),+ }+ }+ return &TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusCreated,+ Headers: map[string]string{"Content-Type": "application/json"},+ Body: []byte(`{"id":"project-1"}`),+ }+ }++ server, tunnel := setupMockAgentServer(t, agentHandler)+ defer server.Close()+ defer func() { _ = tunnel.Close() }()++ e := echo.New()+ w := httptest.NewRecorder()+ body := `{"name":"New Project"}`+ req := httptest.NewRequest(http.MethodPost, "/api/environments/env-123/projects", bytes.NewBufferString(body))+ req.Header.Set("Origin", "http://192.168.1.42:30258")+ req.Header.Set("Referer", "http://192.168.1.42:30258/projects/new")+ req.Header.Set("Content-Type", "application/json")+ req.Header.Set("X-Arcane-Agent-Token", "agent-tok")+ c := e.NewContext(req, w)++ _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")++ assert.True(t, agentHandlerCalled, "Agent handler should have been called")+ assert.Equal(t, http.StatusCreated, w.Code, "Request should succeed because Origin was stripped")+ assert.Contains(t, w.Body.String(), "project-1")+}++func TestProxyHTTPRequest_BodyPreservation_WebSocket(t *testing.T) {+ // Test that a POST body survives WebSocket JSON serialization round-trip+ var receivedBody string++ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ upgrader := websocket.Upgrader{}+ conn, err := upgrader.Upgrade(w, r, nil)+ if err != nil {+ return+ }+ defer func() { _ = conn.Close() }()++ for {+ _, data, err := conn.ReadMessage()+ if err != nil {+ return+ }++ var msg TunnelMessage+ _ = json.Unmarshal(data, &msg)++ if msg.Type == MessageTypeRequest || msg.Type == MessageTypeCommandRequest {+ receivedBody = string(msg.Body)+ resp := &TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusCreated,+ Headers: map[string]string{"Content-Type": "application/json"},+ Body: []byte(`{"ok":true}`),+ }+ respData, _ := json.Marshal(resp)+ _ = conn.WriteMessage(websocket.TextMessage, respData)+ }+ }+ }))+ defer server.Close()++ url := "ws" + server.URL[4:]+ wsConn, resp, err := websocket.DefaultDialer.Dial(url, nil)+ require.NoError(t, err)+ if resp != nil {+ defer func() { _ = resp.Body.Close() }()+ }++ tunnel := newWebSocketAgentTunnel("env-body-test", wsConn)+ defer func() { _ = tunnel.Close() }()++ go func() {+ for {+ msg, err := tunnel.Conn.Receive()+ if err != nil {+ return+ }+ if req, ok := tunnel.Pending.Load(msg.ID); ok {+ pendingReq := req.(*PendingRequest)+ pendingReq.ResponseCh <- msg+ }+ }+ }()++ requestBody := `{"name":"My Project","description":"A test project with special chars: <>&\""}`++ e := echo.New()+ w := httptest.NewRecorder()+ req := httptest.NewRequest(http.MethodPost, "/test", bytes.NewBufferString(requestBody))+ req.Header.Set("Content-Type", "application/json")+ c := e.NewContext(req, w)++ _ = ProxyHTTPRequest(c, tunnel, "/api/environments/0/projects")++ assert.Equal(t, http.StatusCreated, w.Code)+ assert.Equal(t, requestBody, receivedBody, "Request body should survive WebSocket JSON serialization round-trip")+}diff --git a/backend/pkg/libarcane/edge/remenv_client_integration_test.go b/backend/pkg/libarcane/edge/remenv_client_integration_test.godeleted file mode 100644index 4e360d4e3..000000000--- a/backend/pkg/libarcane/edge/remenv_client_integration_test.go+++ /dev/null@@ -1,216 +0,0 @@-package edge--import (- "context"- "errors"- "fmt"- "net"- "net/http"- "testing"- "time"-- tunnelpb "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge/proto/tunnel/v1"- "github.com/getarcaneapp/arcane/backend/v2/pkg/remenv"- "github.com/stretchr/testify/assert"- "github.com/stretchr/testify/require"- "google.golang.org/grpc"- "google.golang.org/grpc/credentials/insecure"-)--func newTestRemenvClientInternal(timeout time.Duration) *remenv.Client {- return remenv.NewClient(&http.Client{Timeout: timeout}, remenv.TunnelTransportFuncs{- EnsureAvailableFunc: func(ctx context.Context, envID string) error {- if HasActiveTunnel(envID) {- return nil- }-- if _, ok := RequestTunnelAndWait(ctx, envID, DefaultTunnelDemandTTL, DefaultTunnelAcquireTimeout()); ok {- return nil- }-- return fmt.Errorf("edge agent is not connected (no active tunnel)")- },- DoFunc: func(ctx context.Context, envID, method, path string, headers map[string]string, body []byte) (*remenv.Response, error) {- tunnel, ok := GetRegistry().Get(envID)- if !ok {- return nil, fmt.Errorf("no active tunnel for environment %s", envID)- }- if tunnel.Conn.IsClosed() {- return nil, fmt.Errorf("tunnel for environment %s is closed", envID)- }-- statusCode, respHeaders, respBody, err := ProxyRequest(ctx, tunnel, method, path, "", headers, body)- if err != nil {- return nil, fmt.Errorf("tunnel request failed: %w", err)- }-- return &remenv.Response{- StatusCode: statusCode,- Body: respBody,- Headers: respHeaders,- }, nil- },- })-}--func TestRemenvClient_EdgeWithTunnel(t *testing.T) {- server, tunnel := setupMockAgentServer(t, func(msg *TunnelMessage) *TunnelMessage {- return &TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusOK,- Headers: map[string]string{"Content-Type": "application/json"},- Body: []byte(`{"edge":true}`),- }- })- defer server.Close()- defer func() { _ = tunnel.Close() }()-- envID := "env-edge-1"- GetRegistry().Register(envID, tunnel)- defer GetRegistry().Unregister(envID)-- client := newTestRemenvClientInternal(1 * time.Second)-- resp, err := client.Do(context.Background(), remenv.Request{- EnvironmentID: envID,- IsEdge: true,- Method: http.MethodGet,- URL: "http://ignored/api/health",- Path: "/api/health",- Headers: map[string]string{"X-H": "v"},- })-- require.NoError(t, err)- assert.Equal(t, http.StatusOK, resp.StatusCode)- assert.Equal(t, []byte(`{"edge":true}`), resp.Body)-}--func TestRemenvClient_EdgeNoTunnel(t *testing.T) {- client := newTestRemenvClientInternal(1 * time.Second)-- _, err := client.Do(context.Background(), remenv.Request{- EnvironmentID: "env-edge-missing",- IsEdge: true,- Method: http.MethodGet,- URL: "http://ignored/api/health",- Path: "/api/health",- })-- var transportErr *remenv.TransportError- require.ErrorAs(t, err, &transportErr)- assert.Contains(t, err.Error(), "not connected")-}--func TestRemenvClient_EdgeWithGRPCTunnel(t *testing.T) {- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)-- envID := "env-edge-grpc-1"- GetRegistry().Unregister(envID)- defer GetRegistry().Unregister(envID)-- lis, grpcServer, tunnelServer := startTestGRPCTunnelServer(ctx, envID)- defer func() {- cancel()- tunnelServer.WaitForCleanupDone()- }()-- go func() {- _ = grpcServer.Serve(lis)- }()- defer grpcServer.GracefulStop()-- conn, err := grpc.NewClient("passthrough:///bufnet",- grpc.WithContextDialer(func(ctx context.Context, s string) (net.Conn, error) {- return lis.Dial()- }),- grpc.WithTransportCredentials(insecure.NewCredentials()),- )- require.NoError(t, err)- defer func() { _ = conn.Close() }()-- clientAPI := tunnelpb.NewTunnelServiceClient(conn)- stream, err := clientAPI.Connect(ctx)- require.NoError(t, err)-- err = stream.Send(&tunnelpb.AgentMessage{Payload: &tunnelpb.AgentMessage_Register{Register: &tunnelpb.RegisterRequest{AgentToken: "valid-token"}}})- require.NoError(t, err)-- registerResp, err := stream.Recv()- require.NoError(t, err)- require.NotNil(t, registerResp.GetRegisterResponse())- assert.True(t, registerResp.GetRegisterResponse().GetAccepted())-- agentErrCh := make(chan error, 1)- go func() {- msg, err := stream.Recv()- if err != nil {- agentErrCh <- err- return- }-- req := msg.GetCommandRequest()- if req == nil {- agentErrCh <- errors.New("expected command request")- return- }-- if req.GetMethod() != http.MethodPost {- agentErrCh <- errors.New("unexpected method")- return- }- if req.GetPath() != "/api/environments/0/projects" {- agentErrCh <- errors.New("unexpected path")- return- }- if req.GetHeaders()["X-H"] != "v" {- agentErrCh <- errors.New("missing X-H header")- return- }- if req.GetHeaders()["Content-Type"] != "application/json" {- agentErrCh <- errors.New("missing content type")- return- }- if string(req.GetBody()) != `{"edge":true}` {- agentErrCh <- errors.New("unexpected request body")- return- }-- if err := stream.Send(&tunnelpb.AgentMessage{Payload: &tunnelpb.AgentMessage_CommandAck{CommandAck: &tunnelpb.CommandAck{- CommandId: req.GetCommandId(),- }}}); err != nil {- agentErrCh <- err- return- }-- agentErrCh <- stream.Send(&tunnelpb.AgentMessage{Payload: &tunnelpb.AgentMessage_CommandComplete{CommandComplete: &tunnelpb.CommandComplete{- CommandId: req.GetCommandId(),- Status: http.StatusCreated,- Headers: map[string]string{"Content-Type": "application/json"},- Body: []byte(`{"ok":true}`),- }}})- }()-- require.Eventually(t, func() bool {- tunnel, ok := GetRegistry().Get(envID)- return ok && tunnel != nil && !tunnel.Conn.IsClosed()- }, time.Second, 10*time.Millisecond)-- client := newTestRemenvClientInternal(1 * time.Second)- resp, err := client.Do(ctx, remenv.Request{- EnvironmentID: envID,- IsEdge: true,- Method: http.MethodPost,- URL: "http://ignored/api/environments/0/projects",- Path: "/api/environments/0/projects",- Headers: map[string]string{"X-H": "v", "Content-Type": "application/json"},- Body: []byte(`{"edge":true}`),- })-- require.NoError(t, err)- assert.Equal(t, http.StatusCreated, resp.StatusCode)- assert.Equal(t, "application/json", resp.Headers["Content-Type"])- assert.Equal(t, []byte(`{"ok":true}`), resp.Body)-- require.NoError(t, <-agentErrCh)-}diff --git a/backend/pkg/libarcane/edge/remenv_test.go b/backend/pkg/libarcane/edge/remenv_test.goindex b3860b167..99b39cff2 100644--- a/backend/pkg/libarcane/edge/remenv_test.go+++ b/backend/pkg/libarcane/edge/remenv_test.go@@ -3,13 +3,22 @@ package edgeimport ("bytes""context"+ "errors"+ "fmt""io"+ "net""net/http""net/http/httptest""testing"+ "time"+ tunnelpb "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge/proto/tunnel/v1"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/remenv""github.com/labstack/echo/v4"+ "github.com/stretchr/testify/assert""github.com/stretchr/testify/require"+ "google.golang.org/grpc"+ "google.golang.org/grpc/credentials/insecure")type chunkReader struct {@@ -253,3 +262,201 @@ func TestCopyBodyWithFlush_DoesNotRequireFlusher(t *testing.T) {CopyBodyWithFlush(w, body)require.Equal(t, "abc", w.buf.String())}++func newTestRemenvClientInternal(timeout time.Duration) *remenv.Client {+ return remenv.NewClient(&http.Client{Timeout: timeout}, remenv.TunnelTransportFuncs{+ EnsureAvailableFunc: func(ctx context.Context, envID string) error {+ if HasActiveTunnel(envID) {+ return nil+ }++ if _, ok := RequestTunnelAndWait(ctx, envID, DefaultTunnelDemandTTL, DefaultTunnelAcquireTimeout()); ok {+ return nil+ }++ return fmt.Errorf("edge agent is not connected (no active tunnel)")+ },+ DoFunc: func(ctx context.Context, envID, method, path string, headers map[string]string, body []byte) (*remenv.Response, error) {+ tunnel, ok := GetRegistry().Get(envID)+ if !ok {+ return nil, fmt.Errorf("no active tunnel for environment %s", envID)+ }+ if tunnel.Conn.IsClosed() {+ return nil, fmt.Errorf("tunnel for environment %s is closed", envID)+ }++ statusCode, respHeaders, respBody, err := ProxyRequest(ctx, tunnel, method, path, "", headers, body)+ if err != nil {+ return nil, fmt.Errorf("tunnel request failed: %w", err)+ }++ return &remenv.Response{+ StatusCode: statusCode,+ Body: respBody,+ Headers: respHeaders,+ }, nil+ },+ })+}++func TestRemenvClient_EdgeWithTunnel(t *testing.T) {+ server, tunnel := setupMockAgentServer(t, func(msg *TunnelMessage) *TunnelMessage {+ return &TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusOK,+ Headers: map[string]string{"Content-Type": "application/json"},+ Body: []byte(`{"edge":true}`),+ }+ })+ defer server.Close()+ defer func() { _ = tunnel.Close() }()++ envID := "env-edge-1"+ GetRegistry().Register(envID, tunnel)+ defer GetRegistry().Unregister(envID)++ client := newTestRemenvClientInternal(1 * time.Second)++ resp, err := client.Do(context.Background(), remenv.Request{+ EnvironmentID: envID,+ IsEdge: true,+ Method: http.MethodGet,+ URL: "http://ignored/api/health",+ Path: "/api/health",+ Headers: map[string]string{"X-H": "v"},+ })++ require.NoError(t, err)+ assert.Equal(t, http.StatusOK, resp.StatusCode)+ assert.Equal(t, []byte(`{"edge":true}`), resp.Body)+}++func TestRemenvClient_EdgeNoTunnel(t *testing.T) {+ client := newTestRemenvClientInternal(1 * time.Second)++ _, err := client.Do(context.Background(), remenv.Request{+ EnvironmentID: "env-edge-missing",+ IsEdge: true,+ Method: http.MethodGet,+ URL: "http://ignored/api/health",+ Path: "/api/health",+ })++ var transportErr *remenv.TransportError+ require.ErrorAs(t, err, &transportErr)+ assert.Contains(t, err.Error(), "not connected")+}++func TestRemenvClient_EdgeWithGRPCTunnel(t *testing.T) {+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)++ envID := "env-edge-grpc-1"+ GetRegistry().Unregister(envID)+ defer GetRegistry().Unregister(envID)++ lis, grpcServer, tunnelServer := startTestGRPCTunnelServer(ctx, envID)+ defer func() {+ cancel()+ tunnelServer.WaitForCleanupDone()+ }()++ go func() {+ _ = grpcServer.Serve(lis)+ }()+ defer grpcServer.GracefulStop()++ conn, err := grpc.NewClient("passthrough:///bufnet",+ grpc.WithContextDialer(func(ctx context.Context, s string) (net.Conn, error) {+ return lis.Dial()+ }),+ grpc.WithTransportCredentials(insecure.NewCredentials()),+ )+ require.NoError(t, err)+ defer func() { _ = conn.Close() }()++ clientAPI := tunnelpb.NewTunnelServiceClient(conn)+ stream, err := clientAPI.Connect(ctx)+ require.NoError(t, err)++ err = stream.Send(&tunnelpb.AgentMessage{Payload: &tunnelpb.AgentMessage_Register{Register: &tunnelpb.RegisterRequest{AgentToken: "valid-token"}}})+ require.NoError(t, err)++ registerResp, err := stream.Recv()+ require.NoError(t, err)+ require.NotNil(t, registerResp.GetRegisterResponse())+ assert.True(t, registerResp.GetRegisterResponse().GetAccepted())++ agentErrCh := make(chan error, 1)+ go func() {+ msg, err := stream.Recv()+ if err != nil {+ agentErrCh <- err+ return+ }++ req := msg.GetCommandRequest()+ if req == nil {+ agentErrCh <- errors.New("expected command request")+ return+ }++ if req.GetMethod() != http.MethodPost {+ agentErrCh <- errors.New("unexpected method")+ return+ }+ if req.GetPath() != "/api/environments/0/projects" {+ agentErrCh <- errors.New("unexpected path")+ return+ }+ if req.GetHeaders()["X-H"] != "v" {+ agentErrCh <- errors.New("missing X-H header")+ return+ }+ if req.GetHeaders()["Content-Type"] != "application/json" {+ agentErrCh <- errors.New("missing content type")+ return+ }+ if string(req.GetBody()) != `{"edge":true}` {+ agentErrCh <- errors.New("unexpected request body")+ return+ }++ if err := stream.Send(&tunnelpb.AgentMessage{Payload: &tunnelpb.AgentMessage_CommandAck{CommandAck: &tunnelpb.CommandAck{+ CommandId: req.GetCommandId(),+ }}}); err != nil {+ agentErrCh <- err+ return+ }++ agentErrCh <- stream.Send(&tunnelpb.AgentMessage{Payload: &tunnelpb.AgentMessage_CommandComplete{CommandComplete: &tunnelpb.CommandComplete{+ CommandId: req.GetCommandId(),+ Status: http.StatusCreated,+ Headers: map[string]string{"Content-Type": "application/json"},+ Body: []byte(`{"ok":true}`),+ }}})+ }()++ require.Eventually(t, func() bool {+ tunnel, ok := GetRegistry().Get(envID)+ return ok && tunnel != nil && !tunnel.Conn.IsClosed()+ }, time.Second, 10*time.Millisecond)++ client := newTestRemenvClientInternal(1 * time.Second)+ resp, err := client.Do(ctx, remenv.Request{+ EnvironmentID: envID,+ IsEdge: true,+ Method: http.MethodPost,+ URL: "http://ignored/api/environments/0/projects",+ Path: "/api/environments/0/projects",+ Headers: map[string]string{"X-H": "v", "Content-Type": "application/json"},+ Body: []byte(`{"edge":true}`),+ })++ require.NoError(t, err)+ assert.Equal(t, http.StatusCreated, resp.StatusCode)+ assert.Equal(t, "application/json", resp.Headers["Content-Type"])+ assert.Equal(t, []byte(`{"ok":true}`), resp.Body)++ require.NoError(t, <-agentErrCh)+}diff --git a/backend/pkg/libarcane/edge/streaming_response_recorder_test.go b/backend/pkg/libarcane/edge/streaming_response_recorder_test.godeleted file mode 100644index 116eb50cf..000000000--- a/backend/pkg/libarcane/edge/streaming_response_recorder_test.go+++ /dev/null@@ -1,105 +0,0 @@-package edge--import (- "context"- "errors"- "net/http"- "sync"- "testing"-- "github.com/stretchr/testify/assert"- "github.com/stretchr/testify/require"-)--type fakeTunnelConn struct {- mu sync.Mutex- msgs []*TunnelMessage- closed bool- sendErr error-}--func (f *fakeTunnelConn) Send(msg *TunnelMessage) error {- f.mu.Lock()- defer f.mu.Unlock()- if f.sendErr != nil {- return f.sendErr- }- copyMsg := *msg- if msg.Headers != nil {- copyMsg.Headers = cloneHeaderMap(msg.Headers)- }- if msg.Body != nil {- copyMsg.Body = append([]byte(nil), msg.Body...)- }- f.msgs = append(f.msgs, ©Msg)- return nil-}--func (f *fakeTunnelConn) Receive() (*TunnelMessage, error) {- return nil, errors.New("not implemented")-}--func (f *fakeTunnelConn) IsExpectedReceiveError(error) bool {- return false-}--func (f *fakeTunnelConn) Close() error {- f.mu.Lock()- defer f.mu.Unlock()- f.closed = true- return nil-}--func (f *fakeTunnelConn) IsClosed() bool {- f.mu.Lock()- defer f.mu.Unlock()- return f.closed-}--func (f *fakeTunnelConn) SendRequest(ctx context.Context, msg *TunnelMessage, pending *sync.Map) (*TunnelMessage, error) {- return nil, errors.New("not implemented")-}--func TestStreamingResponseRecorder_Sequence(t *testing.T) {- conn := &fakeTunnelConn{}- r := newStreamingResponseRecorder("req-1", conn)-- r.Header().Set("Content-Type", "text/plain")-- n, err := r.Write([]byte("hello"))- require.NoError(t, err)- assert.Equal(t, 5, n)-- n, err = r.Write([]byte(" world"))- require.NoError(t, err)- assert.Equal(t, 6, n)-- require.NoError(t, r.Close())-- require.Len(t, conn.msgs, 4)- assert.Equal(t, MessageTypeResponse, conn.msgs[0].Type)- assert.Equal(t, "req-1", conn.msgs[0].ID)- assert.Equal(t, "text/plain", conn.msgs[0].Headers["Content-Type"])- assert.Equal(t, "1", conn.msgs[0].Headers["X-Arcane-Tunnel-Stream"])-- assert.Equal(t, MessageTypeStreamData, conn.msgs[1].Type)- assert.Equal(t, "hello", string(conn.msgs[1].Body))-- assert.Equal(t, MessageTypeStreamData, conn.msgs[2].Type)- assert.Equal(t, " world", string(conn.msgs[2].Body))-- assert.Equal(t, MessageTypeStreamEnd, conn.msgs[3].Type)-}--func TestStreamingResponseRecorder_WriteHeaderAndClose(t *testing.T) {- conn := &fakeTunnelConn{}- r := newStreamingResponseRecorder("req-2", conn)-- r.WriteHeader(http.StatusCreated)- require.NoError(t, r.Close())-- require.Len(t, conn.msgs, 2)- assert.Equal(t, MessageTypeResponse, conn.msgs[0].Type)- assert.Equal(t, http.StatusCreated, conn.msgs[0].Status)- assert.Equal(t, MessageTypeStreamEnd, conn.msgs[1].Type)-}diff --git a/backend/pkg/libarcane/edge/transport_benchmark_test.go b/backend/pkg/libarcane/edge/transport_benchmark_test.godeleted file mode 100644index 922213c38..000000000--- a/backend/pkg/libarcane/edge/transport_benchmark_test.go+++ /dev/null@@ -1,244 +0,0 @@-package edge--import (- "context"- "fmt"- "io"- "log/slog"- "net"- "net/http"- "net/http/httptest"- "strings"- "testing"- "time"-- tunnelpb "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge/proto/tunnel/v1"- "github.com/gorilla/websocket"- "google.golang.org/grpc"- "google.golang.org/grpc/credentials/insecure"-)--func BenchmarkEdgeTunnelProxyRequest(b *testing.B) {- previousLogger := slog.Default()- slog.SetDefault(slog.New(slog.NewTextHandler(io.Discard, nil)))- b.Cleanup(func() {- slog.SetDefault(previousLogger)- })-- payloadSizes := []int{64, 1024, 4096}- for _, payloadSize := range payloadSizes {- b.Run(fmt.Sprintf("grpc_payload_%d", payloadSize), func(b *testing.B) {- tunnel, cleanup := setupGRPCBenchmarkTunnel(b, payloadSize)- defer cleanup()- runProxyRequestBenchmark(b, tunnel, payloadSize)- })-- b.Run(fmt.Sprintf("websocket_payload_%d", payloadSize), func(b *testing.B) {- tunnel, cleanup := setupWebSocketBenchmarkTunnel(b, payloadSize)- defer cleanup()- runProxyRequestBenchmark(b, tunnel, payloadSize)- })- }-}--func runProxyRequestBenchmark(b *testing.B, tunnel *AgentTunnel, payloadSize int) {- b.Helper()-- ctx := context.Background()- body := make([]byte, payloadSize)- headers := map[string]string{- "Content-Type": "application/octet-stream",- }-- b.ReportAllocs()- b.SetBytes(int64(payloadSize))- b.ResetTimer()-- for b.Loop() {- statusCode, _, respBody, err := ProxyRequest(ctx, tunnel, http.MethodPost, "/api/bench", "", headers, body)- if err != nil {- b.Fatalf("proxy request failed: %v", err)- }- if statusCode != http.StatusOK {- b.Fatalf("unexpected status code: %d", statusCode)- }- if len(respBody) != payloadSize {- b.Fatalf("unexpected response length: got %d want %d", len(respBody), payloadSize)- }- }-}--func setupGRPCBenchmarkTunnel(b *testing.B, payloadSize int) (*AgentTunnel, func()) {- b.Helper()-- ctx, cancel := context.WithCancel(context.Background())- envID := fmt.Sprintf("bench-grpc-%d", time.Now().UnixNano())- GetRegistry().Unregister(envID)-- lis, grpcServer, tunnelServer := startTestGRPCTunnelServer(ctx, envID)- go func() {- _ = grpcServer.Serve(lis)- }()-- conn, err := grpc.NewClient("passthrough:///bufnet",- grpc.WithContextDialer(func(ctx context.Context, s string) (net.Conn, error) {- return lis.Dial()- }),- grpc.WithTransportCredentials(insecure.NewCredentials()),- )- if err != nil {- cancel()- tunnelServer.WaitForCleanupDone()- b.Fatalf("failed to create gRPC client: %v", err)- }-- client := tunnelpb.NewTunnelServiceClient(conn)- stream, err := client.Connect(ctx)- if err != nil {- _ = conn.Close()- cancel()- tunnelServer.WaitForCleanupDone()- b.Fatalf("failed to open gRPC stream: %v", err)- }-- if err := stream.Send(&tunnelpb.AgentMessage{- Payload: &tunnelpb.AgentMessage_Register{- Register: &tunnelpb.RegisterRequest{AgentToken: "valid-token"},- },- }); err != nil {- _ = conn.Close()- cancel()- tunnelServer.WaitForCleanupDone()- b.Fatalf("failed to send register message: %v", err)- }-- if _, err := stream.Recv(); err != nil {- _ = conn.Close()- cancel()- tunnelServer.WaitForCleanupDone()- b.Fatalf("failed to receive register response: %v", err)- }-- responseBody := make([]byte, payloadSize)- agentDone := make(chan struct{})- go func() {- defer close(agentDone)- for {- msg, err := stream.Recv()- if err != nil {- return- }- req := msg.GetHttpRequest()- if req == nil {- continue- }- if err := stream.Send(&tunnelpb.AgentMessage{- Payload: &tunnelpb.AgentMessage_HttpResponse{- HttpResponse: &tunnelpb.HttpResponse{- RequestId: req.GetRequestId(),- Status: http.StatusOK,- Body: responseBody,- },- },- }); err != nil {- return- }- }- }()-- tunnel := waitForBenchmarkTunnel(b, envID)-- return tunnel, func() {- _ = conn.Close()- grpcServer.GracefulStop()- cancel()- <-agentDone- tunnelServer.WaitForCleanupDone()- GetRegistry().Unregister(envID)- }-}--func setupWebSocketBenchmarkTunnel(b *testing.B, payloadSize int) (*AgentTunnel, func()) {- b.Helper()-- responseBody := make([]byte, payloadSize)- upgrader := websocket.Upgrader{CheckOrigin: func(_ *http.Request) bool { return true }}-- server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- conn, err := upgrader.Upgrade(w, r, nil)- if err != nil {- return- }-- for {- var msg TunnelMessage- if err := conn.ReadJSON(&msg); err != nil {- _ = conn.Close()- return- }-- if msg.Type != MessageTypeRequest {- continue- }-- resp := TunnelMessage{- ID: msg.ID,- Type: MessageTypeResponse,- Status: http.StatusOK,- Body: responseBody,- }- if err := conn.WriteJSON(resp); err != nil {- _ = conn.Close()- return- }- }- }))-- wsURL := "ws" + strings.TrimPrefix(server.URL, "http")- conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)- if err != nil {- server.Close()- b.Fatalf("failed to dial websocket server: %v", err)- }- if resp != nil {- _ = resp.Body.Close()- }-- tunnel := NewAgentTunnelWithConn("bench-websocket", NewTunnelConn(conn))- dispatchDone := make(chan struct{})- go func() {- defer close(dispatchDone)- for {- msg, err := tunnel.Conn.Receive()- if err != nil {- return- }- if req, ok := tunnel.Pending.Load(msg.ID); ok {- pendingReq := req.(*PendingRequest)- pendingReq.ResponseCh <- msg- }- }- }()-- return tunnel, func() {- _ = tunnel.Close()- server.Close()- <-dispatchDone- }-}--func waitForBenchmarkTunnel(b *testing.B, envID string) *AgentTunnel {- b.Helper()-- deadline := time.Now().Add(2 * time.Second)- for time.Now().Before(deadline) {- tunnel, ok := GetRegistry().Get(envID)- if ok && tunnel != nil {- return tunnel- }- time.Sleep(10 * time.Millisecond)- }-- b.Fatalf("timed out waiting for tunnel registration for env %s", envID)- return nil-}diff --git a/backend/pkg/libarcane/edge/transport_test.go b/backend/pkg/libarcane/edge/transport_test.goindex 02c2380e1..a978931b0 100644--- a/backend/pkg/libarcane/edge/transport_test.go+++ b/backend/pkg/libarcane/edge/transport_test.go@@ -2,10 +2,22 @@ package edgeimport ("context"+ "fmt"+ "io"+ "log/slog"+ "net"+ "net/http"+ "net/http/httptest"+ "strings""sync""testing"+ "time"+ tunnelpb "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/edge/proto/tunnel/v1"+ "github.com/gorilla/websocket""github.com/stretchr/testify/assert"+ "google.golang.org/grpc"+ "google.golang.org/grpc/credentials/insecure")func TestNormalizeEdgeTransport(t *testing.T) {@@ -177,3 +189,228 @@ func (u *unknownTunnelConn) IsClosed() bool { return false }func (u *unknownTunnelConn) SendRequest(ctx context.Context, msg *TunnelMessage, pending *sync.Map) (*TunnelMessage, error) {return nil, nil}++func BenchmarkEdgeTunnelProxyRequest(b *testing.B) {+ previousLogger := slog.Default()+ slog.SetDefault(slog.New(slog.NewTextHandler(io.Discard, nil)))+ b.Cleanup(func() {+ slog.SetDefault(previousLogger)+ })++ payloadSizes := []int{64, 1024, 4096}+ for _, payloadSize := range payloadSizes {+ b.Run(fmt.Sprintf("grpc_payload_%d", payloadSize), func(b *testing.B) {+ tunnel, cleanup := setupGRPCBenchmarkTunnel(b, payloadSize)+ defer cleanup()+ runProxyRequestBenchmark(b, tunnel, payloadSize)+ })++ b.Run(fmt.Sprintf("websocket_payload_%d", payloadSize), func(b *testing.B) {+ tunnel, cleanup := setupWebSocketBenchmarkTunnel(b, payloadSize)+ defer cleanup()+ runProxyRequestBenchmark(b, tunnel, payloadSize)+ })+ }+}++func runProxyRequestBenchmark(b *testing.B, tunnel *AgentTunnel, payloadSize int) {+ b.Helper()++ ctx := context.Background()+ body := make([]byte, payloadSize)+ headers := map[string]string{+ "Content-Type": "application/octet-stream",+ }++ b.ReportAllocs()+ b.SetBytes(int64(payloadSize))+ b.ResetTimer()++ for b.Loop() {+ statusCode, _, respBody, err := ProxyRequest(ctx, tunnel, http.MethodPost, "/api/bench", "", headers, body)+ if err != nil {+ b.Fatalf("proxy request failed: %v", err)+ }+ if statusCode != http.StatusOK {+ b.Fatalf("unexpected status code: %d", statusCode)+ }+ if len(respBody) != payloadSize {+ b.Fatalf("unexpected response length: got %d want %d", len(respBody), payloadSize)+ }+ }+}++func setupGRPCBenchmarkTunnel(b *testing.B, payloadSize int) (*AgentTunnel, func()) {+ b.Helper()++ ctx, cancel := context.WithCancel(context.Background())+ envID := fmt.Sprintf("bench-grpc-%d", time.Now().UnixNano())+ GetRegistry().Unregister(envID)++ lis, grpcServer, tunnelServer := startTestGRPCTunnelServer(ctx, envID)+ go func() {+ _ = grpcServer.Serve(lis)+ }()++ conn, err := grpc.NewClient("passthrough:///bufnet",+ grpc.WithContextDialer(func(ctx context.Context, s string) (net.Conn, error) {+ return lis.Dial()+ }),+ grpc.WithTransportCredentials(insecure.NewCredentials()),+ )+ if err != nil {+ cancel()+ tunnelServer.WaitForCleanupDone()+ b.Fatalf("failed to create gRPC client: %v", err)+ }++ client := tunnelpb.NewTunnelServiceClient(conn)+ stream, err := client.Connect(ctx)+ if err != nil {+ _ = conn.Close()+ cancel()+ tunnelServer.WaitForCleanupDone()+ b.Fatalf("failed to open gRPC stream: %v", err)+ }++ if err := stream.Send(&tunnelpb.AgentMessage{+ Payload: &tunnelpb.AgentMessage_Register{+ Register: &tunnelpb.RegisterRequest{AgentToken: "valid-token"},+ },+ }); err != nil {+ _ = conn.Close()+ cancel()+ tunnelServer.WaitForCleanupDone()+ b.Fatalf("failed to send register message: %v", err)+ }++ if _, err := stream.Recv(); err != nil {+ _ = conn.Close()+ cancel()+ tunnelServer.WaitForCleanupDone()+ b.Fatalf("failed to receive register response: %v", err)+ }++ responseBody := make([]byte, payloadSize)+ agentDone := make(chan struct{})+ go func() {+ defer close(agentDone)+ for {+ msg, err := stream.Recv()+ if err != nil {+ return+ }+ req := msg.GetHttpRequest()+ if req == nil {+ continue+ }+ if err := stream.Send(&tunnelpb.AgentMessage{+ Payload: &tunnelpb.AgentMessage_HttpResponse{+ HttpResponse: &tunnelpb.HttpResponse{+ RequestId: req.GetRequestId(),+ Status: http.StatusOK,+ Body: responseBody,+ },+ },+ }); err != nil {+ return+ }+ }+ }()++ tunnel := waitForBenchmarkTunnel(b, envID)++ return tunnel, func() {+ _ = conn.Close()+ grpcServer.GracefulStop()+ cancel()+ <-agentDone+ tunnelServer.WaitForCleanupDone()+ GetRegistry().Unregister(envID)+ }+}++func setupWebSocketBenchmarkTunnel(b *testing.B, payloadSize int) (*AgentTunnel, func()) {+ b.Helper()++ responseBody := make([]byte, payloadSize)+ upgrader := websocket.Upgrader{CheckOrigin: func(_ *http.Request) bool { return true }}++ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ conn, err := upgrader.Upgrade(w, r, nil)+ if err != nil {+ return+ }++ for {+ var msg TunnelMessage+ if err := conn.ReadJSON(&msg); err != nil {+ _ = conn.Close()+ return+ }++ if msg.Type != MessageTypeRequest {+ continue+ }++ resp := TunnelMessage{+ ID: msg.ID,+ Type: MessageTypeResponse,+ Status: http.StatusOK,+ Body: responseBody,+ }+ if err := conn.WriteJSON(resp); err != nil {+ _ = conn.Close()+ return+ }+ }+ }))++ wsURL := "ws" + strings.TrimPrefix(server.URL, "http")+ conn, resp, err := websocket.DefaultDialer.Dial(wsURL, nil)+ if err != nil {+ server.Close()+ b.Fatalf("failed to dial websocket server: %v", err)+ }+ if resp != nil {+ _ = resp.Body.Close()+ }++ tunnel := NewAgentTunnelWithConn("bench-websocket", NewTunnelConn(conn))+ dispatchDone := make(chan struct{})+ go func() {+ defer close(dispatchDone)+ for {+ msg, err := tunnel.Conn.Receive()+ if err != nil {+ return+ }+ if req, ok := tunnel.Pending.Load(msg.ID); ok {+ pendingReq := req.(*PendingRequest)+ pendingReq.ResponseCh <- msg+ }+ }+ }()++ return tunnel, func() {+ _ = tunnel.Close()+ server.Close()+ <-dispatchDone+ }+}++func waitForBenchmarkTunnel(b *testing.B, envID string) *AgentTunnel {+ b.Helper()++ deadline := time.Now().Add(2 * time.Second)+ for time.Now().Before(deadline) {+ tunnel, ok := GetRegistry().Get(envID)+ if ok && tunnel != nil {+ return tunnel+ }+ time.Sleep(10 * time.Millisecond)+ }++ b.Fatalf("timed out waiting for tunnel registration for env %s", envID)+ return nil+}