Skip to content

Modern Docker Management, Designed for Everyone

fix: edge tunnel go routine leak (#3073)

Kyle Mendella087f1d83da2
diff --git a/backend/pkg/libarcane/edge/client.go b/backend/pkg/libarcane/edge/client.go
index 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 on
cancel context.CancelFunc
dataCh chan wsPayload
mu sync.Mutex
@@ -60,7 +62,7 @@ type TunnelClient struct {
managerGRPCAddr string
localPort string // Port the agent is running on locally
httpClient *http.Client
- conn TunnelConnection
+ conn atomic.Pointer[connBox]
stopCh chan struct{}
requestTimeout time.Duration
activeStreams 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 client
func 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.conn
type registrationResult struct {
msg *TunnelMessage
@@ -414,7 +442,8 @@ func (c *TunnelClient) heartbeatLoop(ctx context.Context) {
case <-ctx.Done():
return
case <-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 manager
func (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 *TunnelMess
req, 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 *TunnelMe
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
}
@@ -678,7 +715,7 @@ func (c *TunnelClient) handleRequestStreaming(ctx context.Context, msg *TunnelMe
req.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 *activeWSStr
c.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, streamCt
websocket.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.go
index 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 Manager
managerServer := 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 *testin
func 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_GRPCConfigWithWebSocketConnUsesNonStreamingR
EdgeTransport: 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_GRPCConfigWithWebSocketConnUsesNonStreamingR
func 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 *tes
require.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 *t
conn := 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_ClosesAttemptConnWhenClientC
t.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, &copyMsg)
+ 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.go
index 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.go
similarity index 100%
rename from backend/pkg/libarcane/edge/grpc_tunnel_integration_test.go
rename to backend/pkg/libarcane/edge/client_transport_grpc_test.go
diff --git a/backend/pkg/libarcane/edge/client_transport_websocket.go b/backend/pkg/libarcane/edge/client_transport_websocket.go
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 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.go
deleted file mode 100644
index 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.go
index b3860b167..99b39cff2 100644
--- a/backend/pkg/libarcane/edge/remenv_test.go
+++ b/backend/pkg/libarcane/edge/remenv_test.go
@@ -3,13 +3,22 @@ package edge
import (
"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.go
deleted file mode 100644
index 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, &copyMsg)
- 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.go
deleted file mode 100644
index 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.go
index 02c2380e1..a978931b0 100644
--- a/backend/pkg/libarcane/edge/transport_test.go
+++ b/backend/pkg/libarcane/edge/transport_test.go
@@ -2,10 +2,22 @@ package edge
import (
"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
+}