Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: image pull progress not streaming from remote environments (#1175)
Kyle Mendellc79cfaf0449e
diff --git a/backend/internal/middleware/environment_middleware.go b/backend/internal/middleware/environment_middleware.goindex 31334c493..347401667 100644--- a/backend/internal/middleware/environment_middleware.go+++ b/backend/internal/middleware/environment_middleware.go@@ -18,8 +18,23 @@ import ()const (+ apiEnvironmentsPrefix = "/api/environments/"environmentsPathMarker = "/environments/"- proxyTimeout = 60 * time.Second++ managementEndpointTest = "/test"+ managementEndpointHeartbeat = "/heartbeat"+ managementEndpointSyncRegistries = "/sync-registries"+ managementEndpointDeployment = "/deployment"+ managementEndpointAgentPair = "/agent/pair"++ errEnvironmentNotFound = "Environment not found"+ errEnvironmentDisabled = "Environment is disabled"+ errFailedCreateProxyRequest = "Failed to create proxy request"+ errProxyRequestFailedPrefix = "Proxy request failed:"++ // proxyTimeout is intentionally generous because some proxied operations+ // (e.g., image pulls with progress streaming) can take multiple minutes.+ proxyTimeout = 30 * time.Minute)// EnvResolver resolves an environment ID to its connection details.@@ -74,7 +89,7 @@ func (m *EnvironmentMiddleware) Handle(c *gin.Context) {if err != nil || apiURL == "" {c.JSON(http.StatusNotFound, gin.H{"success": false,- "data": gin.H{"error": "Environment not found"},+ "data": gin.H{"error": errEnvironmentNotFound},})c.Abort()return@@ -83,7 +98,7 @@ func (m *EnvironmentMiddleware) Handle(c *gin.Context) {if !enabled {c.JSON(http.StatusBadRequest, gin.H{"success": false,- "data": gin.H{"error": "Environment is disabled"},+ "data": gin.H{"error": errEnvironmentDisabled},})c.Abort()return@@ -104,7 +119,7 @@ func (m *EnvironmentMiddleware) Handle(c *gin.Context) {// Returns false for paths like /api/environments/{id} or management endpoints (should be handled locally)func (m *EnvironmentMiddleware) hasResourcePath(c *gin.Context, envID string) bool {path := c.Request.URL.Path- prefix := "/api/environments/" + envID+ prefix := apiEnvironmentsPrefix + envID// If there's content after the environment ID path, check if it's a management endpointsuffix := strings.TrimPrefix(path, prefix)@@ -117,11 +132,11 @@ func (m *EnvironmentMiddleware) hasResourcePath(c *gin.Context, envID string) bo// Check if it's a management endpoint that should NOT be proxied// These are environment management operations handled by the managermanagementEndpoints := []string{- "/test",- "/heartbeat",- "/sync-registries",- "/deployment",- "/agent/pair",+ managementEndpointTest,+ managementEndpointHeartbeat,+ managementEndpointSyncRegistries,+ managementEndpointDeployment,+ managementEndpointAgentPair,}for _, endpoint := range managementEndpoints {@@ -163,14 +178,14 @@ func (m *EnvironmentMiddleware) extractEnvironmentID(c *gin.Context) string {// buildTargetURL constructs the proxy target URL.func (m *EnvironmentMiddleware) buildTargetURL(c *gin.Context, envID, apiURL string) string {// Remove the environment prefix from the path- prefix := "/api/environments/" + envID+ prefix := apiEnvironmentsPrefix + envIDsuffix := strings.TrimPrefix(c.Request.URL.Path, prefix)if suffix != "" && !strings.HasPrefix(suffix, "/") {suffix = "/" + suffix}// Build target: apiURL + /api/environments/{localID} + suffix- target := strings.TrimRight(apiURL, "/") + path.Join("/api/environments/", m.localID) + suffix+ target := strings.TrimRight(apiURL, "/") + path.Join(apiEnvironmentsPrefix, m.localID) + suffix// Append query string if presentif qs := c.Request.URL.RawQuery; qs != "" {@@ -182,14 +197,14 @@ func (m *EnvironmentMiddleware) buildTargetURL(c *gin.Context, envID, apiURL str// isWebSocketUpgrade checks if this is a WebSocket upgrade request.func (m *EnvironmentMiddleware) isWebSocketUpgrade(c *gin.Context) bool {- return strings.EqualFold(c.GetHeader("Upgrade"), "websocket") ||- strings.Contains(strings.ToLower(c.GetHeader("Connection")), "upgrade")+ return strings.EqualFold(c.GetHeader(remenv.HeaderUpgrade), "websocket") ||+ strings.Contains(strings.ToLower(c.GetHeader(remenv.HeaderConnection)), remenv.ConnectionUpgradeToken)}// proxyWebSocket handles WebSocket proxy requests.func (m *EnvironmentMiddleware) proxyWebSocket(c *gin.Context, target string, accessToken *string, envID string) {- wsTarget := httpToWebSocketURL(target)- headers := m.buildWebSocketHeaders(c, accessToken)+ wsTarget := remenv.HTTPToWebSocketURL(target)+ headers := remenv.BuildWebSocketHeaders(c, accessToken)if err := wsutil.ProxyHTTP(c.Writer, c.Request, wsTarget, headers); err != nil {slog.Error("websocket proxy failed", "env_id", envID, "target", wsTarget, "err", err)@@ -203,7 +218,7 @@ func (m *EnvironmentMiddleware) proxyHTTP(c *gin.Context, target string, accessTif err != nil {c.JSON(http.StatusInternalServerError, gin.H{"success": false,- "data": gin.H{"error": "Failed to create proxy request"},+ "data": gin.H{"error": errFailedCreateProxyRequest},})c.Abort()return@@ -213,7 +228,7 @@ func (m *EnvironmentMiddleware) proxyHTTP(c *gin.Context, target string, accessTif err != nil {c.JSON(http.StatusBadGateway, gin.H{"success": false,- "data": gin.H{"error": fmt.Sprintf("Proxy request failed: %v", err)},+ "data": gin.H{"error": fmt.Sprintf("%s %v", errProxyRequestFailedPrefix, err)},})c.Abort()return@@ -238,13 +253,7 @@ func (m *EnvironmentMiddleware) createProxyRequest(c *gin.Context, target stringc.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))}- slog.DebugContext(c.Request.Context(), "Creating proxy request",- "method", c.Request.Method,- "target", target,- "contentLength", c.Request.ContentLength,- "contentType", c.GetHeader("Content-Type"),- "bodyLength", len(bodyBytes),- "body", string(bodyBytes))+ slog.DebugContext(c.Request.Context(), "Creating proxy request", "method", c.Request.Method, "target", target, "contentLength", c.Request.ContentLength, "contentType", c.GetHeader("Content-Type"), "bodyLength", len(bodyBytes), "body", string(bodyBytes))req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, target, bytes.NewBuffer(bodyBytes))if err != nil {@@ -272,49 +281,10 @@ func (m *EnvironmentMiddleware) writeProxyResponse(c *gin.Context, resp *http.Rec.Status(resp.StatusCode)if c.Request.Method != http.MethodHead {- _, _ = io.Copy(c.Writer, resp.Body)- }-}--// buildWebSocketHeaders creates headers for WebSocket proxy requests.-func (m *EnvironmentMiddleware) buildWebSocketHeaders(c *gin.Context, accessToken *string) http.Header {- headers := http.Header{}-- // Forward API key if present- if apiKey := c.GetHeader("X-Api-Key"); apiKey != "" {- headers.Set("X-Api-Key", apiKey)- }-- // Forward authorization (header or cookie)- if auth := c.GetHeader("Authorization"); auth != "" {- headers.Set("Authorization", auth)- } else if token, err := c.Cookie("token"); err == nil && token != "" {- headers.Set("Authorization", "Bearer "+token)- }-- // Forward cookies if no other auth is present- if headers.Get("Authorization") == "" && headers.Get("X-Api-Token") == "" {- if cookies := c.Request.Header.Get("Cookie"); cookies != "" {- headers.Set("Cookie", cookies)- }- }-- // Set agent token for remote environment authentication- if accessToken != nil && *accessToken != "" {- headers.Set("X-Arcane-Agent-Token", *accessToken)- }-- return headers-}--// httpToWebSocketURL converts an HTTP(S) URL to WS(S).-func httpToWebSocketURL(url string) string {- switch {- case strings.HasPrefix(url, "https://"):- return "wss://" + strings.TrimPrefix(url, "https://")- case strings.HasPrefix(url, "http://"):- return "ws://" + strings.TrimPrefix(url, "http://")- default:- return url+ // Ensure headers are sent before streaming the body.+ // This is critical for streaming responses (e.g., JSON line streams) where+ // clients expect incremental updates.+ c.Writer.WriteHeaderNow()+ remenv.CopyBodyWithFlush(c.Writer, resp.Body)}}diff --git a/backend/internal/utils/remenv/remenv.go b/backend/internal/utils/remenv/remenv.goindex b1f9c1e3d..8da5ac838 100644--- a/backend/internal/utils/remenv/remenv.go+++ b/backend/internal/utils/remenv/remenv.go@@ -1,18 +1,29 @@package remenvimport (+ "io""net/http""strings""github.com/gin-gonic/gin")-const headerApiToken = "X-Api-Token" // #nosec G101: header name, not a credential+const (+ HeaderAPIKey = "X-Api-Key" // #nosec G101: header name, not a credential+ HeaderAPIToken = "X-Api-Token" // #nosec G101: header name, not a credential+ HeaderAuthorization = "Authorization"+ HeaderCookie = "Cookie"+ HeaderAgentToken = "X-Arcane-Agent-Token" // #nosec G101: header name, not a credential+ HeaderUpgrade = "Upgrade"+ HeaderConnection = "Connection"++ ConnectionUpgradeToken = "upgrade"+)func CopyRequestHeaders(from http.Header, to http.Header, skip map[string]struct{}) {for k, vs := range from {ck := http.CanonicalHeaderKey(k)- if _, ok := skip[ck]; ok || ck == "Authorization" || ck == http.CanonicalHeaderKey(headerApiToken) {+ if _, ok := skip[ck]; ok || ck == http.CanonicalHeaderKey(HeaderAuthorization) || ck == http.CanonicalHeaderKey(HeaderAPIToken) {continue}for _, v := range vs {@@ -23,21 +34,87 @@ func CopyRequestHeaders(from http.Header, to http.Header, skip map[string]structfunc SetAuthHeader(req *http.Request, c *gin.Context) {// Forward API key header if present- if apiKey := c.GetHeader(headerApiToken); apiKey != "" {- req.Header.Set(headerApiToken, apiKey)+ if apiKey := c.GetHeader(HeaderAPIToken); apiKey != "" {+ req.Header.Set(HeaderAPIToken, apiKey)}// Forward Authorization header or cookie token- if auth := c.GetHeader("Authorization"); auth != "" {- req.Header.Set("Authorization", auth)+ if auth := c.GetHeader(HeaderAuthorization); auth != "" {+ req.Header.Set(HeaderAuthorization, auth)} else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {- req.Header.Set("Authorization", "Bearer "+cookieToken)+ req.Header.Set(HeaderAuthorization, "Bearer "+cookieToken)}}func SetAgentToken(req *http.Request, accessToken *string) {if accessToken != nil && *accessToken != "" {- req.Header.Set("X-Arcane-Agent-Token", *accessToken)+ req.Header.Set(HeaderAgentToken, *accessToken)+ }+}++// BuildWebSocketHeaders constructs a header set for proxying WebSocket requests+// to a remote environment, forwarding authentication in the same way as HTTP proxying.+func BuildWebSocketHeaders(c *gin.Context, accessToken *string) http.Header {+ headers := http.Header{}++ // Forward API key if present+ if apiKey := c.GetHeader(HeaderAPIKey); apiKey != "" {+ headers.Set(HeaderAPIKey, apiKey)+ }++ // Forward authorization (header or cookie)+ if auth := c.GetHeader(HeaderAuthorization); auth != "" {+ headers.Set(HeaderAuthorization, auth)+ } else if token, err := c.Cookie("token"); err == nil && token != "" {+ headers.Set(HeaderAuthorization, "Bearer "+token)+ }++ // Forward cookies if no other auth is present+ if headers.Get(HeaderAuthorization) == "" && headers.Get(HeaderAPIToken) == "" {+ if cookies := c.Request.Header.Get(HeaderCookie); cookies != "" {+ headers.Set(HeaderCookie, cookies)+ }+ }++ // Set agent token for remote environment authentication+ if accessToken != nil && *accessToken != "" {+ headers.Set(HeaderAgentToken, *accessToken)+ }++ return headers+}++// HTTPToWebSocketURL converts an HTTP(S) URL to WS(S).+func HTTPToWebSocketURL(url string) string {+ switch {+ case strings.HasPrefix(url, "https://"):+ return "wss://" + strings.TrimPrefix(url, "https://")+ case strings.HasPrefix(url, "http://"):+ return "ws://" + strings.TrimPrefix(url, "http://")+ default:+ return url+ }+}++// CopyBodyWithFlush streams bytes from body to w, flushing when supported.+// Useful for progress/streaming endpoints where incremental delivery matters.+func CopyBodyWithFlush(w http.ResponseWriter, body io.Reader) {+ buf := make([]byte, 32*1024)+ flusher, canFlush := w.(http.Flusher)++ for {+ n, readErr := body.Read(buf)+ if n > 0 {+ if _, writeErr := w.Write(buf[:n]); writeErr != nil {+ return+ }+ if canFlush {+ flusher.Flush()+ }+ }+ if readErr != nil {+ return+ }}}diff --git a/backend/internal/utils/remenv/remenv_test.go b/backend/internal/utils/remenv/remenv_test.gonew file mode 100644index 000000000..0822f856b--- /dev/null+++ b/backend/internal/utils/remenv/remenv_test.go@@ -0,0 +1,252 @@+package remenv++import (+ "bytes"+ "context"+ "io"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++type chunkReader struct {+ chunks [][]byte+ idx int+}++func (r *chunkReader) Read(p []byte) (int, error) {+ if r.idx >= len(r.chunks) {+ return 0, io.EOF+ }+ c := r.chunks[r.idx]+ r.idx+++ return copy(p, c), nil+}++type flushResponseWriter struct {+ header http.Header+ buf bytes.Buffer+ status int+ flushes int+}++func newFlushResponseWriter() *flushResponseWriter {+ return &flushResponseWriter{header: make(http.Header)}+}++func (w *flushResponseWriter) Header() http.Header { return w.header }++func (w *flushResponseWriter) Write(b []byte) (int, error) {+ return w.buf.Write(b)+}++func (w *flushResponseWriter) WriteHeader(statusCode int) { w.status = statusCode }++func (w *flushResponseWriter) Flush() { w.flushes++ }++type noFlushResponseWriter struct {+ header http.Header+ buf bytes.Buffer+ status int+}++func newNoFlushResponseWriter() *noFlushResponseWriter {+ return &noFlushResponseWriter{header: make(http.Header)}+}++func (w *noFlushResponseWriter) Header() http.Header { return w.header }++func (w *noFlushResponseWriter) Write(b []byte) (int, error) {+ return w.buf.Write(b)+}++func (w *noFlushResponseWriter) WriteHeader(statusCode int) { w.status = statusCode }++func TestCopyRequestHeaders_SkipsExpectedHeaders(t *testing.T) {+ skip := GetSkipHeaders()+ from := http.Header{}+ from.Add("X-Test", "a")+ from.Add("X-Test", "b")+ from.Set(HeaderAuthorization, "Bearer should-not-copy")+ from.Set(HeaderAPIToken, "token-should-not-copy")+ from.Set("Host", "example.com")+ from.Set(HeaderCookie, "session=abc")+ from.Set("Transfer-Encoding", "chunked")++ to := http.Header{}+ CopyRequestHeaders(from, to, skip)++ require.Equal(t, []string{"a", "b"}, to.Values("X-Test"))+ require.Empty(t, to.Get(HeaderAuthorization))+ require.Empty(t, to.Get(HeaderAPIToken))+ require.Empty(t, to.Get("Host"))+ require.Empty(t, to.Get(HeaderCookie))+ require.Empty(t, to.Get("Transfer-Encoding"))+}++func TestSetAuthHeader_ForwardsAPITokenAndAuthorization(t *testing.T) {+ gin.SetMode(gin.TestMode)+ w := httptest.NewRecorder()+ c, _ := gin.CreateTestContext(w)+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)+ c.Request.Header.Set(HeaderAPIToken, "api-token")+ c.Request.Header.Set(HeaderAuthorization, "Bearer auth")++ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)+ require.NoError(t, err)++ SetAuthHeader(req, c)+ require.Equal(t, "api-token", req.Header.Get(HeaderAPIToken))+ require.Equal(t, "Bearer auth", req.Header.Get(HeaderAuthorization))+}++func TestSetAuthHeader_UsesCookieTokenWhenNoAuthorization(t *testing.T) {+ gin.SetMode(gin.TestMode)+ w := httptest.NewRecorder()+ c, _ := gin.CreateTestContext(w)+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)+ c.Request.AddCookie(&http.Cookie{Name: "token", Value: "cookie-token"})++ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)+ require.NoError(t, err)++ SetAuthHeader(req, c)+ require.Equal(t, "Bearer cookie-token", req.Header.Get(HeaderAuthorization))+}++func TestSetAgentToken(t *testing.T) {+ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)+ require.NoError(t, err)++ SetAgentToken(req, nil)+ require.Empty(t, req.Header.Get(HeaderAgentToken))++ tok := "agent-token"+ SetAgentToken(req, &tok)+ require.Equal(t, tok, req.Header.Get(HeaderAgentToken))+}++func TestSetForwardedHeaders(t *testing.T) {+ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)+ require.NoError(t, err)++ SetForwardedHeaders(req, "1.2.3.4", "example.com")+ require.Equal(t, "1.2.3.4", req.Header.Get("X-Forwarded-For"))+ require.Equal(t, "example.com", req.Header.Get("X-Forwarded-Host"))+}++func TestGetHopByHopHeaders_IncludesStandardHeaders(t *testing.T) {+ h := GetHopByHopHeaders()+ _, ok := h[http.CanonicalHeaderKey("Connection")]+ require.True(t, ok)+ _, ok = h[http.CanonicalHeaderKey("Transfer-Encoding")]+ require.True(t, ok)+ _, ok = h[http.CanonicalHeaderKey("Upgrade")]+ require.True(t, ok)+}++func TestBuildHopByHopHeaders_AddsConnectionTokens(t *testing.T) {+ respHeader := http.Header{}+ respHeader.Add("Connection", "X-Foo, keep-alive")+ respHeader.Add("Connection", "x-bar")++ hop := BuildHopByHopHeaders(respHeader)+ require.Contains(t, hop, http.CanonicalHeaderKey("X-Foo"))+ require.Contains(t, hop, http.CanonicalHeaderKey("Keep-Alive"))+ require.Contains(t, hop, http.CanonicalHeaderKey("X-Bar"))+}++func TestCopyResponseHeaders_SkipsHopByHopAndConnectionNamedHeaders(t *testing.T) {+ from := http.Header{}+ from.Set("Content-Type", "application/json")+ from.Set("Transfer-Encoding", "chunked")+ from.Set("X-Foo", "bar")+ from.Add("Connection", "X-Foo")++ hop := BuildHopByHopHeaders(from)+ to := http.Header{}+ CopyResponseHeaders(from, to, hop)++ require.Equal(t, "application/json", to.Get("Content-Type"))+ require.Empty(t, to.Get("Transfer-Encoding"))+ require.Empty(t, to.Get("X-Foo"))+ require.Empty(t, to.Get("Connection"))+}++func TestGetSkipHeaders_ContainsExpectedEntries(t *testing.T) {+ skip := GetSkipHeaders()+ require.Contains(t, skip, "Host")+ require.Contains(t, skip, "Connection")+ require.Contains(t, skip, "Transfer-Encoding")+ require.Contains(t, skip, "Upgrade")+ require.Contains(t, skip, "Content-Length")+ require.Contains(t, skip, "Cookie")+ require.Contains(t, skip, "Origin")+ require.Contains(t, skip, "Referer")+}++func TestBuildWebSocketHeaders_UsesAuthorizationHeaderAndAddsAgentToken(t *testing.T) {+ gin.SetMode(gin.TestMode)+ w := httptest.NewRecorder()+ c, _ := gin.CreateTestContext(w)+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)+ c.Request.Header.Set(HeaderAPIKey, "api-key")+ c.Request.Header.Set(HeaderAuthorization, "Bearer auth")+ c.Request.Header.Set(HeaderCookie, "session=abc")++ agent := "agent-token"+ headers := BuildWebSocketHeaders(c, &agent)++ require.Equal(t, "api-key", headers.Get(HeaderAPIKey))+ require.Equal(t, "Bearer auth", headers.Get(HeaderAuthorization))+ require.Empty(t, headers.Get(HeaderCookie))+ require.Equal(t, agent, headers.Get(HeaderAgentToken))+}++func TestBuildWebSocketHeaders_UsesCookieTokenAsBearer(t *testing.T) {+ gin.SetMode(gin.TestMode)+ w := httptest.NewRecorder()+ c, _ := gin.CreateTestContext(w)+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)+ c.Request.AddCookie(&http.Cookie{Name: "token", Value: "cookie-token"})++ headers := BuildWebSocketHeaders(c, nil)+ require.Equal(t, "Bearer cookie-token", headers.Get(HeaderAuthorization))+}++func TestBuildWebSocketHeaders_ForwardsCookieHeaderWhenNoAuthPresent(t *testing.T) {+ gin.SetMode(gin.TestMode)+ w := httptest.NewRecorder()+ c, _ := gin.CreateTestContext(w)+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)+ c.Request.Header.Set(HeaderCookie, "session=abc")++ headers := BuildWebSocketHeaders(c, nil)+ require.Equal(t, "session=abc", headers.Get(HeaderCookie))+}++func TestHTTPToWebSocketURL(t *testing.T) {+ require.Equal(t, "wss://example.com/path", HTTPToWebSocketURL("https://example.com/path"))+ require.Equal(t, "ws://example.com/path", HTTPToWebSocketURL("http://example.com/path"))+ require.Equal(t, "ws://already", HTTPToWebSocketURL("ws://already"))+}++func TestCopyBodyWithFlush_FlushesWhenSupported(t *testing.T) {+ w := newFlushResponseWriter()+ body := &chunkReader{chunks: [][]byte{[]byte("hello "), []byte("world")}}++ CopyBodyWithFlush(w, body)+ require.Equal(t, "hello world", w.buf.String())+ require.Equal(t, 2, w.flushes)+}++func TestCopyBodyWithFlush_DoesNotRequireFlusher(t *testing.T) {+ w := newNoFlushResponseWriter()+ body := &chunkReader{chunks: [][]byte{[]byte("a"), []byte("b"), []byte("c")}}++ CopyBodyWithFlush(w, body)+ require.Equal(t, "abc", w.buf.String())+}