Skip to content

Modern Docker Management, Designed for Everyone

fix: use docker daemon backed trust store for registry operations (#2042)

Kyle Mendell8b7e6f81a1a4
diff --git a/backend/go.mod b/backend/go.mod
index c649c2e36..bd9dee1f9 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -13,7 +13,6 @@ require (
github.com/depot/depot-go v0.5.2
github.com/docker/cli v29.2.1+incompatible
github.com/docker/compose/v5 v5.1.0
- github.com/docker/distribution v2.8.3+incompatible
github.com/docker/docker v28.5.2+incompatible
github.com/fsnotify/fsnotify v1.9.0
github.com/getarcaneapp/arcane/types v1.15.3
@@ -37,6 +36,7 @@ require (
github.com/moby/moby/client v0.3.0
github.com/moby/patternmatcher v0.6.0
github.com/nicholas-fedor/shoutrrr v0.13.2
+ github.com/opencontainers/go-digest v1.0.0
github.com/opencontainers/image-spec v1.1.1
github.com/orandin/slog-gorm v1.4.0
github.com/robfig/cron/v3 v3.0.1
@@ -161,7 +161,6 @@ require (
github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect
github.com/morikuni/aec v1.1.0 // indirect
github.com/ncruces/go-strftime v0.1.9 // indirect
- github.com/opencontainers/go-digest v1.0.0 // indirect
github.com/pelletier/go-toml v1.9.5 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/pjbgf/sha1cd v0.3.2 // indirect
diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.go
index a426ce004..a6ed5ae26 100644
--- a/backend/internal/bootstrap/services_bootstrap.go
+++ b/backend/internal/bootstrap/services_bootstrap.go
@@ -65,7 +65,9 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Config
dockerClient := services.NewDockerClientService(db, cfg, svcs.Settings)
svcs.Docker = dockerClient
svcs.User = services.NewUserService(db)
- svcs.ContainerRegistry = services.NewContainerRegistryService(db)
+ svcs.ContainerRegistry = services.NewContainerRegistryService(db, func(ctx context.Context) (services.RegistryDaemonClient, error) {
+ return dockerClient.GetClient(ctx)
+ })
svcs.Notification = services.NewNotificationService(db, cfg)
svcs.Apprise = services.NewAppriseService(db, cfg)
svcs.Vulnerability = services.NewVulnerabilityService(db, svcs.Docker, svcs.Event, svcs.Settings, svcs.Notification)
diff --git a/backend/internal/huma/handlers/container_registries.go b/backend/internal/huma/handlers/container_registries.go
index f9cd56c6c..2f21276f8 100644
--- a/backend/internal/huma/handlers/container_registries.go
+++ b/backend/internal/huma/handlers/container_registries.go
@@ -2,8 +2,8 @@ package handlers
import (
"context"
- "fmt"
"log/slog"
+ "strings"
"github.com/danielgtaylor/huma/v2"
"github.com/getarcaneapp/arcane/backend/internal/common"
@@ -11,7 +11,6 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/services"
"github.com/getarcaneapp/arcane/backend/internal/utils/crypto"
"github.com/getarcaneapp/arcane/backend/internal/utils/mapper"
- "github.com/getarcaneapp/arcane/backend/internal/utils/registry"
"github.com/getarcaneapp/arcane/types/base"
"github.com/getarcaneapp/arcane/types/containerregistry"
)
@@ -364,16 +363,20 @@ func (h *ContainerRegistryHandler) TestRegistry(ctx context.Context, input *Test
return nil, huma.Error500InternalServerError((&common.TokenDecryptionError{Err: err}).Error())
}
- testResult, testErr := h.performRegistryTest(ctx, reg, decryptedToken)
- if testErr != nil {
- return nil, huma.Error400BadRequest((&common.RegistryTestError{Err: testErr}).Error())
+ if err := h.registryService.TestRegistry(ctx, reg.URL, reg.Username, decryptedToken); err != nil {
+ return nil, huma.Error400BadRequest((&common.RegistryTestError{Err: err}).Error())
+ }
+
+ msg := "Authentication succeeded"
+ if strings.TrimSpace(reg.Username) == "" && strings.TrimSpace(decryptedToken) == "" {
+ msg = "Registry saved (no credentials to test)"
}
return &TestContainerRegistryOutput{
Body: base.ApiResponse[base.MessageResponse]{
Success: true,
Data: base.MessageResponse{
- Message: testResult["message"].(string),
+ Message: msg,
},
},
}, nil
@@ -408,32 +411,6 @@ func (h *ContainerRegistryHandler) SyncRegistries(ctx context.Context, input *Sy
// Helper Methods
// ============================================================================
-func (h *ContainerRegistryHandler) performRegistryTest(ctx context.Context, registryModel *models.ContainerRegistry, decryptedToken string) (map[string]any, error) {
- var creds *registry.Credentials
- if registryModel.Username != "" && decryptedToken != "" {
- creds = &registry.Credentials{
- Username: registryModel.Username,
- Token: decryptedToken,
- }
- }
-
- testResult, err := registry.TestRegistryConnection(ctx, registryModel.URL, creds)
- if err != nil {
- return nil, err
- }
-
- if !testResult.AuthSuccess {
- if len(testResult.Errors) > 0 {
- return nil, fmt.Errorf("%s", testResult.Errors[0])
- }
- return nil, fmt.Errorf("invalid credentials")
- }
-
- return map[string]any{
- "message": "Authentication succeeded",
- }, nil
-}
-
func (h *ContainerRegistryHandler) triggerRemoteRegistrySync(ctx context.Context, reason string) { //nolint:contextcheck // intentionally spawns background sync
if h.environmentService == nil {
return
diff --git a/backend/internal/services/build_service_test.go b/backend/internal/services/build_service_test.go
index 8a5057e96..b870fe7d9 100644
--- a/backend/internal/services/build_service_test.go
+++ b/backend/internal/services/build_service_test.go
@@ -22,7 +22,7 @@ func TestBuildService_GetRegistryAuthForHost_UsesDatabaseCredentials(t *testing.
_, db := setupImageServiceAuthTest(t)
createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
- svc := &BuildService{registryService: NewContainerRegistryService(db)}
+ svc := &BuildService{registryService: NewContainerRegistryService(db, nil)}
auth, err := svc.GetRegistryAuthForHost(context.Background(), "registry-1.docker.io")
require.NoError(t, err)
@@ -38,7 +38,7 @@ func TestBuildService_GetRegistryAuthForImage_UsesHostLookup(t *testing.T) {
_, db := setupImageServiceAuthTest(t)
createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", "gh-token")
- svc := &BuildService{registryService: NewContainerRegistryService(db)}
+ svc := &BuildService{registryService: NewContainerRegistryService(db, nil)}
auth, err := svc.GetRegistryAuthForImage(context.Background(), "ghcr.io/getarcaneapp/arcane:latest")
require.NoError(t, err)
@@ -54,7 +54,7 @@ func TestBuildService_GetAllRegistryAuthConfigs_UsesDatabaseCredentials(t *testi
_, db := setupImageServiceAuthTest(t)
createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
- svc := &BuildService{registryService: NewContainerRegistryService(db)}
+ svc := &BuildService{registryService: NewContainerRegistryService(db, nil)}
authConfigs, err := svc.GetAllRegistryAuthConfigs(context.Background())
require.NoError(t, err)
diff --git a/backend/internal/services/container_registry_service.go b/backend/internal/services/container_registry_service.go
index 399757c2e..78ec013c4 100644
--- a/backend/internal/services/container_registry_service.go
+++ b/backend/internal/services/container_registry_service.go
@@ -2,15 +2,14 @@ package services
import (
"context"
- "encoding/json"
"errors"
"fmt"
"log/slog"
- "net/http"
"strings"
"sync"
"time"
+ cerrdefs "github.com/containerd/errdefs"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
"github.com/getarcaneapp/arcane/backend/internal/utils"
@@ -21,41 +20,47 @@ import (
utilsregistry "github.com/getarcaneapp/arcane/backend/internal/utils/registry"
"github.com/getarcaneapp/arcane/types/containerregistry"
dockerregistry "github.com/moby/moby/api/types/registry"
+ "github.com/moby/moby/client"
ref "go.podman.io/image/v5/docker/reference"
)
const (
- registryCheckTimeout = 10 * time.Second
- registryCacheTTL = 30 * time.Minute
+ registryCacheTTL = 30 * time.Minute
)
-func getHeaderCaseInsensitive(h http.Header, key string) string {
- for k, v := range h {
- if strings.EqualFold(k, key) && len(v) > 0 {
- return v[0]
- }
- }
- return ""
+type RegistryDaemonClient interface {
+ RegistryLogin(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error)
+ DistributionInspect(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error)
}
-type ContainerRegistryService struct {
- db *database.DB
- httpClient *http.Client
- cache map[string]*cache.Cache[string] // imageRef -> digest cache
- cacheMu sync.RWMutex
+type registryDaemonGetter func(context.Context) (RegistryDaemonClient, error)
+
+type registryDigestResult struct {
+ Digest string
+ AuthMethod string
+ AuthUsername string
+ AuthRegistry string
+ UsedCredential bool
}
-func NewContainerRegistryService(db *database.DB) *ContainerRegistryService {
- transport := http.DefaultTransport.(*http.Transport).Clone()
- transport.Proxy = http.ProxyFromEnvironment
+type resolvedRegistryCredential struct {
+ Username string
+ Token string
+ ServerAddress string
+}
+
+type ContainerRegistryService struct {
+ db *database.DB
+ dockerClient registryDaemonGetter
+ cache map[string]*cache.Cache[string] // imageRef -> digest cache
+ cacheMu sync.RWMutex
+}
+func NewContainerRegistryService(db *database.DB, dockerClient registryDaemonGetter) *ContainerRegistryService {
return &ContainerRegistryService{
- db: db,
- httpClient: &http.Client{
- Timeout: registryCheckTimeout,
- Transport: transport,
- },
- cache: make(map[string]*cache.Cache[string]),
+ db: db,
+ dockerClient: dockerClient,
+ cache: make(map[string]*cache.Cache[string]),
}
}
@@ -275,16 +280,39 @@ func (s *ContainerRegistryService) GetAllRegistryAuthConfigs(ctx context.Context
return authConfigs, nil
}
+func (s *ContainerRegistryService) TestRegistry(ctx context.Context, registryURL, username, token string) error {
+ if strings.TrimSpace(username) == "" && strings.TrimSpace(token) == "" {
+ // No credentials configured — skip the credential test.
+ return nil
+ }
+
+ dockerClient, err := s.getDockerClientInternal(ctx)
+ if err != nil {
+ return err
+ }
+
+ _, err = dockerClient.RegistryLogin(ctx, client.RegistryLoginOptions{
+ Username: strings.TrimSpace(username),
+ Password: strings.TrimSpace(token),
+ ServerAddress: normalizeRegistryServerAddressInternal(registryURL),
+ })
+ if err != nil {
+ return fmt.Errorf("registry login failed: %w", err)
+ }
+
+ return nil
+}
+
// GetImageDigest fetches the current digest for an image:tag from the registry
// This is used for digest-based update detection for non-semver tags
func (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRef string) (string, error) {
- repository, tag := parseImageReference(imageRef)
- if repository == "" || tag == "" {
- return "", fmt.Errorf("invalid image reference: %s", imageRef)
+ normalizedRef, _, err := normalizeImageReferenceForDistributionInternal(imageRef)
+ if err != nil {
+ return "", err
}
// Build a cache key from the full image reference
- cacheKey := fmt.Sprintf("%s:%s", repository, tag)
+ cacheKey := normalizedRef
// Get or create a cache for this specific image reference
s.cacheMu.RLock()
@@ -301,7 +329,12 @@ func (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRef
}
digest, err := imageCache.GetOrFetch(ctx, func(ctx context.Context) (string, error) {
- return s.fetchDigestFromRegistry(ctx, repository, tag)
+ // Pass the original imageRef; inspectImageDigestInternal normalizes internally.
+ result, fetchErr := s.inspectImageDigestInternal(ctx, imageRef, nil)
+ if fetchErr != nil {
+ return "", fetchErr
+ }
+ return result.Digest, nil
})
var staleErr *cache.ErrStale
@@ -312,157 +345,154 @@ func (s *ContainerRegistryService) GetImageDigest(ctx context.Context, imageRef
return digest, nil
}
-// fetchDigestFromRegistry queries the Docker registry API for the image digest
-func (s *ContainerRegistryService) fetchDigestFromRegistry(ctx context.Context, repository, tag string) (string, error) {
- registryURL, repoPath := parseRegistryAndRepo(repository)
- manifestURL := fmt.Sprintf("%s/v2/%s/manifests/%s", registryURL, repoPath, tag)
-
- reqCtx, cancel := context.WithTimeout(ctx, registryCheckTimeout)
- defer cancel()
-
- req, err := http.NewRequestWithContext(reqCtx, http.MethodHead, manifestURL, nil)
+func (s *ContainerRegistryService) inspectImageDigestInternal(ctx context.Context, imageRef string, externalCreds []containerregistry.Credential) (*registryDigestResult, error) {
+ normalizedRef, registryHost, err := normalizeImageReferenceForDistributionInternal(imageRef)
if err != nil {
- return "", fmt.Errorf("create registry request: %w", err)
- }
-
- req.Header.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.list.v2+json")
-
- // Try to find stored credentials for this registry
- creds := s.findCredentialsForRegistry(ctx, registryURL)
- if creds != nil {
- req.SetBasicAuth(creds.Username, creds.Token)
+ return nil, err
}
- resp, err := s.httpClient.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint
+ dockerClient, err := s.getDockerClientInternal(ctx)
if err != nil {
- return "", fmt.Errorf("registry request failed: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode == http.StatusUnauthorized {
- return s.fetchWithTokenAuth(ctx, repository, tag, getHeaderCaseInsensitive(resp.Header, "WWW-Authenticate"), creds)
+ return nil, err
}
- if resp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("registry returned status %d", resp.StatusCode)
+ inspectResult, err := dockerClient.DistributionInspect(ctx, normalizedRef, client.DistributionInspectOptions{})
+ if err == nil {
+ digest := strings.TrimSpace(string(inspectResult.Descriptor.Digest))
+ if digest == "" {
+ return nil, fmt.Errorf("distribution inspect returned empty digest for %s", normalizedRef)
+ }
+ return &registryDigestResult{
+ Digest: digest,
+ AuthMethod: "anonymous",
+ AuthRegistry: registryHost,
+ }, nil
}
-
- digest := resp.Header.Get("Docker-Content-Digest")
- if digest == "" {
- digest = strings.Trim(resp.Header.Get("Etag"), "\"")
+ if !isUnauthorizedRegistryErrorInternal(err) {
+ return &registryDigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost},
+ fmt.Errorf("distribution inspect failed for %s: %w", normalizedRef, err)
}
- if digest == "" {
- return "", fmt.Errorf("no digest found in registry response")
+ credentials, credErr := s.getMatchingRegistryCredentialsInternal(ctx, registryHost, externalCreds)
+ if credErr != nil {
+ return &registryDigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost}, credErr
}
- return digest, nil
-}
-
-// findCredentialsForRegistry finds stored credentials for a registry URL
-func (s *ContainerRegistryService) findCredentialsForRegistry(ctx context.Context, registryURL string) *struct{ Username, Token string } {
- registries, err := s.GetEnabledRegistries(ctx)
- if err != nil {
- return nil
- }
+ lastErr := err
+ var lastCred resolvedRegistryCredential
+ for _, credential := range credentials {
+ lastCred = credential
+ authHeader, encodeErr := utilsregistry.EncodeAuthHeader(credential.Username, credential.Token, credential.ServerAddress)
+ if encodeErr != nil {
+ return nil, fmt.Errorf("encode registry auth header for %s: %w", registryHost, encodeErr)
+ }
- for _, reg := range registries {
- if utilsregistry.IsRegistryMatch(reg.URL, registryURL) {
- token, err := crypto.Decrypt(reg.Token)
- if err != nil {
- slog.WarnContext(ctx, "Failed to decrypt registry token", "registry", reg.URL, "error", err)
- continue
+ inspectResult, err = dockerClient.DistributionInspect(ctx, normalizedRef, client.DistributionInspectOptions{
+ EncodedRegistryAuth: authHeader,
+ })
+ if err == nil {
+ digest := strings.TrimSpace(string(inspectResult.Descriptor.Digest))
+ if digest == "" {
+ return nil, fmt.Errorf("distribution inspect returned empty digest for %s", normalizedRef)
}
- return &struct{ Username, Token string }{Username: reg.Username, Token: token}
+ return &registryDigestResult{
+ Digest: digest,
+ AuthMethod: "credential",
+ AuthUsername: credential.Username,
+ AuthRegistry: registryHost,
+ UsedCredential: true,
+ }, nil
+ }
+ lastErr = err
+ if !isUnauthorizedRegistryErrorInternal(err) {
+ return &registryDigestResult{
+ AuthMethod: "credential",
+ AuthUsername: credential.Username,
+ AuthRegistry: registryHost,
+ UsedCredential: true,
+ }, fmt.Errorf("distribution inspect failed for %s with credentials: %w", normalizedRef, err)
}
}
- return nil
+ partial := &registryDigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost}
+ if lastCred.Username != "" {
+ partial.AuthMethod = "credential"
+ partial.AuthUsername = lastCred.Username
+ partial.UsedCredential = true
+ }
+ return partial, fmt.Errorf("distribution inspect failed for %s: %w", normalizedRef, lastErr)
}
-// fetchWithTokenAuth handles token-based authentication for registries
-func (s *ContainerRegistryService) fetchWithTokenAuth(ctx context.Context, repository, tag, wwwAuth string, creds *struct{ Username, Token string }) (string, error) {
- realm, service := parseWWWAuth(wwwAuth)
- if realm == "" {
- return "", fmt.Errorf("no auth realm found")
+func (s *ContainerRegistryService) getDockerClientInternal(ctx context.Context) (RegistryDaemonClient, error) {
+ if s.dockerClient == nil {
+ return nil, errors.New("docker client unavailable")
}
- registryURL, repoPath := parseRegistryAndRepo(repository)
-
- tokenURL := fmt.Sprintf("%s?service=%s&scope=repository:%s:pull", realm, service, repoPath)
-
- reqCtx, cancel := context.WithTimeout(ctx, registryCheckTimeout)
- defer cancel()
-
- tokenReq, err := http.NewRequestWithContext(reqCtx, http.MethodGet, tokenURL, nil)
+ dockerClient, err := s.dockerClient(ctx)
if err != nil {
- return "", fmt.Errorf("create token request: %w", err)
+ return nil, fmt.Errorf("failed to get docker client: %w", err)
}
-
- if creds != nil {
- tokenReq.SetBasicAuth(creds.Username, creds.Token)
+ if dockerClient == nil {
+ return nil, errors.New("docker client unavailable")
}
- tokenResp, err := s.httpClient.Do(tokenReq) //nolint:gosec // intentional request to auth realm provided by registry challenge
- if err != nil {
- return "", fmt.Errorf("token request failed: %w", err)
- }
- defer func() { _ = tokenResp.Body.Close() }()
-
- if tokenResp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("token request returned status %d", tokenResp.StatusCode)
- }
+ return dockerClient, nil
+}
- var tokenData struct {
- Token string `json:"token"`
- Legacy string `json:"access_token"` //nolint:gosec // JSON compatibility with registry token response schema
- }
- if err := json.NewDecoder(tokenResp.Body).Decode(&tokenData); err != nil {
- return "", fmt.Errorf("decode token response: %w", err)
- }
+func (s *ContainerRegistryService) getMatchingRegistryCredentialsInternal(ctx context.Context, registryHost string, externalCreds []containerregistry.Credential) ([]resolvedRegistryCredential, error) {
+ if len(externalCreds) > 0 {
+ credentials := make([]resolvedRegistryCredential, 0, len(externalCreds))
+ for _, cred := range externalCreds {
+ if !cred.Enabled || strings.TrimSpace(cred.Username) == "" || strings.TrimSpace(cred.Token) == "" {
+ continue
+ }
+ if !utilsregistry.IsRegistryMatch(cred.URL, registryHost) {
+ continue
+ }
- token := tokenData.Token
- if token == "" {
- token = tokenData.Legacy
- }
- if token == "" {
- return "", fmt.Errorf("no token in response")
+ credentials = append(credentials, resolvedRegistryCredential{
+ Username: strings.TrimSpace(cred.Username),
+ Token: strings.TrimSpace(cred.Token),
+ ServerAddress: normalizeRegistryServerAddressInternal(cred.URL),
+ })
+ }
+ return credentials, nil
}
- // Retry with token
- manifestURL := fmt.Sprintf("%s/v2/%s/manifests/%s", registryURL, repoPath, tag)
-
- reqCtx2, cancel2 := context.WithTimeout(ctx, registryCheckTimeout)
- defer cancel2()
-
- req, err := http.NewRequestWithContext(reqCtx2, http.MethodHead, manifestURL, nil)
+ registries, err := s.GetEnabledRegistries(ctx)
if err != nil {
- return "", fmt.Errorf("create authenticated request: %w", err)
+ return nil, fmt.Errorf("failed to load enabled registries: %w", err)
}
- req.Header.Set("Authorization", "Bearer "+token)
- req.Header.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.list.v2+json")
-
- resp, err := s.httpClient.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint
- if err != nil {
- return "", fmt.Errorf("authenticated request failed: %w", err)
- }
- defer func() { _ = resp.Body.Close() }()
+ credentials := make([]resolvedRegistryCredential, 0, len(registries))
+ for _, reg := range registries {
+ if !utilsregistry.IsRegistryMatch(reg.URL, registryHost) {
+ continue
+ }
- if resp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("authenticated request returned status %d", resp.StatusCode)
- }
+ username := strings.TrimSpace(reg.Username)
+ if username == "" || reg.Token == "" {
+ continue
+ }
- digest := resp.Header.Get("Docker-Content-Digest")
- if digest == "" {
- digest = strings.Trim(resp.Header.Get("Etag"), "\"")
- }
+ token, decryptErr := crypto.Decrypt(reg.Token)
+ if decryptErr != nil {
+ slog.WarnContext(ctx, "failed to decrypt registry token", "registry", reg.URL, "error", decryptErr)
+ continue
+ }
+ token = strings.TrimSpace(token)
+ if token == "" {
+ continue
+ }
- if digest == "" {
- return "", fmt.Errorf("no digest found in authenticated response")
+ credentials = append(credentials, resolvedRegistryCredential{
+ Username: username,
+ Token: token,
+ ServerAddress: normalizeRegistryServerAddressInternal(reg.URL),
+ })
}
- return digest, nil
+ return credentials, nil
}
// SyncRegistries syncs registries from a manager to this agent instance
@@ -578,45 +608,67 @@ func (s *ContainerRegistryService) deleteUnsyncedInternal(ctx context.Context, e
return nil
}
-// parseImageReference splits an image reference into repository and tag using distribution/reference
-func parseImageReference(imageRef string) (repository, tag string) {
- named, err := ref.ParseNormalizedNamed(imageRef)
+func normalizeImageReferenceForDistributionInternal(imageRef string) (string, string, error) {
+ named, err := ref.ParseNormalizedNamed(strings.TrimSpace(imageRef))
if err != nil {
- return imageRef, "latest"
+ return "", "", fmt.Errorf("invalid image reference %q: %w", imageRef, err)
}
- tagged, ok := named.(ref.Tagged)
- if ok {
+ if _, ok := named.(ref.Digested); ok {
+ return "", "", fmt.Errorf("digest-pinned references are not supported for distribution inspect: %q", imageRef)
+ }
+
+ registryHost := utilsregistry.NormalizeRegistryForComparison(ref.Domain(named))
+ repository := ref.Path(named)
+
+ tag := "latest"
+ if tagged, ok := named.(ref.NamedTagged); ok {
tag = tagged.Tag()
- } else {
- tag = "latest"
}
- return named.Name(), tag
+ return registryHost + "/" + repository + ":" + tag, registryHost, nil
}
-// parseRegistryAndRepo splits a repository into registry URL and repo path using distribution/reference
-func parseRegistryAndRepo(repository string) (registryURL, repoPath string) {
- named, err := ref.ParseNormalizedNamed(repository)
- if err != nil {
- return "https://" + utilsregistry.DefaultRegistry, "library/" + repository
+func normalizeRegistryServerAddressInternal(registryURL string) string {
+ normalizedHost := strings.TrimSpace(utilsregistry.NormalizeRegistryForComparison(registryURL))
+ if normalizedHost == "" {
+ return ""
}
- domain := ref.Domain(named)
- repoPath = ref.Path(named)
-
- registryURL, err = utilsregistry.GetRegistryAddress(named.Name())
- if err != nil {
- registryURL = "https://" + domain
- } else {
- registryURL = "https://" + registryURL
+ if normalizedHost == "docker.io" {
+ return utilsregistry.NormalizeRegistryURL(registryURL)
}
- return registryURL, repoPath
+ return normalizedHost
}
-// parseWWWAuth parses the WWW-Authenticate header using the registry client
-func parseWWWAuth(header string) (realm, service string) {
- c := utilsregistry.NewClient()
- return c.ParseAuthChallenge(header)
+func isUnauthorizedRegistryErrorInternal(err error) bool {
+ if err == nil {
+ return false
+ }
+
+ // Prefer structured error type check from the Docker SDK / containerd.
+ if cerrdefs.IsUnauthorized(err) || cerrdefs.IsPermissionDenied(err) {
+ return true
+ }
+
+ // Fallback: some Docker daemon versions return plain-text errors without
+ // a typed wrapper. These known substrings cover Docker Hub, GHCR, and
+ // other common OCI registries as of Docker Engine 27.x.
+ errLower := strings.ToLower(err.Error())
+ indicators := []string{
+ "unauthorized",
+ "authentication required",
+ "no basic auth credentials",
+ "access denied",
+ "incorrect username or password",
+ }
+
+ for _, indicator := range indicators {
+ if strings.Contains(errLower, indicator) {
+ return true
+ }
+ }
+
+ return false
}
diff --git a/backend/internal/services/container_registry_service_test.go b/backend/internal/services/container_registry_service_test.go
index 9ca07760e..a38c0e2bb 100644
--- a/backend/internal/services/container_registry_service_test.go
+++ b/backend/internal/services/container_registry_service_test.go
@@ -2,18 +2,42 @@ package services
import (
"context"
+ "errors"
"testing"
+ dockerregistry "github.com/moby/moby/api/types/registry"
+ "github.com/moby/moby/client"
+ "github.com/opencontainers/go-digest"
+ ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
+type fakeRegistryDaemonClient struct {
+ registryLoginFn func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error)
+ distributionInspectFn func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error)
+}
+
+func (f *fakeRegistryDaemonClient) RegistryLogin(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
+ if f.registryLoginFn == nil {
+ return client.RegistryLoginResult{}, nil
+ }
+ return f.registryLoginFn(ctx, options)
+}
+
+func (f *fakeRegistryDaemonClient) DistributionInspect(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
+ if f.distributionInspectFn == nil {
+ return client.DistributionInspectResult{}, nil
+ }
+ return f.distributionInspectFn(ctx, imageRef, options)
+}
+
func TestContainerRegistryService_GetAllRegistryAuthConfigs_NormalizesHosts(t *testing.T) {
_, db := setupImageServiceAuthTest(t)
createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
createTestPullRegistry(t, db, "https://GHCR.IO/", "gh-user", "gh-token")
- svc := NewContainerRegistryService(db)
+ svc := NewContainerRegistryService(db, nil)
authConfigs, err := svc.GetAllRegistryAuthConfigs(context.Background())
require.NoError(t, err)
require.NotNil(t, authConfigs)
@@ -40,7 +64,7 @@ func TestContainerRegistryService_GetAllRegistryAuthConfigs_SkipsInvalidEntries(
createTestPullRegistry(t, db, "https://ghcr.io", "gh-user", " ")
createTestPullRegistry(t, db, "https://registry.example.com", "example-user", "example-token")
- svc := NewContainerRegistryService(db)
+ svc := NewContainerRegistryService(db, nil)
authConfigs, err := svc.GetAllRegistryAuthConfigs(context.Background())
require.NoError(t, err)
require.NotNil(t, authConfigs)
@@ -54,3 +78,115 @@ func TestContainerRegistryService_GetAllRegistryAuthConfigs_SkipsInvalidEntries(
assert.Equal(t, "example-token", exampleCfg.Password)
assert.Equal(t, "registry.example.com", exampleCfg.ServerAddress)
}
+
+func TestContainerRegistryService_TestRegistry_UsesDockerDaemon(t *testing.T) {
+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
+ return &fakeRegistryDaemonClient{
+ registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
+ assert.Equal(t, "user", options.Username)
+ assert.Equal(t, "token", options.Password)
+ assert.Equal(t, "registry.example.com:5443", options.ServerAddress)
+ return client.RegistryLoginResult{}, nil
+ },
+ }, nil
+ })
+
+ err := svc.TestRegistry(context.Background(), "https://registry.example.com:5443", "user", "token")
+ require.NoError(t, err)
+}
+
+func TestContainerRegistryService_TestRegistry_PropagatesDaemonError(t *testing.T) {
+ expectedErr := errors.New("tls: failed to verify certificate: x509: certificate signed by unknown authority")
+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
+ return &fakeRegistryDaemonClient{
+ registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
+ return client.RegistryLoginResult{}, expectedErr
+ },
+ }, nil
+ })
+
+ err := svc.TestRegistry(context.Background(), "registry.example.com", "user", "token")
+ require.Error(t, err)
+ assert.ErrorIs(t, err, expectedErr)
+}
+
+func TestContainerRegistryService_TestRegistry_SkipsLoginForEmptyCredentials(t *testing.T) {
+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
+ return &fakeRegistryDaemonClient{
+ registryLoginFn: func(ctx context.Context, options client.RegistryLoginOptions) (client.RegistryLoginResult, error) {
+ t.Fatal("RegistryLogin should not be called with empty credentials")
+ return client.RegistryLoginResult{}, nil
+ },
+ }, nil
+ })
+
+ err := svc.TestRegistry(context.Background(), "registry.example.com", "", "")
+ require.NoError(t, err)
+
+ err = svc.TestRegistry(context.Background(), "registry.example.com", " ", " ")
+ require.NoError(t, err)
+}
+
+func TestContainerRegistryService_InspectImageDigest_AnonymousSuccess(t *testing.T) {
+ svc := NewContainerRegistryService(nil, func(context.Context) (RegistryDaemonClient, error) {
+ return &fakeRegistryDaemonClient{
+ distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
+ assert.Equal(t, "registry.example.com:5443/team/app:1.2.3", imageRef)
+ assert.Empty(t, options.EncodedRegistryAuth)
+ return client.DistributionInspectResult{
+ DistributionInspect: dockerregistry.DistributionInspect{
+ Descriptor: ocispec.Descriptor{
+ Digest: digest.Digest("sha256:feedface"),
+ },
+ },
+ }, nil
+ },
+ }, nil
+ })
+
+ result, err := svc.inspectImageDigestInternal(context.Background(), "registry.example.com:5443/team/app:1.2.3", nil)
+ require.NoError(t, err)
+ assert.Equal(t, "sha256:feedface", result.Digest)
+ assert.Equal(t, "anonymous", result.AuthMethod)
+ assert.Equal(t, "registry.example.com:5443", result.AuthRegistry)
+}
+
+func TestContainerRegistryService_InspectImageDigest_RetriesWithStoredCredentials(t *testing.T) {
+ _, db := setupImageServiceAuthTest(t)
+ createTestPullRegistry(t, db, "https://index.docker.io/v1/", "docker-user", "docker-token")
+
+ var calls int
+ svc := NewContainerRegistryService(db, func(context.Context) (RegistryDaemonClient, error) {
+ return &fakeRegistryDaemonClient{
+ distributionInspectFn: func(ctx context.Context, imageRef string, options client.DistributionInspectOptions) (client.DistributionInspectResult, error) {
+ calls++
+ assert.Equal(t, "docker.io/library/nginx:latest", imageRef)
+ if calls == 1 {
+ assert.Empty(t, options.EncodedRegistryAuth)
+ return client.DistributionInspectResult{}, errors.New("unauthorized: authentication required")
+ }
+
+ authCfg := decodeRegistryAuth(t, options.EncodedRegistryAuth)
+ assert.Equal(t, "docker-user", authCfg.Username)
+ assert.Equal(t, "docker-token", authCfg.Password)
+ assert.Equal(t, "https://index.docker.io/v1/", authCfg.ServerAddress)
+
+ return client.DistributionInspectResult{
+ DistributionInspect: dockerregistry.DistributionInspect{
+ Descriptor: ocispec.Descriptor{
+ Digest: digest.Digest("sha256:cafebabe"),
+ },
+ },
+ }, nil
+ },
+ }, nil
+ })
+
+ result, err := svc.inspectImageDigestInternal(context.Background(), "registry-1.docker.io/library/nginx:latest", nil)
+ require.NoError(t, err)
+ assert.Equal(t, 2, calls)
+ assert.Equal(t, "sha256:cafebabe", result.Digest)
+ assert.Equal(t, "credential", result.AuthMethod)
+ assert.Equal(t, "docker-user", result.AuthUsername)
+ assert.True(t, result.UsedCredential)
+}
diff --git a/backend/internal/services/image_service_test.go b/backend/internal/services/image_service_test.go
index 1c67bdd9a..56af7d648 100644
--- a/backend/internal/services/image_service_test.go
+++ b/backend/internal/services/image_service_test.go
@@ -67,7 +67,7 @@ func setupImageServiceAuthTest(t *testing.T) (*ImageService, *database.DB) {
dbWrap := &database.DB{DB: db}
svc := &ImageService{
- registryService: NewContainerRegistryService(dbWrap),
+ registryService: NewContainerRegistryService(dbWrap, nil),
}
return svc, dbWrap
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 730badae2..f8cd60b31 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -68,9 +68,7 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
}, nil
}
- registries := s.getRegistriesForImage(ctx, parts.Registry)
-
- digestResult, snapshot, err := s.checkDigestUpdateWithSnapshotInternal(ctx, parts, registries)
+ digestResult, snapshot, err := s.checkDigestUpdateWithSnapshotInternal(ctx, parts)
if err != nil {
result := &imageupdate.Response{
Error: err.Error(),
@@ -119,91 +117,32 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
return digestResult, nil
}
-type authDetails struct {
- Method string
- Username string
- Registry string
-}
-
-// Try anonymous first, then each matching registry credential (decrypting token)
-// until one returns a token. If auth is not required, returns empty token.
-func (s *ImageUpdateService) getRegistryToken(ctx context.Context, regHost, repository string, regs []models.ContainerRegistry) (string, *authDetails, error) {
- rc := registry.NewClient()
-
- slog.DebugContext(ctx, "Checking registry auth", "registry", regHost, "repository", repository)
-
- authURL, err := rc.CheckAuth(ctx, regHost)
- if err != nil {
- slog.DebugContext(ctx, "Registry auth check failed", "registry", regHost, "error", err.Error())
- return "", nil, fmt.Errorf("failed to check auth: %w", err)
- }
-
- // No auth required
- if authURL == "" {
- return "", &authDetails{Method: "none", Registry: regHost}, nil
- }
-
- // 1) Try anonymous (works for many public repos)
- anonToken, anonErr := rc.GetToken(ctx, authURL, repository, nil)
- if anonErr == nil && anonToken != "" {
- return anonToken, &authDetails{Method: "anonymous", Registry: regHost}, nil
+func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.Context, parts *ImageParts) (*imageupdate.Response, *localImageSnapshot, error) {
+ if s.registryService == nil {
+ return nil, nil, fmt.Errorf("registry service unavailable")
}
- // 2) Try each matching enabled registry credential
- var lastErr error
- for i, reg := range regs {
- if reg.Username == "" || reg.Token == "" {
- continue
- }
- decrypted, decErr := crypto.Decrypt(reg.Token)
- if decErr != nil {
- lastErr = decErr
- continue
- }
- creds := &registry.Credentials{Username: reg.Username, Token: decrypted}
- token, err := rc.GetToken(ctx, authURL, repository, creds)
- if err == nil && token != "" {
- return token, &authDetails{Method: "credential", Username: reg.Username, Registry: regHost}, nil
- }
- if err != nil {
- lastErr = err
- } else {
- lastErr = fmt.Errorf("empty token (cred idx %d)", i)
- }
- }
-
- if lastErr != nil {
- return "", nil, fmt.Errorf("failed to get registry token: %w", lastErr)
- }
- return "", nil, fmt.Errorf("failed to get registry token")
-}
-
-func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.Context, parts *ImageParts, registries []models.ContainerRegistry) (*imageupdate.Response, *localImageSnapshot, error) {
- rc := registry.NewClient()
-
- token, auth, err := s.getRegistryToken(ctx, parts.Registry, parts.Repository, registries)
- if err != nil {
- return nil, nil, fmt.Errorf("failed to get registry token: %w", err)
- }
-
- normalizedRepo := s.normalizeRepository(parts.Registry, parts.Repository)
-
+ imageRef := fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag)
start := time.Now()
- remoteDigest, _, err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)
- if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
- // Attempt to resolve auth header via registry helpers and retry once
- enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)
- authHeader, _, _, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, parts.Tag, enabledRegs)
- if resolveErr == nil && authHeader != "" {
- remoteDigest, _, err = rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, authHeader)
- }
- }
+ digestResult, err := s.registryService.inspectImageDigestInternal(ctx, imageRef, nil)
elapsed := time.Since(start)
if err != nil {
- return nil, nil, fmt.Errorf("failed to get remote digest: %w", err)
+ partial := digestResult // may contain auth metadata even on error
+ if partial == nil {
+ return nil, nil, fmt.Errorf("failed to get remote digest: %w", err)
+ }
+ return &imageupdate.Response{
+ Error: err.Error(),
+ CheckTime: time.Now(),
+ ResponseTimeMs: int(elapsed.Milliseconds()),
+ AuthMethod: partial.AuthMethod,
+ AuthUsername: partial.AuthUsername,
+ AuthRegistry: partial.AuthRegistry,
+ UsedCredential: partial.UsedCredential,
+ }, nil, fmt.Errorf("failed to get remote digest: %w", err)
}
- snapshot, err := s.inspectLocalImageSnapshotInternal(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
+ snapshot, err := s.inspectLocalImageSnapshotInternal(ctx, imageRef)
if err != nil {
return nil, nil, fmt.Errorf("failed to get local digest: %w", err)
}
@@ -211,7 +150,7 @@ func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.C
localDigest := snapshot.PrimaryDigest
hasUpdate := true
for _, localDig := range snapshot.AllDigests {
- if localDig == remoteDigest {
+ if localDig == digestResult.Digest {
localDigest = localDig
hasUpdate = false
break
@@ -219,23 +158,23 @@ func (s *ImageUpdateService) checkDigestUpdateWithSnapshotInternal(ctx context.C
}
slog.DebugContext(ctx, "digest comparison",
- "imageRef", fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag),
+ "imageRef", imageRef,
"primaryLocalDigest", localDigest,
"allLocalDigests", snapshot.AllDigests,
- "remoteDigest", remoteDigest,
+ "remoteDigest", digestResult.Digest,
"hasUpdate", hasUpdate)
return &imageupdate.Response{
HasUpdate: hasUpdate,
UpdateType: "digest",
CurrentDigest: localDigest,
- LatestDigest: remoteDigest,
+ LatestDigest: digestResult.Digest,
CheckTime: time.Now(),
ResponseTimeMs: int(elapsed.Milliseconds()),
- AuthMethod: auth.Method,
- AuthUsername: auth.Username,
- AuthRegistry: auth.Registry,
- UsedCredential: auth.Method == "credential",
+ AuthMethod: digestResult.AuthMethod,
+ AuthUsername: digestResult.AuthUsername,
+ AuthRegistry: digestResult.AuthRegistry,
+ UsedCredential: digestResult.UsedCredential,
}, snapshot, nil
}
@@ -442,36 +381,6 @@ func (s *ImageUpdateService) inspectLocalImageSnapshotInternal(ctx context.Conte
}, nil
}
-// Returns all enabled credentials whose URL matches the image registry domain (normalized)
-func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, regHost string) []models.ContainerRegistry {
- normalizedDomain := registry.NormalizeRegistryForComparison(regHost)
-
- registries, err := s.registryService.GetAllRegistries(ctx)
- if err != nil {
- slog.DebugContext(ctx, "Failed to load registries for image", "registry", regHost, "error", err.Error())
- return nil
- }
-
- var matches []models.ContainerRegistry
- for _, reg := range registries {
- if !reg.Enabled {
- continue
- }
- normalizedRegURL := registry.NormalizeRegistryForComparison(reg.URL)
- if normalizedRegURL == normalizedDomain {
- matches = append(matches, reg)
- }
- }
-
- slog.DebugContext(ctx, "Matched registry credentials for image", "registry", regHost, "normalizedDomain", normalizedDomain, "matchCount", len(matches))
-
- for i, reg := range matches {
- slog.DebugContext(ctx, "Matched credential", "index", i, "registryURL", reg.URL, "username", reg.Username)
- }
-
- return matches
-}
-
func (s *ImageUpdateService) normalizeRepository(regHost, repo string) string {
if regHost == "docker.io" && !strings.Contains(repo, "/") {
return "library/" + repo
@@ -681,16 +590,6 @@ func (s *ImageUpdateService) MarkUpdatesAsNotified(ctx context.Context, imageIDs
Update("notification_sent", true).Error
}
-type batchCred struct {
- username string
- token string
-}
-
-type regAuth struct {
- token string
- auth *authDetails
-}
-
type batchImage struct {
refs []string
canonicalRef string
@@ -733,201 +632,50 @@ func (s *ImageUpdateService) parseAndGroupImagesInternal(imageRefs []string) (ma
return regRepos, results, images
}
-func (s *ImageUpdateService) buildCredentialMap(ctx context.Context, externalCreds []containerregistry.Credential) (map[string]batchCred, []models.ContainerRegistry) {
- var enabledRegs []models.ContainerRegistry
- credMap := make(map[string]batchCred)
-
- if len(externalCreds) > 0 {
- enabledRegHosts := make(map[string]struct{})
- for _, c := range externalCreds {
- if !c.Enabled || c.Username == "" || c.Token == "" {
- continue
- }
- host := registry.NormalizeRegistryForComparison(c.URL)
- if host == "" {
- continue
- }
- if _, exists := credMap[host]; !exists {
- credMap[host] = batchCred{username: c.Username, token: c.Token}
- }
- if _, exists := enabledRegHosts[host]; exists {
- continue
- }
- encToken, encErr := crypto.Encrypt(c.Token)
- if encErr != nil {
- slog.WarnContext(ctx, "Failed to encrypt external registry token", "registryURL", c.URL, "error", encErr.Error())
- continue
- }
- enabledRegs = append(enabledRegs, models.ContainerRegistry{
- URL: c.URL,
- Username: c.Username,
- Token: encToken,
- Enabled: c.Enabled,
- })
- enabledRegHosts[host] = struct{}{}
- }
- slog.DebugContext(ctx, "Using external credentials for batch check", "credentialCount", len(credMap))
- return credMap, enabledRegs
- }
-
- dbRegs, err := s.registryService.GetEnabledRegistries(ctx)
- if err != nil {
- slog.DebugContext(ctx, "Failed to load enabled registries", "error", err.Error())
- return credMap, nil
- }
- enabledRegs = dbRegs
-
- for _, r := range dbRegs {
- if r.Username == "" || r.Token == "" {
- continue
- }
- host := registry.NormalizeRegistryForComparison(r.URL)
- if host == "" {
- continue
- }
- dec, decErr := crypto.Decrypt(r.Token)
- if decErr != nil {
- slog.DebugContext(ctx, "Decrypt registry token failed", "registryURL", r.URL, "error", decErr.Error())
- continue
- }
- if _, exists := credMap[host]; !exists {
- credMap[host] = batchCred{username: r.Username, token: dec}
- }
- }
- return credMap, enabledRegs
-}
-
-func (s *ImageUpdateService) buildRegistryAuthMap(ctx context.Context, rc *registry.Client, regRepos map[string]map[string]struct{}, credMap map[string]batchCred) map[string]regAuth {
- regAuthMap := make(map[string]regAuth, len(regRepos))
-
- slog.DebugContext(ctx, "Building registry auth map",
- "registryCount", len(regRepos),
- "registries", func() []string {
- regs := make([]string, 0, len(regRepos))
- for r := range regRepos {
- regs = append(regs, r)
- }
- return regs
- }(),
- "credMapKeys", func() []string {
- keys := make([]string, 0, len(credMap))
- for k := range credMap {
- keys = append(keys, k)
- }
- return keys
- }())
-
- for regHost, set := range regRepos {
- repos := make([]string, 0, len(set))
- for r := range set {
- repos = append(repos, r)
- }
-
- authURL, err := rc.CheckAuth(ctx, regHost)
- if err != nil {
- slog.DebugContext(ctx, "Auth probe failed", "registry", regHost, "error", err.Error())
- regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}
- continue
- }
- // No auth required
- if authURL == "" {
- regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "none", Registry: regHost}}
- continue
- }
-
- // Credential attempt first (if available)
- host := registry.NormalizeRegistryForComparison(regHost)
- slog.DebugContext(ctx, "Looking up credentials for registry",
- "registry", regHost,
- "normalizedHost", host,
- "hasCredentials", credMap[host].username != "")
- if c, ok := credMap[host]; ok && c.username != "" && c.token != "" {
- creds := &registry.Credentials{Username: c.username, Token: c.token}
- if tok, tokErr := rc.GetTokenMulti(ctx, authURL, repos, creds); tokErr == nil && tok != "" {
- slog.InfoContext(ctx, "Using credential auth for registry", "registry", regHost, "username", c.username)
- regAuthMap[regHost] = regAuth{
- token: tok,
- auth: &authDetails{Method: "credential", Username: c.username, Registry: regHost},
- }
- continue
- } else {
- slog.WarnContext(ctx, "Failed to get token with credentials, falling back to anonymous",
- "registry", regHost,
- "username", c.username,
- "error", func() string {
- if tokErr != nil {
- return tokErr.Error()
- }
- return "empty token"
- }())
- }
- }
-
- // Anonymous multi-scope fallback
- if anonToken, anonErr := rc.GetTokenMulti(ctx, authURL, repos, nil); anonErr == nil && anonToken != "" {
- slog.DebugContext(ctx, "Using anonymous auth for registry", "registry", regHost)
- regAuthMap[regHost] = regAuth{token: anonToken, auth: &authDetails{Method: "anonymous", Registry: regHost}}
- continue
- }
- // Fallback unknown
- slog.DebugContext(ctx, "No valid credentials found for registry, using unknown auth", "registry", regHost)
- regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}
+func (s *ImageUpdateService) checkSingleImageInBatchInternal(ctx context.Context, externalCreds []containerregistry.Credential, parts *ImageParts) (*imageupdate.Response, *localImageSnapshot) {
+ if s.registryService == nil {
+ return &imageupdate.Response{
+ Error: "registry service unavailable",
+ CheckTime: time.Now(),
+ ResponseTimeMs: 0,
+ }, nil
}
- return regAuthMap
-}
-func (s *ImageUpdateService) checkSingleImageInBatchInternal(
- ctx context.Context,
- rc *registry.Client,
- authMap map[string]regAuth,
- enabledRegs []models.ContainerRegistry,
- parts *ImageParts,
-) (*imageupdate.Response, *localImageSnapshot) {
start := time.Now()
- authInfo := authMap[parts.Registry]
- token := authInfo.token
- auth := authInfo.auth
- normalizedRepo := s.normalizeRepository(parts.Registry, parts.Repository)
-
- remoteDigest, _, digestErr := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)
- if digestErr != nil && strings.Contains(strings.ToLower(digestErr.Error()), "unauthorized") {
- authHeader, method, username, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, parts.Tag, enabledRegs)
- if resolveErr == nil && authHeader != "" {
- remoteDigest, _, digestErr = rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, authHeader)
- if digestErr == nil {
- auth = &authDetails{Method: method, Username: username, Registry: parts.Registry}
- }
- }
- }
+ imageRef := fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag)
+ digestResult, digestErr := s.registryService.inspectImageDigestInternal(ctx, imageRef, externalCreds)
if digestErr != nil {
- return &imageupdate.Response{
+ resp := &imageupdate.Response{
Error: digestErr.Error(),
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(start).Milliseconds()),
- AuthMethod: auth.Method,
- AuthUsername: auth.Username,
- AuthRegistry: auth.Registry,
- UsedCredential: auth.Method == "credential",
- }, nil
+ }
+ if digestResult != nil {
+ resp.AuthMethod = digestResult.AuthMethod
+ resp.AuthUsername = digestResult.AuthUsername
+ resp.AuthRegistry = digestResult.AuthRegistry
+ resp.UsedCredential = digestResult.UsedCredential
+ }
+ return resp, nil
}
- snapshot, ldErr := s.inspectLocalImageSnapshotInternal(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
+ snapshot, ldErr := s.inspectLocalImageSnapshotInternal(ctx, imageRef)
if ldErr != nil {
return &imageupdate.Response{
Error: ldErr.Error(),
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(start).Milliseconds()),
- AuthMethod: auth.Method,
- AuthUsername: auth.Username,
- AuthRegistry: auth.Registry,
- UsedCredential: auth.Method == "credential",
+ AuthMethod: digestResult.AuthMethod,
+ AuthUsername: digestResult.AuthUsername,
+ AuthRegistry: digestResult.AuthRegistry,
+ UsedCredential: digestResult.UsedCredential,
}, nil
}
localDigest := snapshot.PrimaryDigest
hasDigestUpdate := true
for _, localDig := range snapshot.AllDigests {
- if localDig == remoteDigest {
+ if localDig == digestResult.Digest {
localDigest = localDig
hasDigestUpdate = false
break
@@ -938,16 +686,65 @@ func (s *ImageUpdateService) checkSingleImageInBatchInternal(
HasUpdate: hasDigestUpdate,
UpdateType: "digest",
CurrentDigest: localDigest,
- LatestDigest: remoteDigest,
+ LatestDigest: digestResult.Digest,
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(start).Milliseconds()),
- AuthMethod: auth.Method,
- AuthUsername: auth.Username,
- AuthRegistry: auth.Registry,
- UsedCredential: auth.Method == "credential",
+ AuthMethod: digestResult.AuthMethod,
+ AuthUsername: digestResult.AuthUsername,
+ AuthRegistry: digestResult.AuthRegistry,
+ UsedCredential: digestResult.UsedCredential,
}, snapshot
}
+func (s *ImageUpdateService) resolveBatchCredentialsInternal(ctx context.Context, externalCreds []containerregistry.Credential) []containerregistry.Credential {
+ if len(externalCreds) > 0 {
+ filtered := make([]containerregistry.Credential, 0, len(externalCreds))
+ for _, cred := range externalCreds {
+ if !cred.Enabled || strings.TrimSpace(cred.URL) == "" || strings.TrimSpace(cred.Username) == "" || strings.TrimSpace(cred.Token) == "" {
+ continue
+ }
+ filtered = append(filtered, cred)
+ }
+ return filtered
+ }
+
+ if s.registryService == nil {
+ return nil
+ }
+
+ registries, err := s.registryService.GetEnabledRegistries(ctx)
+ if err != nil {
+ slog.DebugContext(ctx, "failed to load enabled registries for batch check", "error", err.Error())
+ return nil
+ }
+
+ credentials := make([]containerregistry.Credential, 0, len(registries))
+ for _, reg := range registries {
+ if strings.TrimSpace(reg.URL) == "" || strings.TrimSpace(reg.Username) == "" || reg.Token == "" {
+ continue
+ }
+
+ token, decryptErr := crypto.Decrypt(reg.Token)
+ if decryptErr != nil {
+ slog.DebugContext(ctx, "failed to decrypt registry token for batch check", "registryURL", reg.URL, "error", decryptErr.Error())
+ continue
+ }
+ token = strings.TrimSpace(token)
+ if token == "" {
+ continue
+ }
+
+ credentials = append(credentials, containerregistry.Credential{
+ URL: reg.URL,
+ Username: reg.Username,
+ Token: token,
+ Enabled: reg.Enabled,
+ })
+ }
+
+ return credentials
+}
+
func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string, externalCreds []containerregistry.Credential) (map[string]*imageupdate.Response, error) {
startBatch := time.Now()
results := make(map[string]*imageupdate.Response, len(imageRefs))
@@ -957,16 +754,12 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
slog.DebugContext(ctx, "Starting batch image update check", "imageCount", len(imageRefs), "externalCredCount", len(externalCreds))
- rc := registry.NewClient()
-
regRepos, initialResults, images := s.parseAndGroupImagesInternal(imageRefs)
maps.Copy(results, initialResults)
- credMap, enabledRegs := s.buildCredentialMap(ctx, externalCreds)
-
- slog.DebugContext(ctx, "Built credential map", "credMapSize", len(credMap), "enabledRegsCount", len(enabledRegs))
+ resolvedCreds := s.resolveBatchCredentialsInternal(ctx, externalCreds)
- regAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)
+ slog.DebugContext(ctx, "Resolved batch registry credentials", "credentialCount", len(resolvedCreds), "registryCount", len(regRepos))
var mu sync.Mutex
g, groupCtx := errgroup.WithContext(ctx)
@@ -974,7 +767,7 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
for _, img := range images {
g.Go(func() error {
- res, snapshot := s.checkSingleImageInBatchInternal(groupCtx, rc, regAuthMap, enabledRegs, img.parts)
+ res, snapshot := s.checkSingleImageInBatchInternal(groupCtx, resolvedCreds, img.parts)
mu.Lock()
for _, ref := range img.refs {
diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.go
index 617846eef..6d6a9eb6d 100644
--- a/backend/internal/services/image_update_service_test.go
+++ b/backend/internal/services/image_update_service_test.go
@@ -6,12 +6,8 @@ import (
"testing"
"time"
- "github.com/getarcaneapp/arcane/backend/internal/config"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
- "github.com/getarcaneapp/arcane/backend/internal/utils/crypto"
- utilsregistry "github.com/getarcaneapp/arcane/backend/internal/utils/registry"
- "github.com/getarcaneapp/arcane/types/containerregistry"
"github.com/getarcaneapp/arcane/types/imageupdate"
glsqlite "github.com/glebarez/sqlite"
dockertypesimage "github.com/moby/moby/api/types/image"
@@ -761,70 +757,6 @@ func TestImageUpdateService_ParseAndGroupImages_DedupesNormalizedRefs(t *testing
containsAll(firstRefSet, "redis:7", "docker.io/library/redis:7")))
}
-func TestImageUpdateService_BuildCredentialMap_ExternalCredsDedupesEnabledRegistriesByHost(t *testing.T) {
- crypto.InitEncryption(&config.Config{
- Environment: config.AppEnvironmentTest,
- EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
- })
-
- svc := &ImageUpdateService{}
- ctx := context.Background()
-
- externalCreds := []containerregistry.Credential{
- {URL: "https://ghcr.io", Username: "first-user", Token: "first-token", Enabled: true},
- {URL: "ghcr.io/", Username: "second-user", Token: "second-token", Enabled: true},
- {URL: "https://docker.io", Username: "docker-user", Token: "docker-token", Enabled: true},
- }
-
- credMap, enabledRegs := svc.buildCredentialMap(ctx, externalCreds)
-
- require.Len(t, credMap, 2)
- require.Len(t, enabledRegs, 2)
-
- // Keep first credential per normalized host for token exchange calls.
- assert.Equal(t, "first-user", credMap["ghcr.io"].username)
- assert.Equal(t, "first-token", credMap["ghcr.io"].token)
- assert.Equal(t, "docker-user", credMap["docker.io"].username)
- assert.Equal(t, "docker-token", credMap["docker.io"].token)
-
- // Enabled registry records used for auth fallback should be de-duplicated per host.
- enabledByHost := make(map[string]models.ContainerRegistry, len(enabledRegs))
- for _, reg := range enabledRegs {
- host := utilsregistry.NormalizeRegistryForComparison(reg.URL)
- enabledByHost[host] = reg
- }
- require.Contains(t, enabledByHost, "ghcr.io")
- require.Contains(t, enabledByHost, "docker.io")
-
- assert.Equal(t, "first-user", enabledByHost["ghcr.io"].Username)
- assert.NotEmpty(t, enabledByHost["ghcr.io"].Token)
- assert.Equal(t, "docker-user", enabledByHost["docker.io"].Username)
- assert.NotEmpty(t, enabledByHost["docker.io"].Token)
-}
-
-func TestImageUpdateService_BuildCredentialMap_ExternalCredsSkipsInvalidEntries(t *testing.T) {
- crypto.InitEncryption(&config.Config{
- Environment: config.AppEnvironmentTest,
- EncryptionKey: "test-encryption-key-for-testing-32bytes-min",
- })
-
- svc := &ImageUpdateService{}
- ctx := context.Background()
-
- externalCreds := []containerregistry.Credential{
- {URL: "https://ghcr.io", Username: "valid-user", Token: "valid-token", Enabled: true},
- {URL: "https://ghcr.io", Username: "", Token: "missing-user", Enabled: true},
- {URL: "https://ghcr.io", Username: "disabled", Token: "disabled-token", Enabled: false},
- {URL: "", Username: "missing-url", Token: "token", Enabled: true},
- }
-
- credMap, enabledRegs := svc.buildCredentialMap(ctx, externalCreds)
-
- require.Len(t, credMap, 1)
- require.Len(t, enabledRegs, 1)
- assert.Equal(t, "valid-user", credMap["ghcr.io"].username)
-}
-
func TestDedupeImageRefsFromSummaries_WithLimit(t *testing.T) {
summaries := []dockertypesimage.Summary{
{RepoTags: []string{"nginx:latest", "nginx:latest", "<none>:<none>"}},
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index 0973b78bd..73a495cc2 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -158,15 +158,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*update
if err != nil {
return nil, fmt.Errorf("docker connect: %w", err)
}
- registryClient := arcRegistry.NewClient()
- digestChecker := arcaneupdater.NewDigestChecker(dcli, registryClient)
-
- enabledRegs := []models.ContainerRegistry{}
- if s.registryService != nil {
- if regs, rerr := s.registryService.GetEnabledRegistries(ctx); rerr == nil {
- enabledRegs = regs
- }
- }
+ digestChecker := arcaneupdater.NewDigestChecker(dcli, s.registryService)
// track all old image IDs we saw for pulled updates so we can prune them after restart
oldIDSet := map[string]struct{}{}
@@ -202,9 +194,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*update
// Digest pre-check: if registry supports it and digests match, avoid pulling entirely.
// This also prevents unnecessary restarts when the update record is stale.
normNew := s.normalizeRef(p.newRef)
- host, repo, tag := s.parseNormalizedRef(normNew)
- authHeader, _, _, _ := arcRegistry.ResolveAuthHeaderForRepository(ctx, host, repo, tag, enabledRegs)
- check := digestChecker.CheckImageNeedsUpdate(ctx, normNew, authHeader)
+ check := digestChecker.CheckImageNeedsUpdate(ctx, normNew)
skipPull := false
if check.CheckedViaAPI && check.Error == nil && !check.NeedsUpdate {
@@ -533,8 +523,10 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID
return out, nil
}
- // Compare with pulled image to avoid unnecessary restart
- checker := arcaneupdater.NewDigestChecker(dcli, arcRegistry.NewClient())
+ // Compare with pulled image to avoid unnecessary restart.
+ // digestResolver is intentionally nil: CompareWithPulled only inspects local
+ // images and does not need remote registry access.
+ checker := arcaneupdater.NewDigestChecker(dcli, nil)
changed, cmpErr := checker.CompareWithPulled(ctx, inspectBefore.Image, normalizedRef)
slog.InfoContext(ctx, "UpdateSingleContainer: digest comparison",
"containerID", containerID,
@@ -1140,7 +1132,8 @@ func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref str
return nil, err
}
- checker := arcaneupdater.NewDigestChecker(dcli, arcRegistry.NewClient())
+ // digestResolver is intentionally nil: GetImageIDsForRef only inspects local images.
+ checker := arcaneupdater.NewDigestChecker(dcli, nil)
ids, err := checker.GetImageIDsForRef(ctx, ref)
if err != nil {
return nil, err
@@ -1501,25 +1494,6 @@ func resolvePullableImageRefInternal(summaryImage, inspectConfigImage string, re
return "", ""
}
-// parseNormalizedRef expects a normalized ref in the form "host/repository:tag".
-func (s *UpdaterService) parseNormalizedRef(ref string) (host, repository, tag string) {
- // host/repo:tag
- parts := strings.SplitN(ref, "/", 2)
- if len(parts) != 2 {
- return "", "", ""
- }
- host = parts[0]
- rest := parts[1]
- tag = "latest"
- if i := strings.LastIndex(rest, ":"); i != -1 && strings.LastIndex(rest, "/") < i {
- tag = rest[i+1:]
- repository = rest[:i]
- } else {
- repository = rest
- }
- return host, repository, tag
-}
-
func (s *UpdaterService) logAutoUpdate(ctx context.Context, sev models.EventSeverity, metadata models.JSON) {
phase, _ := metadata["phase"].(string)
diff --git a/backend/internal/utils/arcaneupdater/digest.go b/backend/internal/utils/arcaneupdater/digest.go
index 2f104964c..b132f574a 100644
--- a/backend/internal/utils/arcaneupdater/digest.go
+++ b/backend/internal/utils/arcaneupdater/digest.go
@@ -6,22 +6,27 @@ import (
"log/slog"
"strings"
- "github.com/getarcaneapp/arcane/backend/internal/utils/registry"
"github.com/moby/moby/client"
ref "go.podman.io/image/v5/docker/reference"
+
+ "github.com/getarcaneapp/arcane/backend/internal/utils/registry"
)
+type remoteDigestResolver interface {
+ GetImageDigest(ctx context.Context, imageRef string) (string, error)
+}
+
// DigestChecker provides methods to check if an image needs updating by comparing digests
type DigestChecker struct {
dcli *client.Client
- registryClient *registry.Client
+ digestResolver remoteDigestResolver
}
// NewDigestChecker creates a new DigestChecker
-func NewDigestChecker(dcli *client.Client, registryClient *registry.Client) *DigestChecker {
+func NewDigestChecker(dcli *client.Client, digestResolver remoteDigestResolver) *DigestChecker {
return &DigestChecker{
dcli: dcli,
- registryClient: registryClient,
+ digestResolver: digestResolver,
}
}
@@ -36,17 +41,12 @@ type CheckResult struct {
// CheckImageNeedsUpdate checks if an image has a newer version available without pulling
// Returns true if the remote digest differs from the local digest
-func (c *DigestChecker) CheckImageNeedsUpdate(ctx context.Context, imageRef string, authToken string) CheckResult {
+func (c *DigestChecker) CheckImageNeedsUpdate(ctx context.Context, imageRef string) CheckResult {
result := CheckResult{}
- // Parse image reference
- registryHost, repository, tag := parseImageRef(imageRef)
-
slog.DebugContext(ctx, "CheckImageNeedsUpdate: checking image",
"imageRef", imageRef,
- "registry", registryHost,
- "repository", repository,
- "tag", tag)
+ "normalizedRef", normalizeRef(imageRef))
// Get local digest
localDigest, err := c.getLocalDigest(ctx, imageRef)
@@ -61,10 +61,15 @@ func (c *DigestChecker) CheckImageNeedsUpdate(ctx context.Context, imageRef stri
}
result.LocalDigest = localDigest
- // Get remote digest via HEAD request
- remoteDigest, err := c.registryClient.GetLatestDigest(ctx, registryHost, repository, tag, authToken)
+ if c.digestResolver == nil {
+ result.Error = fmt.Errorf("remote digest resolver unavailable")
+ return result
+ }
+
+ // Get remote digest via the Docker daemon-backed registry path.
+ remoteDigest, err := c.digestResolver.GetImageDigest(ctx, imageRef)
if err != nil {
- slog.DebugContext(ctx, "CheckImageNeedsUpdate: failed to get remote digest via HEAD",
+ slog.DebugContext(ctx, "CheckImageNeedsUpdate: failed to get remote digest",
"imageRef", imageRef,
"error", err)
// Can't determine remotely - caller should fall back to pull
diff --git a/backend/internal/utils/registry/auth.go b/backend/internal/utils/registry/auth.go
deleted file mode 100644
index 48b8004ed..000000000
--- a/backend/internal/utils/registry/auth.go
+++ /dev/null
@@ -1,377 +0,0 @@
-package registry
-
-import (
- "context"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "net/http"
- "net/url"
- "strings"
- "time"
-
- ref "go.podman.io/image/v5/docker/reference"
-
- "github.com/getarcaneapp/arcane/backend/internal/models"
- "github.com/getarcaneapp/arcane/backend/internal/utils/crypto"
-)
-
-type Credentials struct {
- Username string
- Token string
-}
-
-func (c *Client) GetRegistryURL(registry string) string {
- registry = strings.TrimSpace(registry)
-
- if strings.HasPrefix(registry, "http://") || strings.HasPrefix(registry, "https://") {
- if parsed, err := url.Parse(registry); err == nil && parsed.Host != "" {
- if NormalizeRegistryForComparison(parsed.Host) == "docker.io" {
- return "https://index.docker.io"
- }
- }
- return strings.TrimSuffix(registry, "/")
- }
-
- switch NormalizeRegistryForComparison(registry) {
- case "docker.io":
- return "https://index.docker.io"
- default:
- return "https://" + NormalizeRegistryForComparison(registry)
- }
-}
-
-func (c *Client) getServiceName(authURL string) string {
- if strings.Contains(authURL, "auth.docker.io") {
- return "registry.docker.io"
- }
- parts := strings.Split(strings.TrimPrefix(authURL, "https://"), "/")
- if len(parts) > 0 {
- return parts[0]
- }
- return "registry"
-}
-
-func (c *Client) ParseAuthChallenge(header string) (string, string) {
- lower := strings.ToLower(header)
- if !strings.HasPrefix(lower, "bearer ") {
- return "", ""
- }
- _, after, ok := strings.Cut(header, " ")
- if !ok {
- return "", ""
- }
- raw := after
- parts := strings.Split(raw, ",")
- var realm, service string
- for _, p := range parts {
- p = strings.TrimSpace(p)
- lp := strings.ToLower(p)
- switch {
- case strings.HasPrefix(lp, "realm="):
- realm = strings.Trim(p[len("realm="):], `"`)
- case strings.HasPrefix(lp, "service="):
- service = strings.Trim(p[len("service="):], `"`)
- }
- }
- return realm, service
-}
-
-func (c *Client) CheckAuth(ctx context.Context, registry string) (string, error) {
- url := fmt.Sprintf("%s/v2/", c.GetRegistryURL(registry))
- ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
- defer cancel()
-
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
- if err != nil {
- return "", err
- }
- resp, err := c.http.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint
- if err != nil {
- return "", err
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode == http.StatusUnauthorized {
- h := resp.Header.Get("WWW-Authenticate")
- if h == "" {
- h = resp.Header.Get("Www-Authenticate")
- }
- if h != "" {
- realm, service := c.ParseAuthChallenge(h)
- if realm != "" {
- if service != "" && !strings.Contains(realm, "service=") {
- if strings.Contains(realm, "?") {
- return realm + "&service=" + service, nil
- }
- return realm + "?service=" + service, nil
- }
- return realm, nil
- }
- }
- }
- return "", nil
-}
-
-func (c *Client) GetTokenMulti(ctx context.Context, authURL string, repositories []string, creds *Credentials) (string, error) {
- parsed, err := url.Parse(authURL)
- if err != nil {
- return "", fmt.Errorf("invalid auth url: %w", err)
- }
- q := parsed.Query()
- if q.Get("service") == "" {
- q.Set("service", c.getServiceName(authURL))
- }
- for _, repo := range repositories {
- q.Add("scope", fmt.Sprintf("repository:%s:pull", repo))
- }
- parsed.RawQuery = q.Encode()
-
- ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
- defer cancel()
-
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, parsed.String(), nil)
- if err != nil {
- return "", err
- }
- if creds != nil && creds.Username != "" && creds.Token != "" {
- req.SetBasicAuth(creds.Username, creds.Token)
- }
- resp, err := c.http.Do(req) //nolint:gosec // intentional token request to registry auth realm from challenge
- if err != nil {
- return "", err
- }
- defer func() { _ = resp.Body.Close() }()
- if resp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("token request failed with status: %d", resp.StatusCode)
- }
- var tr struct {
- Token string `json:"token"`
- }
- if err := json.NewDecoder(resp.Body).Decode(&tr); err != nil {
- return "", err
- }
- return tr.Token, nil
-}
-
-func (c *Client) GetToken(ctx context.Context, authURL, repository string, creds *Credentials) (string, error) {
- return c.GetTokenMulti(ctx, authURL, []string{repository}, creds)
-}
-
-// AcquireTokenViaChallenge:
-// Parses a WWW-Authenticate Bearer challenge, builds an auth URL,
-// tries anonymous multi-scope token, then credential-based.
-// Returns (token, method, username, error)
-func AcquireTokenViaChallenge(
- ctx context.Context,
- registryHost string,
- repository string,
- challengeHeader string,
- enabledRegs []models.ContainerRegistry,
-) (string, string, string, error) {
- // Normalize challenge to start at Bearer
- ch := strings.TrimSpace(challengeHeader)
- low := strings.ToLower(ch)
- if idx := strings.Index(low, "bearer "); idx >= 0 && idx != 0 {
- ch = ch[idx:]
- }
-
- // Extract (realm, service)
- c := NewClient()
- realm, service := c.ParseAuthChallenge(ch)
- if realm == "" {
- return "", "", "", fmt.Errorf("invalid challenge")
- }
-
- authURL := realm
- if service != "" && !strings.Contains(authURL, "service=") {
- if strings.Contains(authURL, "?") {
- authURL += "&service=" + service
- } else {
- authURL += "?service=" + service
- }
- }
-
- repoNorm := normalizeRepositoryForDockerIO(registryHost, repository)
- scopes := []string{repoNorm}
-
- // Anonymous attempt
- if tok, err := c.GetTokenMulti(ctx, authURL, scopes, nil); err == nil && tok != "" {
- return tok, "anonymous", "", nil
- }
-
- // Credential attempts
- hostNorm := normalizeHost(registryHost)
- for _, cr := range enabledRegs {
- if !cr.Enabled || cr.Username == "" || cr.Token == "" {
- continue
- }
- if normalizeHost(cr.URL) != hostNorm {
- continue
- }
- dec, err := crypto.Decrypt(cr.Token)
- if err != nil {
- continue
- }
- creds := &Credentials{Username: cr.Username, Token: dec}
- if tok, err := c.GetTokenMulti(ctx, authURL, scopes, creds); err == nil && tok != "" {
- return tok, "credential", cr.Username, nil
- }
- }
-
- return "", "", "", fmt.Errorf("token acquisition failed")
-}
-
-// Helpers (formerly in check.go)
-
-func normalizeHost(u string) string {
- return NormalizeRegistryForComparison(u)
-}
-
-func normalizeRepositoryForDockerIO(registryHost, repo string) string {
- r := normalizeHost(registryHost)
- if r == "docker.io" {
- if !strings.Contains(repo, "/") {
- return "library/" + repo
- }
- if strings.Count(repo, "/") == 0 {
- return "library/" + repo
- }
- }
- return repo
-}
-
-func GetChallengeRequest(ctx context.Context, u url.URL) (*http.Request, error) {
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
- if err != nil {
- return nil, err
- }
- req.Header.Set("Accept", "*/*")
- req.Header.Set("User-Agent", "Arcane")
- return req, nil
-}
-
-// GetChallengeURL returns https://<host>/v2/ for a given image ref (normalized).
-// host is normalized so docker.io => index.docker.io.
-func GetChallengeURL(imageRef string) (url.URL, error) {
- named, err := ref.ParseNormalizedNamed(imageRef)
- if err != nil {
- return url.URL{}, err
- }
- host, err := GetRegistryAddress(named.Name())
- if err != nil {
- return url.URL{}, err
- }
- return url.URL{Scheme: "https", Host: host, Path: "/v2/"}, nil
-}
-
-// GetAuthHeaderForImage performs the /v2/ challenge for an image and returns a usable Authorization header.
-// It supports Basic and Bearer challenges. For Bearer, it reuses AcquireTokenViaChallenge which
-// looks up credentials from the database (enabledRegs) when needed.
-func GetAuthHeaderForImage(ctx context.Context, imageRef string, enabledRegs []models.ContainerRegistry) (string, error) {
- chURL, err := GetChallengeURL(imageRef)
- if err != nil {
- return "", err
- }
-
- if _, ok := ctx.Deadline(); !ok {
- var cancel context.CancelFunc
- ctx, cancel = context.WithTimeout(ctx, 5*time.Second)
- defer cancel()
- }
-
- req, err := GetChallengeRequest(ctx, chURL)
- if err != nil {
- return "", err
- }
-
- c := NewClient()
- resp, err := c.http.Do(req) //nolint:gosec // intentional /v2/ challenge request to resolved registry host
- if err != nil {
- return "", err
- }
- defer func() { _ = resp.Body.Close() }()
-
- ch := resp.Header.Get(ChallengeHeader)
- if ch == "" {
- // try alternate case just in case
- ch = resp.Header.Get("Www-Authenticate")
- }
-
- // If /v2/ returns 200 or there's no WWW-Authenticate header, the registry is open —
- // no auth header required. Return empty header instead of an error.
- if resp.StatusCode == http.StatusOK || strings.TrimSpace(ch) == "" {
- return "", nil
- }
-
- chLower := strings.ToLower(strings.TrimSpace(ch))
-
- named, err := ref.ParseNormalizedNamed(imageRef)
- if err != nil {
- return "", err
- }
- host, err := GetRegistryAddress(named.Name())
- if err != nil {
- return "", err
- }
- repo := ref.Path(named)
-
- switch {
- case strings.HasPrefix(chLower, "basic"):
- h := normalizeHost(host)
- for _, cr := range enabledRegs {
- if !cr.Enabled || cr.Username == "" || cr.Token == "" {
- continue
- }
- if normalizeHost(cr.URL) != h {
- continue
- }
- dec, err := crypto.Decrypt(cr.Token)
- if err != nil {
- continue
- }
- ba := []byte(cr.Username + ":" + dec)
- return "Basic " + base64.StdEncoding.EncodeToString(ba), nil
- }
- return "", fmt.Errorf("no credentials available for basic auth at %s", host)
-
- case strings.HasPrefix(chLower, "bearer"):
- token, _, _, err := AcquireTokenViaChallenge(ctx, host, repo, ch, enabledRegs)
- if err != nil {
- return "", err
- }
- if token == "" {
- return "", fmt.Errorf("empty bearer token")
- }
- return "Bearer " + token, nil
-
- default:
- return "", fmt.Errorf("unsupported challenge type from registry: %q", ch)
- }
-}
-
-func ResolveAuthHeaderForRepository(ctx context.Context, host, repository, tag string, enabledRegs []models.ContainerRegistry) (string, string, string, error) {
- var imageRef string
- if tag != "" {
- imageRef = fmt.Sprintf("%s/%s:%s", host, repository, tag)
- } else {
- imageRef = fmt.Sprintf("%s/%s", host, repository)
- }
-
- hdr, err := GetAuthHeaderForImage(ctx, imageRef, enabledRegs)
- if err != nil {
- return "", "", "", err
- }
- if hdr == "" {
- return "", "none", "", nil
- }
- lh := strings.ToLower(strings.TrimSpace(hdr))
- switch {
- case strings.HasPrefix(lh, "basic "):
- return hdr, "basic", "", nil
- case strings.HasPrefix(lh, "bearer "):
- return hdr, "bearer", "", nil
- default:
- return hdr, "unknown", "", nil
- }
-}
diff --git a/backend/internal/utils/registry/client.go b/backend/internal/utils/registry/client.go
deleted file mode 100644
index 385abc182..000000000
--- a/backend/internal/utils/registry/client.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package registry
-
-import (
- "net/http"
-)
-
-// Client provides helper methods for Docker/OCI registries.
-type Client struct {
- http *http.Client
-}
-
-func NewClient() *Client {
- transport := http.DefaultTransport.(*http.Transport).Clone()
- transport.Proxy = http.ProxyFromEnvironment
-
- return &Client{http: &http.Client{Transport: transport}}
-}
diff --git a/backend/internal/utils/registry/digest.go b/backend/internal/utils/registry/digest.go
deleted file mode 100644
index d838cc9c3..000000000
--- a/backend/internal/utils/registry/digest.go
+++ /dev/null
@@ -1,130 +0,0 @@
-package registry
-
-import (
- "context"
- "fmt"
- "log/slog"
- "net/http"
- "strings"
- "time"
-)
-
-// buildAuthHeader constructs a proper Authorization header value from a token.
-// If token already has a scheme (Bearer/Basic), it's used as-is. Otherwise, Bearer is assumed.
-func buildAuthHeader(token string) string {
- t := strings.TrimSpace(token)
- if t == "" {
- return ""
- }
- lower := strings.ToLower(t)
- if strings.HasPrefix(lower, "bearer ") || strings.HasPrefix(lower, "basic ") {
- return t
- }
- return "Bearer " + t
-}
-
-// getHeaderCI returns the first header value for the given key, case-insensitively.
-func getHeaderCI(h http.Header, key string) string {
- for k, v := range h {
- if strings.EqualFold(k, key) && len(v) > 0 {
- return v[0]
- }
- }
- return ""
-}
-
-func extractDigestFromHeaders(h http.Header) string {
- d := getHeaderCI(h, ContentDigestHeader)
- if d != "" {
- return d
- }
- etag := getHeaderCI(h, "ETag")
- if etag != "" {
- etag = strings.Trim(etag, `"`)
- if strings.HasPrefix(etag, "sha256:") {
- return etag
- }
- }
- return ""
-}
-
-func (c *Client) GetLatestDigest(ctx context.Context, registry, repository, tag, token string) (string, error) {
- url := fmt.Sprintf("%s/v2/%s/manifests/%s", c.GetRegistryURL(registry), repository, tag)
- ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
- defer cancel()
-
- req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)
- if err != nil {
- return "", err
- }
-
- req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v2+json")
- req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.list.v2+json")
- req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v1+json")
- req.Header.Add("Accept", "application/vnd.oci.image.index.v1+json")
- req.Header.Add("Accept", "application/vnd.oci.image.manifest.v1+json")
- req.Header.Set("User-Agent", "Arcane")
-
- if ah := buildAuthHeader(token); ah != "" {
- req.Header.Set("Authorization", ah)
- }
-
- start := time.Now()
- resp, err := c.http.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint
- if err != nil {
- return "", err
- }
- defer func() { _ = resp.Body.Close() }()
-
- // If HEAD isn't supported by the registry, fall back to GET and try again.
- if resp.StatusCode == http.StatusMethodNotAllowed || resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusForbidden {
- slog.DebugContext(ctx, "HEAD not supported or returned unexpected status, retrying with GET", "url", url, "status", resp.StatusCode)
- // create GET request
- getReq, rerr := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
- if rerr != nil {
- return "", rerr
- }
- getReq.Header = req.Header.Clone()
- getResp, derr := c.http.Do(getReq) //nolint:gosec // intentional fallback request to same user-configured registry endpoint
- if derr != nil {
- return "", derr
- }
- defer func() { _ = getResp.Body.Close() }()
- resp = getResp
- }
-
- elapsed := time.Since(start)
- slog.DebugContext(ctx, "manifest request completed", "url", url, "status", resp.StatusCode, "elapsed", elapsed)
-
- if resp.StatusCode == http.StatusUnauthorized {
- h := getHeaderCI(resp.Header, "WWW-Authenticate")
- if h != "" {
- slog.DebugContext(ctx, "manifest request unauthorized", "www-authenticate", h)
- return "", fmt.Errorf("unauthorized: %s", h)
- }
- return "", fmt.Errorf("manifest request failed with status: 401")
- }
- if resp.StatusCode != http.StatusOK {
- www := getHeaderCI(resp.Header, "WWW-Authenticate")
- if www == "" {
- www = "not present"
- }
- slog.DebugContext(ctx, "manifest request unexpected status", "www-authenticate", www)
- return "", fmt.Errorf("manifest request failed with status: %d, auth: %q", resp.StatusCode, www)
- }
-
- d := extractDigestFromHeaders(resp.Header)
- if d == "" {
- return "", fmt.Errorf("no digest header found in response")
- }
-
- slog.DebugContext(ctx, "resolved remote digest", "registry", registry, "repository", repository, "tag", tag, "digest", d, "elapsed", elapsed)
-
- return d, nil
-}
-
-func (c *Client) GetLatestDigestTimed(ctx context.Context, registry, repository, tag, token string) (string, time.Duration, error) {
- start := time.Now()
- d, err := c.GetLatestDigest(ctx, registry, repository, tag, token)
- return d, time.Since(start), err
-}
diff --git a/backend/internal/utils/registry/ping.go b/backend/internal/utils/registry/ping.go
deleted file mode 100644
index 611503dd1..000000000
--- a/backend/internal/utils/registry/ping.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Package registry is derived from Moby's registry implementation.
-//
-// Source: https://github.com/moby/moby/blob/v28.5.2/registry/auth.go
-// License: Apache License 2.0
-// SPDX-License-Identifier: Apache-2.0
-//
-// # Simplified Wrapper as Arcane only needs the Ping Function currently
-//
-// This local copy is vendored to avoid pulling conflicting module variants
-// during dependency resolution in this monorepo.
-package registry
-
-import (
- "context"
- "net/http"
- "net/url"
- "strings"
- "time"
-
- "github.com/docker/distribution/registry/client/auth/challenge"
-)
-
-type PingResponseError struct {
- Err error
-}
-
-func (e PingResponseError) Error() string {
- if e.Err == nil {
- return "registry ping response error"
- }
-
- return e.Err.Error()
-}
-
-func (e PingResponseError) Unwrap() error {
- return e.Err
-}
-
-// PingV2Registry attempts to ping a v2 registry and on success return a
-// challenge manager for the supported authentication types.
-// If a response is received but cannot be interpreted, a PingResponseError will be returned.
-func PingV2Registry(ctx context.Context, endpoint *url.URL, transport http.RoundTripper) (challenge.Manager, error) {
- pingClient := &http.Client{
- Transport: transport,
- Timeout: 15 * time.Second,
- }
- endpointStr := strings.TrimRight(endpoint.String(), "/") + "/v2/"
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpointStr, http.NoBody)
- if err != nil {
- return nil, err
- }
- resp, err := pingClient.Do(req) //nolint:gosec // intentional request to user-configured registry endpoint
- if err != nil {
- return nil, err
- }
- defer resp.Body.Close()
-
- challengeManager := challenge.NewSimpleManager()
- if err := challengeManager.AddResponse(resp); err != nil {
- return nil, PingResponseError{
- Err: err,
- }
- }
-
- return challengeManager, nil
-}
diff --git a/backend/internal/utils/registry/registry_test.go b/backend/internal/utils/registry/registry_test.go
deleted file mode 100644
index ea6481e11..000000000
--- a/backend/internal/utils/registry/registry_test.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package registry
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "net/http"
- "net/http/httptest"
- "net/url"
- "testing"
-)
-
-func TestCheckAuthParsesRealmAndService(t *testing.T) {
- t.Parallel()
- realm := "https://auth.example/token"
- service := "example.org"
- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if r.URL.Path == "/v2/" {
- w.Header().Set("WwW-Authenticate", `Bearer realm="`+realm+`",service="`+service+`"`)
- http.Error(w, "unauthorized", http.StatusUnauthorized)
- return
- }
- w.WriteHeader(http.StatusOK)
- }))
- defer srv.Close()
-
- c := NewClient()
- got, err := c.CheckAuth(context.Background(), srv.URL)
- if err != nil {
- t.Fatalf("err: %v", err)
- }
- exp := realm + "?service=" + service
- if got != exp {
- t.Fatalf("got %q want %q", got, exp)
- }
-}
-
-func TestGetTokenMultiScopes(t *testing.T) {
- t.Parallel()
- var scopes []string
- var service string
- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- _ = r.ParseForm()
- scopes = r.Form["scope"]
- service = r.Form.Get("service")
- _ = json.NewEncoder(w).Encode(map[string]string{"token": "t123"})
- }))
- defer srv.Close()
-
- u, _ := url.Parse(srv.URL)
- authURL := fmt.Sprintf("%s/auth?service=test.local", u.String())
-
- c := NewClient()
- tok, err := c.GetTokenMulti(context.Background(), authURL, []string{"library/a", "library/b"}, nil)
- if err != nil {
- t.Fatalf("err: %v", err)
- }
- if tok != "t123" {
- t.Fatalf("token %q", tok)
- }
- if len(scopes) != 2 {
- t.Fatalf("scopes %v", scopes)
- }
- if service != "test.local" {
- t.Fatalf("service %q", service)
- }
-}
-
-func TestGetLatestDigestLowerCaseHeader(t *testing.T) {
- t.Parallel()
- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodHead {
- t.Fatalf("expected HEAD, got %s", r.Method)
- }
- w.Header().Set("docker-content-digest", "sha256:feedface")
- w.WriteHeader(http.StatusOK)
- }))
- defer srv.Close()
-
- c := NewClient()
- d, err := c.GetLatestDigest(context.Background(), srv.URL, "org/repo", "latest", "")
- if err != nil {
- t.Fatalf("err: %v", err)
- }
- if d != "sha256:feedface" {
- t.Fatalf("digest %q", d)
- }
-}
diff --git a/backend/internal/utils/registry/test_connection.go b/backend/internal/utils/registry/test_connection.go
deleted file mode 100644
index f76e80fae..000000000
--- a/backend/internal/utils/registry/test_connection.go
+++ /dev/null
@@ -1,228 +0,0 @@
-package registry
-
-import (
- "context"
- "encoding/base64"
- "fmt"
- "net/http"
- "net/url"
- "strings"
- "time"
-
- "github.com/docker/distribution/registry/client/auth/challenge"
-)
-
-type TestResult struct {
- OverallSuccess bool `json:"overall_success"`
- PingSuccess bool `json:"ping_success"`
- AuthSuccess bool `json:"auth_success"`
- CatalogSuccess bool `json:"catalog_success"`
- URL string `json:"url"`
- Domain string `json:"domain"`
- Timestamp time.Time `json:"timestamp"`
- Errors []string `json:"errors"`
-}
-
-const (
- authTimeout = 10 * time.Second
- catalogTimeout = 15 * time.Second
- registryPing = "/v2/"
- registryCatalog = "/v2/_catalog"
-)
-
-type registryConnectionTester struct {
- client *Client
- registry string
- result *TestResult
- endpoint *url.URL
-}
-
-func TestRegistryConnection(ctx context.Context, registryURL string, creds *Credentials) (*TestResult, error) {
- tester := &registryConnectionTester{
- client: NewClient(),
- registry: normalizeRegistry(registryURL),
- result: &TestResult{
- URL: registryURL,
- Domain: registryURL,
- Timestamp: time.Now(),
- Errors: []string{},
- },
- }
-
- if err := tester.parseEndpoint(); err != nil {
- return tester.result, err
- }
-
- challengeManager, err := tester.ping(ctx)
- if err != nil {
- return tester.result, err
- }
-
- authHeader := tester.performAuth(ctx, challengeManager, creds)
- tester.testCatalog(ctx, authHeader)
-
- tester.result.OverallSuccess = tester.result.PingSuccess && tester.result.AuthSuccess && tester.result.CatalogSuccess
- return tester.result, nil
-}
-
-func normalizeRegistry(registryURL string) string {
- reg := NormalizeRegistryForComparison(registryURL)
- if reg == "docker.io" {
- return DefaultRegistry
- }
- return reg
-}
-
-func (t *registryConnectionTester) parseEndpoint() error {
- registryEndpoint := t.client.GetRegistryURL(t.registry)
- endpointURL, err := url.Parse(registryEndpoint)
- if err != nil {
- t.addErrorf("Invalid registry URL: %v", err)
- return err
- }
-
- t.endpoint = endpointURL
- return nil
-}
-
-func (t *registryConnectionTester) ping(ctx context.Context) (challenge.Manager, error) {
- challengeManager, err := PingV2Registry(ctx, t.endpoint, t.client.http.Transport)
- if err != nil {
- t.addErrorf("Connectivity test failed: %v", err)
- return nil, err
- }
- t.result.PingSuccess = true
- return challengeManager, nil
-}
-
-func extractAuthURL(challengeManager challenge.Manager, endpointURL *url.URL) string {
- if challengeManager == nil {
- return ""
- }
-
- challenges, err := challengeManager.GetChallenges(*endpointURL)
- if err != nil {
- return ""
- }
-
- for _, ch := range challenges {
- if !strings.EqualFold(ch.Scheme, "bearer") {
- continue
- }
- realm, ok := ch.Parameters["realm"]
- if !ok || strings.TrimSpace(realm) == "" {
- continue
- }
-
- authURL, parseErr := url.Parse(realm)
- if parseErr != nil {
- return ""
- }
- if service, ok := ch.Parameters["service"]; ok && strings.TrimSpace(service) != "" {
- query := authURL.Query()
- if query.Get("service") == "" {
- query.Set("service", service)
- authURL.RawQuery = query.Encode()
- }
- }
- return authURL.String()
- }
-
- return ""
-}
-
-func (t *registryConnectionTester) performAuth(ctx context.Context, challengeManager challenge.Manager, creds *Credentials) string {
- authURL := extractAuthURL(challengeManager, t.endpoint)
- if authURL == "" {
- t.result.AuthSuccess = true
- return ""
- }
- if creds == nil {
- t.result.AuthSuccess = false
- return ""
- }
-
- if authHeader := t.tryBearerAuth(ctx, authURL, creds); authHeader != "" {
- t.result.AuthSuccess = true
- return authHeader
- }
-
- authHeader, ok := t.tryBasicAuth(ctx, creds)
- t.result.AuthSuccess = ok
- return authHeader
-}
-
-func (t *registryConnectionTester) tryBearerAuth(ctx context.Context, authURL string, creds *Credentials) string {
- tok, err := t.client.GetTokenMulti(ctx, authURL, []string{}, creds)
- if err == nil && tok != "" {
- return "Bearer " + tok
- }
-
- return ""
-}
-
-func (t *registryConnectionTester) tryBasicAuth(ctx context.Context, creds *Credentials) (string, bool) {
- resp, err := t.doRegistryGet(ctx, registryPing, authTimeout, func(req *http.Request) {
- req.SetBasicAuth(creds.Username, creds.Token)
- })
- if err != nil {
- t.addErrorf("Auth request failed: %v", err)
- return "", false
- }
- defer func() { _ = resp.Body.Close() }()
-
- if resp.StatusCode != http.StatusOK {
- t.addErrorf("Auth failed: status %d", resp.StatusCode)
- return "", false
- }
-
- ba := []byte(creds.Username + ":" + creds.Token)
- return "Basic " + base64.StdEncoding.EncodeToString(ba), true
-}
-
-func (t *registryConnectionTester) testCatalog(ctx context.Context, authHeader string) {
- resp, err := t.doRegistryGet(ctx, registryCatalog, catalogTimeout, func(req *http.Request) {
- if authHeader != "" {
- req.Header.Set("Authorization", authHeader)
- }
- })
- if err != nil {
- t.addErrorf("Catalog request failed: %v", err)
- t.result.CatalogSuccess = false
- return
- }
- defer func() { _ = resp.Body.Close() }()
-
- t.result.CatalogSuccess = resp.StatusCode == http.StatusOK
- if !t.result.CatalogSuccess {
- t.addErrorf("Catalog returned status: %d", resp.StatusCode)
- }
-}
-
-func (t *registryConnectionTester) doRegistryGet(ctx context.Context, path string, timeout time.Duration, setup func(*http.Request)) (*http.Response, error) {
- reqCtx, cancel := context.WithTimeout(ctx, timeout)
- defer cancel()
-
- req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, t.registryURL(path), http.NoBody)
- if err != nil {
- return nil, err
- }
- if setup != nil {
- setup(req)
- }
-
- resp, err := t.client.http.Do(req) //nolint:gosec // intentional request to user-provided registry for connection test
- if err != nil {
- return nil, err
- }
-
- return resp, nil
-}
-
-func (t *registryConnectionTester) registryURL(path string) string {
- return strings.TrimRight(t.client.GetRegistryURL(t.registry), "/") + path
-}
-
-func (t *registryConnectionTester) addErrorf(format string, args ...any) {
- t.result.Errors = append(t.result.Errors, fmt.Sprintf(format, args...))
-}
diff --git a/backend/internal/utils/validation/email_test.go b/backend/internal/utils/validation/email_test.go
index 57f1ed0ed..96228472e 100644
--- a/backend/internal/utils/validation/email_test.go
+++ b/backend/internal/utils/validation/email_test.go
@@ -13,7 +13,6 @@ func TestIsValidUserEmail_AllowsReportedFormats(t *testing.T) {
}
for _, email := range validEmails {
- email := email
t.Run(email, func(t *testing.T) {
t.Parallel()
if !IsValidUserEmail(email) {
@@ -42,7 +41,6 @@ func TestIsValidUserEmail_RejectsMalformedAddresses(t *testing.T) {
}
for _, email := range invalidEmails {
- email := email
t.Run(email, func(t *testing.T) {
t.Parallel()
if IsValidUserEmail(email) {
diff --git a/backend/pkg/projects/compose_test.go b/backend/pkg/projects/compose_test.go
index 09a860f80..aa60f0215 100644
--- a/backend/pkg/projects/compose_test.go
+++ b/backend/pkg/projects/compose_test.go
@@ -26,5 +26,5 @@ func TestWrapDockerCLIWithInspectCompatibility(t *testing.T) {
wrapped := wrapDockerCLIWithInspectCompatibilityInternal(baseCLI)
require.NotNil(t, wrapped)
require.NotSame(t, baseCLI, wrapped)
- require.NotEqual(t, reflect.TypeOf(apiClient), reflect.TypeOf(wrapped.Client()))
+ require.NotEqual(t, reflect.TypeFor[*mobyclient.Client](), reflect.TypeOf(wrapped.Client()))
}
diff --git a/backend/pkg/scheduler/analytics_job_test.go b/backend/pkg/scheduler/analytics_job_test.go
index 1c19473ae..304b1e995 100644
--- a/backend/pkg/scheduler/analytics_job_test.go
+++ b/backend/pkg/scheduler/analytics_job_test.go
@@ -205,12 +205,10 @@ func TestAnalyticsJob_Run_ConcurrentRunsSendOnce(t *testing.T) {
start := make(chan struct{})
var wg sync.WaitGroup
for range 2 {
- wg.Add(1)
- go func() {
- defer wg.Done()
+ wg.Go(func() {
<-start
job.Run(ctx)
- }()
+ })
}
close(start)
diff --git a/cli/go.sum b/cli/go.sum
index 9a5434098..5ac11a2ba 100644
--- a/cli/go.sum
+++ b/cli/go.sum
@@ -155,6 +155,7 @@ go.yaml.in/yaml/v4 v4.0.0-rc.4/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfP
golang.org/x/exp v0.0.0-20250911091902-df9299821621 h1:2id6c1/gto0kaHYyrixvknJ8tUK/Qs5IsmBtrc+FtgU=
golang.org/x/exp v0.0.0-20250911091902-df9299821621/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk=
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
diff --git a/types/go.sum b/types/go.sum
index c77f51088..477535861 100644
--- a/types/go.sum
+++ b/types/go.sum
@@ -66,6 +66,7 @@ go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTq
go.yaml.in/yaml/v4 v4.0.0-rc.4 h1:UP4+v6fFrBIb1l934bDl//mmnoIZEDK0idg1+AIvX5U=
go.yaml.in/yaml/v4 v4.0.0-rc.4/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=
golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=