Skip to content

Modern Docker Management, Designed for Everyone

fix: pass registry credentials to environments (#603)

Kyle Mendelle04d6c92ca8b
diff --git a/.env.dev b/.env.dev
index bd4a10215..3a456b2a7 100644
--- a/.env.dev
+++ b/.env.dev
@@ -24,5 +24,5 @@ JWT_SECRET=dev-jwt-secret-replace-in-production-must-be-long-enough
DATABASE_URL=file:data/arcane.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(2500)&_txlock=immediate
# Agent Configuration (for development agent service)
-AGENT_MODE=false
+# AGENT_MODE=f
AGENT_BOOTSTRAP_TOKEN=development-bootstrap-token
diff --git a/backend/internal/api/container_handler.go b/backend/internal/api/container_handler.go
index 25b6c4f42..dd35e6aeb 100644
--- a/backend/internal/api/container_handler.go
+++ b/backend/internal/api/container_handler.go
@@ -170,7 +170,7 @@ func (h *ContainerHandler) PullImage(c *gin.Context) {
if !ok {
return
}
- if err := h.imageService.PullImage(c.Request.Context(), imageName, c.Writer, *currentUser); err != nil {
+ if err := h.imageService.PullImage(c.Request.Context(), imageName, c.Writer, *currentUser, nil); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"data": gin.H{"error": "Failed to pull image: " + err.Error()},
diff --git a/backend/internal/api/environment_handler.go b/backend/internal/api/environment_handler.go
index e8eb4bbba..40b75ea21 100644
--- a/backend/internal/api/environment_handler.go
+++ b/backend/internal/api/environment_handler.go
@@ -1,6 +1,7 @@
package api
import (
+ "log/slog"
"net/http"
"github.com/gin-gonic/gin"
@@ -96,14 +97,23 @@ func (h *EnvironmentHandler) CreateEnvironment(c *gin.Context) {
env.Enabled = *req.Enabled
}
- // Auto-pair with agent if bootstrap token is provided
if (req.AccessToken == nil || *req.AccessToken == "") && req.BootstrapToken != nil && *req.BootstrapToken != "" {
- if token, err := h.environmentService.PairAgentWithBootstrap(c.Request.Context(), req.ApiUrl, *req.BootstrapToken); err == nil && token != "" {
- env.AccessToken = &token
- } else if err != nil {
- c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": "Agent pairing failed: " + err.Error()}})
+ token, err := h.environmentService.PairAgentWithBootstrap(c.Request.Context(), req.ApiUrl, *req.BootstrapToken)
+ if err != nil {
+ slog.ErrorContext(c.Request.Context(), "Failed to pair with agent",
+ slog.String("apiUrl", req.ApiUrl),
+ slog.String("error", err.Error()))
+
+ c.JSON(http.StatusBadGateway, gin.H{
+ "success": false,
+ "data": gin.H{
+ "error": "Agent pairing failed: " + err.Error(),
+ "hint": "Ensure the agent is running and the bootstrap token matches AGENT_BOOTSTRAP_TOKEN",
+ },
+ })
return
}
+ env.AccessToken = &token
} else if req.AccessToken != nil && *req.AccessToken != "" {
env.AccessToken = req.AccessToken
}
diff --git a/backend/internal/api/image_handler.go b/backend/internal/api/image_handler.go
index d2d73ce91..fb7e452a5 100644
--- a/backend/internal/api/image_handler.go
+++ b/backend/internal/api/image_handler.go
@@ -124,7 +124,7 @@ func (h *ImageHandler) Pull(c *gin.Context) {
return
}
- if err := h.imageService.PullImage(ctx, req.ImageName, c.Writer, *currentUser); err != nil {
+ if err := h.imageService.PullImage(ctx, req.ImageName, c.Writer, *currentUser, req.Credentials); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
"data": dto.MessageDto{Message: fmt.Sprintf("Failed to pull image '%s': %s", req.ImageName, err.Error())},
diff --git a/backend/internal/api/image_update_handler.go b/backend/internal/api/image_update_handler.go
index f2b46dd47..30768cc32 100644
--- a/backend/internal/api/image_update_handler.go
+++ b/backend/internal/api/image_update_handler.go
@@ -98,7 +98,7 @@ func (h *ImageUpdateHandler) CheckMultipleImages(c *gin.Context) {
return
}
- results, err := h.imageUpdateService.CheckMultipleImages(c.Request.Context(), req.ImageRefs)
+ results, err := h.imageUpdateService.CheckMultipleImages(c.Request.Context(), req.ImageRefs, req.Credentials)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
@@ -116,7 +116,10 @@ func (h *ImageUpdateHandler) CheckMultipleImages(c *gin.Context) {
}
func (h *ImageUpdateHandler) CheckAllImages(c *gin.Context) {
- results, err := h.imageUpdateService.CheckAllImages(c.Request.Context(), 0)
+ var req dto.BatchImageUpdateRequest
+ _ = c.ShouldBindJSON(&req)
+
+ results, err := h.imageUpdateService.CheckAllImages(c.Request.Context(), 0, req.Credentials)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.go
index bd419f9c5..b0a9f837b 100644
--- a/backend/internal/bootstrap/jobs_bootstrap.go
+++ b/backend/internal/bootstrap/jobs_bootstrap.go
@@ -23,12 +23,11 @@ func registerJobs(appCtx context.Context, scheduler *job.Scheduler, appServices
slog.ErrorContext(appCtx, "Failed to register auto-update job", slog.Any("error", err))
}
- imagePollingJob := job.NewImagePollingJob(scheduler, appServices.ImageUpdate, appServices.Settings)
+ imagePollingJob := job.NewImagePollingJob(scheduler, appServices.ImageUpdate, appServices.Settings, appServices.Environment)
if err := imagePollingJob.Register(appCtx); err != nil {
slog.ErrorContext(appCtx, "Failed to register image polling job", slog.Any("error", err))
}
- // Register analytics heartbeat job
analyticsJob := job.NewAnalyticsJob(scheduler, appServices.Settings, nil, appConfig)
if err := analyticsJob.Register(appCtx); err != nil {
slog.ErrorContext(appCtx, "Failed to register analytics heartbeat job", slog.Any("error", err))
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index c2b298ac1..d85baa277 100644
--- a/backend/internal/bootstrap/router_bootstrap.go
+++ b/backend/internal/bootstrap/router_bootstrap.go
@@ -71,25 +71,30 @@ func setupRouter(cfg *config.Config, appServices *Services) *gin.Engine {
api.NewOidcHandler(apiGroup, appServices.Auth, appServices.Oidc, cfg)
api.NewSettingsHandler(apiGroup, appServices.Settings, authMiddleware)
api.NewEnvironmentHandler(apiGroup, appServices.Environment, appServices.Settings, authMiddleware, cfg)
+ api.NewContainerRegistryHandler(apiGroup, appServices.ContainerRegistry, authMiddleware)
+ api.NewTemplateHandler(apiGroup, appServices.Template, authMiddleware)
- apiGroup.Use(middleware.NewEnvProxyMiddleware(api.LOCAL_DOCKER_ENVIRONMENT_ID, func(ctx context.Context, id string) (string, *string, bool, error) {
- env, err := appServices.Environment.GetEnvironmentByID(ctx, id)
- if err != nil || env == nil {
- return "", nil, false, err
- }
- return env.ApiUrl, env.AccessToken, env.Enabled, nil
- }))
+ envMiddleware := middleware.NewEnvProxyMiddlewareWithParam(
+ api.LOCAL_DOCKER_ENVIRONMENT_ID,
+ "id",
+ func(ctx context.Context, id string) (string, *string, bool, error) {
+ env, err := appServices.Environment.GetEnvironmentByID(ctx, id)
+ if err != nil || env == nil {
+ return "", nil, false, err
+ }
+ return env.ApiUrl, env.AccessToken, env.Enabled, nil
+ },
+ appServices.Environment,
+ )
+ apiGroup.Use(envMiddleware)
api.NewHealthHandler(apiGroup)
-
api.NewContainerHandler(apiGroup, appServices.Docker, appServices.Container, appServices.Image, authMiddleware)
- api.NewContainerRegistryHandler(apiGroup, appServices.ContainerRegistry, authMiddleware)
api.NewImageHandler(apiGroup, appServices.Docker, appServices.Image, appServices.ImageUpdate, authMiddleware)
api.NewImageUpdateHandler(apiGroup, appServices.ImageUpdate, authMiddleware)
api.NewNetworkHandler(apiGroup, appServices.Docker, appServices.Network, authMiddleware)
api.NewProjectHandler(apiGroup, appServices.Project, authMiddleware)
api.NewSystemHandler(apiGroup, appServices.Docker, appServices.System, authMiddleware)
- api.NewTemplateHandler(apiGroup, appServices.Template, authMiddleware)
api.NewUpdaterHandler(apiGroup, appServices.Updater, authMiddleware)
api.NewVolumeHandler(apiGroup, appServices.Docker, appServices.Volume, authMiddleware)
diff --git a/backend/internal/dto/container_registry_dto.go b/backend/internal/dto/container_registry_dto.go
index 7a0ed1610..5dd824273 100644
--- a/backend/internal/dto/container_registry_dto.go
+++ b/backend/internal/dto/container_registry_dto.go
@@ -12,3 +12,10 @@ type ContainerRegistryDto struct {
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
}
+
+type ContainerRegistryCredential struct {
+ URL string `json:"url" binding:"required"`
+ Username string `json:"username" binding:"required"`
+ Token string `json:"token" binding:"required"`
+ Enabled bool `json:"enabled"`
+}
diff --git a/backend/internal/dto/image_dto.go b/backend/internal/dto/image_dto.go
index ec09e4ff8..edc17f34c 100644
--- a/backend/internal/dto/image_dto.go
+++ b/backend/internal/dto/image_dto.go
@@ -9,7 +9,8 @@ import (
)
type ImagePullDto struct {
- ImageName string `json:"imageName" binding:"required"`
+ ImageName string `json:"imageName" binding:"required"`
+ Credentials []ContainerRegistryCredential `json:"credentials,omitempty"`
}
type ImageUpdateInfoDto struct {
diff --git a/backend/internal/dto/image_update_dto.go b/backend/internal/dto/image_update_dto.go
index 3c3360c17..a8e39ab08 100644
--- a/backend/internal/dto/image_update_dto.go
+++ b/backend/internal/dto/image_update_dto.go
@@ -43,7 +43,8 @@ type VersionComparisonResponse struct {
}
type BatchImageUpdateRequest struct {
- ImageRefs []string `json:"imageRefs" binding:"required"`
+ ImageRefs []string `json:"imageRefs" binding:"required"`
+ Credentials []ContainerRegistryCredential `json:"credentials,omitempty"`
}
type BatchImageUpdateResponse map[string]*ImageUpdateResponse
diff --git a/backend/internal/job/image_polling_job.go b/backend/internal/job/image_polling_job.go
index ac2561c85..51e680421 100644
--- a/backend/internal/job/image_polling_job.go
+++ b/backend/internal/job/image_polling_job.go
@@ -6,19 +6,22 @@ import (
"time"
"github.com/go-co-op/gocron/v2"
+ "github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/services"
)
type ImagePollingJob struct {
imageUpdateService *services.ImageUpdateService
settingsService *services.SettingsService
+ environmentService *services.EnvironmentService
scheduler *Scheduler
}
-func NewImagePollingJob(scheduler *Scheduler, imageUpdateService *services.ImageUpdateService, settingsService *services.SettingsService) *ImagePollingJob {
+func NewImagePollingJob(scheduler *Scheduler, imageUpdateService *services.ImageUpdateService, settingsService *services.SettingsService, environmentService *services.EnvironmentService) *ImagePollingJob {
return &ImagePollingJob{
imageUpdateService: imageUpdateService,
settingsService: settingsService,
+ environmentService: environmentService,
scheduler: scheduler,
}
}
@@ -35,14 +38,13 @@ func (j *ImagePollingJob) Register(ctx context.Context) error {
interval := time.Duration(pollingInterval) * time.Minute
if interval < 5*time.Minute {
slog.WarnContext(ctx, "polling interval too low; using default",
- "requested_minutes", pollingInterval,
- "effective_interval", "60m")
+ slog.Int("requested_minutes", pollingInterval),
+ slog.String("effective_interval", "60m"))
interval = 60 * time.Minute
}
- slog.InfoContext(ctx, "registering image polling job", "interval", interval.String())
+ slog.InfoContext(ctx, "registering image polling job", slog.String("interval", interval.String()))
- // ensure single instance
j.scheduler.RemoveJobByName("image-polling")
jobDefinition := gocron.DurationJob(interval)
@@ -58,9 +60,16 @@ func (j *ImagePollingJob) Register(ctx context.Context) error {
func (j *ImagePollingJob) Execute(ctx context.Context) error {
slog.InfoContext(ctx, "image scan run started")
- results, err := j.imageUpdateService.CheckAllImages(ctx, 0)
+ creds, err := j.loadRegistryCredentials(ctx)
if err != nil {
- slog.ErrorContext(ctx, "image scan failed", "err", err)
+ slog.WarnContext(ctx, "failed to load registry credentials for polling",
+ slog.String("error", err.Error()))
+ creds = nil
+ }
+
+ results, err := j.imageUpdateService.CheckAllImages(ctx, 0, creds)
+ if err != nil {
+ slog.ErrorContext(ctx, "image scan failed", slog.Any("err", err))
return err
}
@@ -81,14 +90,17 @@ func (j *ImagePollingJob) Execute(ctx context.Context) error {
}
slog.InfoContext(ctx, "image scan run completed",
- "checked", total,
- "updates", updates,
- "errors", errors,
- )
+ slog.Int("checked", total),
+ slog.Int("updates", updates),
+ slog.Int("errors", errors))
return nil
}
+func (j *ImagePollingJob) loadRegistryCredentials(ctx context.Context) ([]dto.ContainerRegistryCredential, error) {
+ return j.environmentService.GetEnabledRegistryCredentials(ctx)
+}
+
func (j *ImagePollingJob) Reschedule(ctx context.Context) error {
pollingEnabled := j.settingsService.GetBoolSetting(ctx, "pollingEnabled", true)
pollingInterval := j.settingsService.GetIntSetting(ctx, "pollingInterval", 60)
@@ -103,7 +115,7 @@ func (j *ImagePollingJob) Reschedule(ctx context.Context) error {
if interval < 5*time.Minute {
interval = 60 * time.Minute
}
- slog.InfoContext(ctx, "polling settings changed; rescheduling", "interval", interval.String())
+ slog.InfoContext(ctx, "polling settings changed; rescheduling", slog.String("interval", interval.String()))
return j.scheduler.RescheduleDurationJobByName(ctx, "image-polling", interval, j.Execute, false)
}
diff --git a/backend/internal/middleware/environment_middleware.go b/backend/internal/middleware/environment_middleware.go
index 5a61961c6..86ea1c5bc 100644
--- a/backend/internal/middleware/environment_middleware.go
+++ b/backend/internal/middleware/environment_middleware.go
@@ -11,6 +11,8 @@ import (
"time"
"github.com/gin-gonic/gin"
+ "github.com/ofkm/arcane-backend/internal/services"
+ "github.com/ofkm/arcane-backend/internal/utils/remenv"
wsutil "github.com/ofkm/arcane-backend/internal/utils/ws"
)
@@ -19,37 +21,42 @@ type EnvResolver func(ctx context.Context, id string) (apiURL string, accessToke
// NewEnvProxyMiddleware preserves the previous API and uses "id" as the param name.
func NewEnvProxyMiddleware(localID string, resolver EnvResolver) gin.HandlerFunc {
- return NewEnvProxyMiddlewareWithParam(localID, "id", resolver)
+ return NewEnvProxyMiddlewareWithParam(localID, "id", resolver, nil)
}
// NewEnvProxyMiddlewareWithParam returns a gin middleware that proxies requests whose environment id
// is remote. paramName is the URL param key (e.g. "id") that contains the environment id when using
// router groups; if that param is not present the middleware will attempt to auto-detect the id
// by parsing the request path after the first "/environments/" segment.
-//
-//nolint:gocognit
-func NewEnvProxyMiddlewareWithParam(localID string, paramName string, resolver EnvResolver) gin.HandlerFunc {
+func NewEnvProxyMiddlewareWithParam(localID string, paramName string, resolver EnvResolver, envService *services.EnvironmentService) gin.HandlerFunc {
+ m := &EnvironmentMiddleware{
+ localID: localID,
+ resolver: resolver,
+ envService: envService,
+ httpClient: &http.Client{
+ Timeout: 60 * time.Second,
+ },
+ }
+ return m.handle(paramName)
+}
+
+type EnvironmentMiddleware struct {
+ localID string
+ resolver EnvResolver
+ envService *services.EnvironmentService
+ httpClient *http.Client
+}
+
+func (m *EnvironmentMiddleware) handle(paramName string) gin.HandlerFunc {
return func(c *gin.Context) {
- envID := c.Param(paramName)
-
- // Fallback: try to auto-detect env id from path like "/.../environments/<envID>/..."
- if envID == "" {
- const marker = "/environments/"
- if idx := strings.Index(c.Request.URL.Path, marker); idx >= 0 {
- rest := c.Request.URL.Path[idx+len(marker):]
- parts := strings.SplitN(rest, "/", 2)
- if len(parts) > 0 && parts[0] != "" {
- envID = parts[0]
- }
- }
- }
+ envID := m.extractEnvironmentID(c, paramName)
- if envID == "" || envID == localID {
+ if envID == "" || envID == m.localID {
c.Next()
return
}
- apiURL, accessToken, enabled, err := resolver(c.Request.Context(), envID)
+ apiURL, accessToken, enabled, err := m.resolver(c.Request.Context(), envID)
if err != nil || apiURL == "" {
c.JSON(http.StatusNotFound, gin.H{"success": false, "data": gin.H{"error": "Environment not found"}})
c.Abort()
@@ -61,146 +68,151 @@ func NewEnvProxyMiddlewareWithParam(localID string, paramName string, resolver E
return
}
- // Build target: map incoming /api/environments/:id/... -> remoteApiUrl/api/environments/<localID>/...
- prefix := "/api/environments/" + envID
- suffix := strings.TrimPrefix(c.Request.URL.Path, prefix)
- if !strings.HasPrefix(suffix, "/") && suffix != "" {
- suffix = "/" + suffix
- }
- target := strings.TrimRight(apiURL, "/") + path.Join("/api/environments/", localID) + suffix
- if qs := c.Request.URL.RawQuery; qs != "" {
- target += "?" + qs
- }
+ target := m.buildTargetURL(c, envID, apiURL)
- if strings.EqualFold(c.GetHeader("Upgrade"), "websocket") || strings.Contains(strings.ToLower(c.GetHeader("Connection")), "upgrade") {
- wsTarget := target
- if strings.HasPrefix(target, "https://") {
- wsTarget = "wss://" + strings.TrimPrefix(target, "https://")
- } else if strings.HasPrefix(target, "http://") {
- wsTarget = "ws://" + strings.TrimPrefix(target, "http://")
- }
-
- hdr := http.Header{}
- if auth := c.GetHeader("Authorization"); auth != "" {
- hdr.Set("Authorization", auth)
- } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {
- hdr.Set("Authorization", "Bearer "+cookieToken)
- }
-
- if hdr.Get("Authorization") == "" {
- if cookieHeader := c.Request.Header.Get("Cookie"); cookieHeader != "" {
- hdr.Set("Cookie", cookieHeader)
- }
- }
-
- if accessToken != nil && *accessToken != "" {
- hdr.Set("X-Arcane-Agent-Token", *accessToken)
- }
-
- if err := wsutil.ProxyHTTP(c.Writer, c.Request, wsTarget, hdr); err != nil {
- slog.Error("websocket proxy failed", "env_id", envID, "target", wsTarget, "err", err)
- }
- c.Abort()
+ if m.isWebSocketRequest(c) {
+ m.handleWebSocket(c, target, accessToken, envID)
return
}
- var bodyReader io.Reader
- if c.Request.Body != nil {
- bodyReader = c.Request.Body
- }
+ m.proxyHTTP(c, target, accessToken)
+ }
+}
- req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, target, bodyReader)
- if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{"success": false, "data": gin.H{"error": "Failed to create proxy request"}})
- c.Abort()
- return
- }
+func (m *EnvironmentMiddleware) extractEnvironmentID(c *gin.Context, paramName string) string {
+ envID := c.Param(paramName)
+ if envID != "" {
+ return envID
+ }
- skip := map[string]struct{}{
- "Host": {},
- "Connection": {},
- "Keep-Alive": {},
- "Proxy-Authenticate": {},
- "Proxy-Authorization": {},
- "Te": {},
- "Trailer": {},
- "Transfer-Encoding": {},
- "Upgrade": {},
- "Content-Length": {},
- "Origin": {},
- "Referer": {},
- "Access-Control-Request-Method": {},
- "Access-Control-Request-Headers": {},
- "Cookie": {},
- }
- for k, vs := range c.Request.Header {
- ck := http.CanonicalHeaderKey(k)
- if _, ok := skip[ck]; ok || ck == "Authorization" {
- continue
- }
- for _, v := range vs {
- req.Header.Add(k, v)
- }
+ const marker = "/environments/"
+ if idx := strings.Index(c.Request.URL.Path, marker); idx >= 0 {
+ rest := c.Request.URL.Path[idx+len(marker):]
+ parts := strings.SplitN(rest, "/", 2)
+ if len(parts) > 0 && parts[0] != "" {
+ return parts[0]
}
+ }
- // Forward Authorization (or promote cookie)
- if auth := c.GetHeader("Authorization"); auth != "" {
- req.Header.Set("Authorization", auth)
- } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {
- req.Header.Set("Authorization", "Bearer "+cookieToken)
- }
+ return ""
+}
- // Forward agent token if provided by resolver
- if accessToken != nil && *accessToken != "" {
- req.Header.Set("X-Arcane-Agent-Token", *accessToken)
- }
+func (m *EnvironmentMiddleware) buildTargetURL(c *gin.Context, envID, apiURL string) string {
+ prefix := "/api/environments/" + envID
+ suffix := strings.TrimPrefix(c.Request.URL.Path, prefix)
+ if !strings.HasPrefix(suffix, "/") && suffix != "" {
+ suffix = "/" + suffix
+ }
- req.Header.Set("X-Forwarded-For", c.ClientIP())
- req.Header.Set("X-Forwarded-Host", c.Request.Host)
+ target := strings.TrimRight(apiURL, "/") + path.Join("/api/environments/", m.localID) + suffix
+ if qs := c.Request.URL.RawQuery; qs != "" {
+ target += "?" + qs
+ }
- client := &http.Client{Timeout: 60 * time.Second}
- resp, err := client.Do(req)
- if err != nil {
- c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": fmt.Sprintf("Proxy request failed: %v", err)}})
- c.Abort()
- return
- }
- defer resp.Body.Close()
-
- hop := map[string]struct{}{
- http.CanonicalHeaderKey("Connection"): {},
- http.CanonicalHeaderKey("Keep-Alive"): {},
- http.CanonicalHeaderKey("Proxy-Authenticate"): {},
- http.CanonicalHeaderKey("Proxy-Authorization"): {},
- http.CanonicalHeaderKey("TE"): {},
- http.CanonicalHeaderKey("Trailers"): {},
- http.CanonicalHeaderKey("Trailer"): {},
- http.CanonicalHeaderKey("Transfer-Encoding"): {},
- http.CanonicalHeaderKey("Upgrade"): {},
- }
- for _, connVal := range resp.Header.Values("Connection") {
- for _, token := range strings.Split(connVal, ",") {
- if t := strings.TrimSpace(token); t != "" {
- hop[http.CanonicalHeaderKey(t)] = struct{}{}
- }
- }
- }
+ return target
+}
- for k, vs := range resp.Header {
- ck := http.CanonicalHeaderKey(k)
- if _, ok := hop[ck]; ok {
- continue
- }
- for _, v := range vs {
- c.Writer.Header().Add(k, v)
- }
- }
+func (m *EnvironmentMiddleware) isWebSocketRequest(c *gin.Context) bool {
+ return strings.EqualFold(c.GetHeader("Upgrade"), "websocket") ||
+ strings.Contains(strings.ToLower(c.GetHeader("Connection")), "upgrade")
+}
- c.Status(resp.StatusCode)
- if c.Request.Method != http.MethodHead {
- _, _ = io.Copy(c.Writer, resp.Body)
+func (m *EnvironmentMiddleware) handleWebSocket(c *gin.Context, target string, accessToken *string, envID string) {
+ wsTarget := m.convertToWebSocketURL(target)
+ hdr := m.buildWebSocketHeaders(c, accessToken)
+
+ if err := wsutil.ProxyHTTP(c.Writer, c.Request, wsTarget, hdr); err != nil {
+ slog.Error("websocket proxy failed", "env_id", envID, "target", wsTarget, "err", err)
+ }
+ c.Abort()
+}
+
+func (m *EnvironmentMiddleware) convertToWebSocketURL(target string) string {
+ if strings.HasPrefix(target, "https://") {
+ return "wss://" + strings.TrimPrefix(target, "https://")
+ }
+ if strings.HasPrefix(target, "http://") {
+ return "ws://" + strings.TrimPrefix(target, "http://")
+ }
+ return target
+}
+
+func (m *EnvironmentMiddleware) buildWebSocketHeaders(c *gin.Context, accessToken *string) http.Header {
+ hdr := http.Header{}
+
+ if auth := c.GetHeader("Authorization"); auth != "" {
+ hdr.Set("Authorization", auth)
+ } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {
+ hdr.Set("Authorization", "Bearer "+cookieToken)
+ }
+
+ if hdr.Get("Authorization") == "" {
+ if cookieHeader := c.Request.Header.Get("Cookie"); cookieHeader != "" {
+ hdr.Set("Cookie", cookieHeader)
}
+ }
+
+ if accessToken != nil && *accessToken != "" {
+ hdr.Set("X-Arcane-Agent-Token", *accessToken)
+ }
+
+ return hdr
+}
+
+func (m *EnvironmentMiddleware) proxyHTTP(c *gin.Context, target string, accessToken *string) {
+ req, err := m.createProxyRequest(c, target, accessToken)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{"success": false, "data": gin.H{"error": "Failed to create proxy request"}})
+ c.Abort()
+ return
+ }
+ resp, err := m.httpClient.Do(req)
+ if err != nil {
+ c.JSON(http.StatusBadGateway, gin.H{"success": false, "data": gin.H{"error": fmt.Sprintf("Proxy request failed: %v", err)}})
c.Abort()
+ return
+ }
+ defer resp.Body.Close()
+
+ m.copyResponseToClient(c, resp)
+ c.Abort()
+}
+
+func (m *EnvironmentMiddleware) createProxyRequest(c *gin.Context, target string, accessToken *string) (*http.Request, error) {
+ var bodyReader io.Reader
+ if c.Request.Body != nil {
+ bodyReader = c.Request.Body
+ }
+
+ req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, target, bodyReader)
+ if err != nil {
+ return nil, err
+ }
+
+ skip := remenv.GetSkipHeaders()
+ remenv.CopyRequestHeaders(c.Request.Header, req.Header, skip)
+ remenv.SetAuthHeader(req, c)
+ remenv.SetAgentToken(req, accessToken)
+ remenv.SetForwardedHeaders(req, c.ClientIP(), c.Request.Host)
+
+ if remenv.NeedsCredentialInjection(target) {
+ if err := remenv.InjectRegistryCredentials(c.Request.Context(), req, m.envService); err != nil {
+ slog.WarnContext(c.Request.Context(), "Failed to inject registry credentials",
+ slog.String("error", err.Error()),
+ slog.String("target", target))
+ }
+ }
+
+ return req, nil
+}
+
+func (m *EnvironmentMiddleware) copyResponseToClient(c *gin.Context, resp *http.Response) {
+ hop := remenv.BuildHopByHopHeaders(resp.Header)
+ remenv.CopyResponseHeaders(resp.Header, c.Writer.Header(), hop)
+
+ c.Status(resp.StatusCode)
+ if c.Request.Method != http.MethodHead {
+ _, _ = io.Copy(c.Writer, resp.Body)
}
}
diff --git a/backend/internal/services/environment_service.go b/backend/internal/services/environment_service.go
index 001bd85eb..1a1780e59 100644
--- a/backend/internal/services/environment_service.go
+++ b/backend/internal/services/environment_service.go
@@ -6,6 +6,7 @@ import (
"errors"
"fmt"
"io"
+ "log/slog"
"net/http"
"net/url"
"path"
@@ -16,6 +17,7 @@ import (
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/models"
+ "github.com/ofkm/arcane-backend/internal/utils"
"github.com/ofkm/arcane-backend/internal/utils/pagination"
"gorm.io/gorm"
)
@@ -322,3 +324,38 @@ func (s *EnvironmentService) BuildRemoteWSTarget(environment *models.Environment
h := s.BuildWSAuthHeadersFromRequest(req, agentToken)
return base.String(), h, nil
}
+
+func (s *EnvironmentService) GetDB() *database.DB {
+ return s.db
+}
+
+func (s *EnvironmentService) GetEnabledRegistryCredentials(ctx context.Context) ([]dto.ContainerRegistryCredential, error) {
+ var registries []models.ContainerRegistry
+ if err := s.db.WithContext(ctx).Where("enabled = ?", true).Find(&registries).Error; err != nil {
+ return nil, fmt.Errorf("failed to get enabled container registries: %w", err)
+ }
+
+ var creds []dto.ContainerRegistryCredential
+ for _, reg := range registries {
+ if !reg.Enabled || reg.Username == "" || reg.Token == "" {
+ continue
+ }
+
+ decryptedToken, err := utils.Decrypt(reg.Token)
+ if err != nil {
+ slog.WarnContext(ctx, "Failed to decrypt registry token",
+ slog.String("registryURL", reg.URL),
+ slog.String("error", err.Error()))
+ continue
+ }
+
+ creds = append(creds, dto.ContainerRegistryCredential{
+ URL: reg.URL,
+ Username: reg.Username,
+ Token: decryptedToken,
+ Enabled: reg.Enabled,
+ })
+ }
+
+ return creds, nil
+}
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index abf45239d..cd41ae21b 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -97,23 +97,31 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, u
return nil
}
-func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user models.User) error {
+func (s *ImageService) PullImage(ctx context.Context, imageName string, progressWriter io.Writer, user models.User, externalCreds []dto.ContainerRegistryCredential) error {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
- slog.Debug("attempting to pull image", slog.String("image", imageName))
+ slog.DebugContext(ctx, "Attempting to pull image",
+ slog.String("image", imageName),
+ slog.Int("externalCredCount", len(externalCreds)))
- pullOptions, err := s.getPullOptionsWithAuth(ctx, imageName)
+ pullOptions, err := s.getPullOptionsWithAuth(ctx, imageName, externalCreds)
if err != nil {
- slog.Warn("failed to get registry authentication for image; proceeding without auth", slog.String("image", imageName), slog.Any("err", err))
+ slog.WarnContext(ctx, "Failed to get registry authentication for image; proceeding without auth",
+ slog.String("image", imageName),
+ slog.String("error", err.Error()))
pullOptions = image.PullOptions{}
}
reader, err := dockerClient.ImagePull(ctx, imageName, pullOptions)
if err != nil {
+ slog.ErrorContext(ctx, "Docker ImagePull failed",
+ slog.String("image", imageName),
+ slog.Bool("hasAuth", pullOptions.RegistryAuth != ""),
+ slog.String("error", err.Error()))
return fmt.Errorf("failed to initiate image pull for %s: %w", imageName, err)
}
defer reader.Close()
@@ -155,15 +163,43 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progress
return nil
}
-func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef string) (image.PullOptions, error) {
+func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef string, externalCreds []dto.ContainerRegistryCredential) (image.PullOptions, error) {
pullOptions := image.PullOptions{}
+ registryHost := s.extractRegistryHost(imageRef)
+
+ if len(externalCreds) > 0 {
+ for _, cred := range externalCreds {
+ if !cred.Enabled || cred.Username == "" || cred.Token == "" {
+ continue
+ }
+
+ credHost := s.normalizeRegistryForComparison(cred.URL)
+ if credHost == s.normalizeRegistryForComparison(registryHost) {
+ authConfig := &registry.AuthConfig{
+ Username: cred.Username,
+ Password: cred.Token,
+ ServerAddress: s.normalizeRegistryURL(cred.URL),
+ }
+
+ authBytes, err := json.Marshal(authConfig)
+ if err != nil {
+ return pullOptions, fmt.Errorf("failed to marshal auth config: %w", err)
+ }
+
+ pullOptions.RegistryAuth = base64.StdEncoding.EncodeToString(authBytes)
+ slog.DebugContext(ctx, "Using external credentials for image pull",
+ slog.String("registry", credHost),
+ slog.String("username", cred.Username))
+ return pullOptions, nil
+ }
+ }
+ }
+
if s.registryService == nil {
return pullOptions, nil
}
- registryHost := s.extractRegistryHost(imageRef)
-
registries, err := s.registryService.GetEnabledRegistries(ctx)
if err != nil {
return pullOptions, fmt.Errorf("failed to get registry credentials: %w", err)
@@ -187,7 +223,10 @@ func (s *ImageService) getPullOptionsWithAuth(ctx context.Context, imageRef stri
return pullOptions, fmt.Errorf("failed to marshal auth config: %w", err)
}
- pullOptions.RegistryAuth = base64.URLEncoding.EncodeToString(authBytes)
+ pullOptions.RegistryAuth = base64.StdEncoding.EncodeToString(authBytes)
+ slog.DebugContext(ctx, "Using database credentials for image pull",
+ slog.String("registry", registryHost),
+ slog.String("username", reg.Username))
break
}
}
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index cca9feec4..74f27b2f7 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -887,20 +887,56 @@ func (s *ImageUpdateService) parseAndGroupImages(imageRefs []string) (map[string
return regRepos, results, images
}
-func (s *ImageUpdateService) buildCredentialMap(ctx context.Context) (map[string]batchCred, []models.ContainerRegistry) {
- enabledRegs, err := s.registryService.GetEnabledRegistries(ctx)
- if err != nil {
- slog.DebugContext(ctx, "Failed to load enabled registries", slog.String("error", err.Error()))
- return map[string]batchCred{}, nil
- }
- credMap := make(map[string]batchCred, len(enabledRegs))
+func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCreds []dto.ContainerRegistryCredential) (map[string]batchCred, []models.ContainerRegistry) {
+ var enabledRegs []models.ContainerRegistry
+ credMap := make(map[string]batchCred)
+
normalizeHost := func(u string) string {
u = strings.TrimSpace(u)
u = strings.TrimPrefix(u, "https://")
u = strings.TrimPrefix(u, "http://")
return strings.TrimSuffix(u, "/")
}
- for _, r := range enabledRegs {
+
+ if len(externalCreds) > 0 {
+ for _, c := range externalCreds {
+ if !c.Enabled || c.Username == "" || c.Token == "" {
+ continue
+ }
+ host := normalizeHost(c.URL)
+ if host == "" {
+ continue
+ }
+ if _, exists := credMap[host]; !exists {
+ credMap[host] = batchCred{username: c.Username, token: c.Token}
+ }
+ encToken, encErr := utils.Encrypt(c.Token)
+ if encErr != nil {
+ slog.WarnContext(ctx, "Failed to encrypt external registry token",
+ slog.String("registryURL", c.URL),
+ slog.String("error", encErr.Error()))
+ continue
+ }
+ enabledRegs = append(enabledRegs, models.ContainerRegistry{
+ URL: c.URL,
+ Username: c.Username,
+ Token: encToken,
+ Enabled: c.Enabled,
+ })
+ }
+ slog.DebugContext(ctx, "Using external credentials for batch check",
+ slog.Int("credentialCount", len(credMap)))
+ return credMap, enabledRegs
+ }
+
+ dbRegs, err := s.registryService.GetEnabledRegistries(ctx)
+ if err != nil {
+ slog.DebugContext(ctx, "Failed to load enabled registries", slog.String("error", err.Error()))
+ return credMap, nil
+ }
+ enabledRegs = dbRegs
+
+ for _, r := range dbRegs {
if r.Username == "" || r.Token == "" {
continue
}
@@ -1063,7 +1099,7 @@ func (s *ImageUpdateService) checkSingleImageInBatch(
}
}
-func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string) (map[string]*dto.ImageUpdateResponse, error) {
+func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string, externalCreds []dto.ContainerRegistryCredential) (map[string]*dto.ImageUpdateResponse, error) {
startBatch := time.Now()
results := make(map[string]*dto.ImageUpdateResponse, len(imageRefs))
if len(imageRefs) == 0 {
@@ -1072,19 +1108,15 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
rc := registry.NewClient()
- // Parse & group
regRepos, initialResults, images := s.parseAndGroupImages(imageRefs)
for k, v := range initialResults {
results[k] = v
}
- // Credentials + enabled registry list (for challenge retries)
- credMap, enabledRegs := s.buildCredentialMap(ctx)
+ credMap, enabledRegs := s.buildCredentialMap(ctx, externalCreds)
- // Registry auth map
regAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)
- // Concurrency
updateScope := s.getUpdateScope()
outCh := make(chan struct {
ref string
@@ -1094,38 +1126,46 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
wg := sync.WaitGroup{}
wg.Add(len(images))
for _, img := range images {
- go func() {
+ go func(bi batchImage) {
defer wg.Done()
- res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, img.parts, updateScope)
- // Persist
- _ = s.saveUpdateResult(ctx, img.ref, res)
+ res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, bi.parts, updateScope)
outCh <- struct {
ref string
res *dto.ImageUpdateResponse
- }{ref: img.ref, res: res}
- }()
+ }{bi.ref, res}
+ }(img)
}
-
wg.Wait()
close(outCh)
- for it := range outCh {
- results[it.ref] = it.res
+ for item := range outCh {
+ results[item.ref] = item.res
+ if err := s.saveUpdateResult(ctx, item.ref, item.res); err != nil {
+ slog.WarnContext(ctx, "Failed to save update result",
+ slog.String("imageRef", item.ref),
+ slog.String("error", err.Error()))
+ }
}
- slog.DebugContext(ctx, "Batch image update check complete",
- slog.Int("count", len(results)),
- slog.Int64("elapsedMs", time.Since(startBatch).Milliseconds()))
+ slog.InfoContext(ctx, "Batch image update check completed",
+ slog.Int("totalImages", len(imageRefs)),
+ slog.Int("successCount", len(results)),
+ slog.Duration("duration", time.Since(startBatch)))
return results, nil
}
-func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int) (map[string]*dto.ImageUpdateResponse, error) {
+func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int, externalCreds []dto.ContainerRegistryCredential) (map[string]*dto.ImageUpdateResponse, error) {
imageRefs, err := s.getAllImageRefs(ctx, limit)
if err != nil {
return nil, fmt.Errorf("failed to get image references: %w", err)
}
- return s.CheckMultipleImages(ctx, imageRefs)
+
+ if len(imageRefs) == 0 {
+ return make(map[string]*dto.ImageUpdateResponse), nil
+ }
+
+ return s.CheckMultipleImages(ctx, imageRefs, externalCreds)
}
func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 751cbc016..6f00e473d 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -613,7 +613,7 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID string
}
for img := range images {
- if err := s.imageService.PullImage(ctx, img, progressWriter, systemUser); err != nil {
+ if err := s.imageService.PullImage(ctx, img, progressWriter, systemUser, nil); err != nil {
return fmt.Errorf("failed to pull image %s: %w", img, err)
}
}
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index 7fcb1a1e1..82bba8e3b 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -170,7 +170,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*dto.Up
continue
}
- if err := s.imageService.PullImage(ctx, p.newRef, io.Discard, systemUser); err != nil {
+ if err := s.imageService.PullImage(ctx, p.newRef, io.Discard, systemUser, nil); err != nil {
item.Status = "failed"
item.Error = err.Error()
out.Failed++
diff --git a/backend/internal/utils/remenv/remenv.go b/backend/internal/utils/remenv/remenv.go
new file mode 100644
index 000000000..8d7cf3fe6
--- /dev/null
+++ b/backend/internal/utils/remenv/remenv.go
@@ -0,0 +1,191 @@
+package remenv
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "log/slog"
+ "net/http"
+ "strconv"
+ "strings"
+
+ "github.com/gin-gonic/gin"
+ "github.com/ofkm/arcane-backend/internal/dto"
+)
+
+type CredentialInjector interface {
+ GetEnabledRegistryCredentials(ctx context.Context) ([]dto.ContainerRegistryCredential, error)
+}
+
+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" {
+ continue
+ }
+ for _, v := range vs {
+ to.Add(k, v)
+ }
+ }
+}
+
+func SetAuthHeader(req *http.Request, c *gin.Context) {
+ if auth := c.GetHeader("Authorization"); auth != "" {
+ req.Header.Set("Authorization", auth)
+ } else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {
+ req.Header.Set("Authorization", "Bearer "+cookieToken)
+ }
+}
+
+func SetAgentToken(req *http.Request, accessToken *string) {
+ if accessToken != nil && *accessToken != "" {
+ req.Header.Set("X-Arcane-Agent-Token", *accessToken)
+ }
+}
+
+func SetForwardedHeaders(req *http.Request, clientIP, host string) {
+ req.Header.Set("X-Forwarded-For", clientIP)
+ req.Header.Set("X-Forwarded-Host", host)
+}
+
+func GetHopByHopHeaders() map[string]struct{} {
+ return map[string]struct{}{
+ http.CanonicalHeaderKey("Connection"): {},
+ http.CanonicalHeaderKey("Keep-Alive"): {},
+ http.CanonicalHeaderKey("Proxy-Authenticate"): {},
+ http.CanonicalHeaderKey("Proxy-Authorization"): {},
+ http.CanonicalHeaderKey("TE"): {},
+ http.CanonicalHeaderKey("Trailers"): {},
+ http.CanonicalHeaderKey("Trailer"): {},
+ http.CanonicalHeaderKey("Transfer-Encoding"): {},
+ http.CanonicalHeaderKey("Upgrade"): {},
+ }
+}
+
+func BuildHopByHopHeaders(respHeader http.Header) map[string]struct{} {
+ hop := GetHopByHopHeaders()
+
+ for _, connVal := range respHeader.Values("Connection") {
+ for _, token := range strings.Split(connVal, ",") {
+ if t := strings.TrimSpace(token); t != "" {
+ hop[http.CanonicalHeaderKey(t)] = struct{}{}
+ }
+ }
+ }
+
+ return hop
+}
+
+func CopyResponseHeaders(from http.Header, to http.Header, hop map[string]struct{}) {
+ for k, vs := range from {
+ ck := http.CanonicalHeaderKey(k)
+ if _, ok := hop[ck]; ok {
+ continue
+ }
+ for _, v := range vs {
+ to.Add(k, v)
+ }
+ }
+}
+
+func NeedsCredentialInjection(target string) bool {
+ return strings.Contains(target, "/image-updates/check") ||
+ strings.Contains(target, "/images/pull")
+}
+
+func InjectRegistryCredentials(ctx context.Context, req *http.Request, injector CredentialInjector) error {
+ if injector == nil || req.Method != http.MethodPost {
+ return nil
+ }
+
+ bodyBytes, err := io.ReadAll(req.Body)
+ if err != nil {
+ return fmt.Errorf("failed to read request body: %w", err)
+ }
+ req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+ var pullReq dto.ImagePullDto
+ if err := json.Unmarshal(bodyBytes, &pullReq); err != nil {
+ return injectBatchUpdateCredentials(ctx, bodyBytes, req, injector)
+ }
+
+ return injectImagePullCredentials(ctx, pullReq, req, injector)
+}
+
+func injectBatchUpdateCredentials(ctx context.Context, bodyBytes []byte, req *http.Request, injector CredentialInjector) error {
+ var batchReq dto.BatchImageUpdateRequest
+
+ if err := json.Unmarshal(bodyBytes, &batchReq); err != nil {
+ return nil //nolint:nilerr
+ }
+
+ if len(batchReq.Credentials) > 0 {
+ return nil
+ }
+
+ creds, err := injector.GetEnabledRegistryCredentials(ctx)
+ if err != nil {
+ return fmt.Errorf("failed to load registry credentials: %w", err)
+ }
+
+ if len(creds) == 0 {
+ return nil
+ }
+
+ batchReq.Credentials = creds
+ modifiedBody, err := json.Marshal(batchReq)
+ if err != nil {
+ return fmt.Errorf("failed to marshal modified request: %w", err)
+ }
+
+ updateRequestBody(req, modifiedBody)
+ slog.DebugContext(ctx, "Injected registry credentials into batch update request",
+ slog.Int("credentialCount", len(creds)))
+
+ return nil
+}
+
+func injectImagePullCredentials(ctx context.Context, pullReq dto.ImagePullDto, req *http.Request, injector CredentialInjector) error {
+ if len(pullReq.Credentials) > 0 {
+ return nil
+ }
+
+ creds, err := injector.GetEnabledRegistryCredentials(ctx)
+ if err != nil {
+ return err
+ }
+
+ if len(creds) == 0 {
+ return nil
+ }
+
+ pullReq.Credentials = creds
+ modifiedBody, err := json.Marshal(pullReq)
+ if err != nil {
+ return fmt.Errorf("failed to marshal modified request: %w", err)
+ }
+
+ updateRequestBody(req, modifiedBody)
+ slog.DebugContext(ctx, "Injected registry credentials into image pull request",
+ slog.Int("credentialCount", len(creds)),
+ slog.String("imageName", pullReq.ImageName))
+
+ return nil
+}
+
+func updateRequestBody(req *http.Request, body []byte) {
+ req.Body = io.NopCloser(bytes.NewBuffer(body))
+ req.ContentLength = int64(len(body))
+ req.Header.Set("Content-Length", strconv.Itoa(len(body)))
+}
+
+func GetSkipHeaders() map[string]struct{} {
+ return map[string]struct{}{
+ "Host": {}, "Connection": {}, "Keep-Alive": {}, "Proxy-Authenticate": {},
+ "Proxy-Authorization": {}, "Te": {}, "Trailer": {}, "Transfer-Encoding": {},
+ "Upgrade": {}, "Content-Length": {}, "Origin": {}, "Referer": {},
+ "Access-Control-Request-Method": {}, "Access-Control-Request-Headers": {}, "Cookie": {},
+ }
+}
diff --git a/frontend/src/lib/components/sheets/image-pull-sheet.svelte b/frontend/src/lib/components/sheets/image-pull-sheet.svelte
index df1972ebe..282b1d510 100644
--- a/frontend/src/lib/components/sheets/image-pull-sheet.svelte
+++ b/frontend/src/lib/components/sheets/image-pull-sheet.svelte
@@ -104,12 +104,15 @@
if (!response.ok || !response.body) {
const errorData = await response.json().catch(() => ({
- error: m.images_pull_server_error()
+ data: { message: m.images_pull_server_error() }
}));
+
const errorMessage =
- typeof errorData.error === 'string'
- ? errorData.error
- : errorData.message || `${m.images_pull_server_error()}: HTTP ${response.status}`;
+ errorData.data?.message ||
+ errorData.error ||
+ errorData.message ||
+ `${m.images_pull_server_error()}: HTTP ${response.status}`;
+
throw new Error(errorMessage);
}