Skip to content

Modern Docker Management, Designed for Everyone

refactor: consolidate registry logic into a cleaner structure (#443)

Kyle Mendellffeb4c6ad69e
diff --git a/backend/internal/api/container_registry_handler.go b/backend/internal/api/container_registry_handler.go
index 83a7f409a..00c48fe95 100644
--- a/backend/internal/api/container_registry_handler.go
+++ b/backend/internal/api/container_registry_handler.go
@@ -12,6 +12,7 @@ import (
"github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
+ registry "github.com/ofkm/arcane-backend/internal/utils/registry"
)
type ContainerRegistryHandler struct {
@@ -226,24 +227,24 @@ func (h *ContainerRegistryHandler) TestRegistry(c *gin.Context) {
})
}
-func (h *ContainerRegistryHandler) performRegistryTest(ctx context.Context, registry *models.ContainerRegistry, decryptedToken string) (map[string]interface{}, error) {
- var creds *utils.RegistryCredentials
- if registry.Username != "" && decryptedToken != "" {
- creds = &utils.RegistryCredentials{
- Username: registry.Username,
+func (h *ContainerRegistryHandler) performRegistryTest(ctx context.Context, registryModel *models.ContainerRegistry, decryptedToken string) (map[string]interface{}, error) {
+ var creds *registry.Credentials
+ if registryModel.Username != "" && decryptedToken != "" {
+ creds = &registry.Credentials{
+ Username: registryModel.Username,
Token: decryptedToken,
}
}
- testResult, err := utils.TestRegistryConnection(ctx, registry.URL, creds)
+ testResult, err := registry.TestRegistryConnection(ctx, registryModel.URL, creds)
if err != nil {
return nil, fmt.Errorf("registry test failed: %w", err)
}
result := map[string]interface{}{
"status": getStatusString(testResult.OverallSuccess),
- "url": registry.URL,
- "username": registry.Username,
+ "url": registryModel.URL,
+ "username": registryModel.Username,
"timestamp": testResult.Timestamp.Format(time.RFC3339),
"overall_success": testResult.OverallSuccess,
"ping_success": testResult.PingSuccess,
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 740e21413..1f2c2933e 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -3,17 +3,27 @@ package services
import (
"context"
"fmt"
+ "regexp"
"strconv"
"strings"
"time"
"log/slog"
+ "sync"
"github.com/docker/docker/api/types/image"
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/utils"
+ registry "github.com/ofkm/arcane-backend/internal/utils/registry"
+)
+
+// Local regex copies (previously referenced from utils.*VersionRegex)
+var (
+ semanticVersionRegex = regexp.MustCompile(`^(?:v)?(\d+)\.(\d+)\.(\d+)$`)
+ dateVersionRegex = regexp.MustCompile(`^(\d{4})\.(\d{1,2})\.(\d{1,2})$`)
+ numericVersionRegex = regexp.MustCompile(`^(\d+)(?:\.(\d+))?(?:\.(\d+))?$`)
)
type ImageUpdateService struct {
@@ -68,7 +78,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
}
-
metadata := models.JSON{
"action": "check_update",
"imageRef": imageRef,
@@ -80,7 +89,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
slog.String("imageRef", imageRef),
slog.String("error", logErr.Error()))
}
-
if saveErr := s.saveUpdateResult(ctx, imageRef, result); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -97,7 +105,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
CheckTime: time.Now(),
ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
}
-
metadata := models.JSON{
"action": "check_update",
"imageRef": imageRef,
@@ -109,7 +116,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
slog.String("imageRef", imageRef),
slog.String("error", logErr.Error()))
}
-
if saveErr := s.saveUpdateResult(ctx, imageRef, result); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -119,7 +125,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
}
if tagResult.HasUpdate {
tagResult.ResponseTimeMs = int(time.Since(startTime).Milliseconds())
-
metadata := models.JSON{
"action": "check_update",
"imageRef": imageRef,
@@ -134,7 +139,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
slog.String("imageRef", imageRef),
slog.String("error", logErr.Error()))
}
-
if saveErr := s.saveUpdateResult(ctx, imageRef, tagResult); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -145,7 +149,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
}
digestResult.ResponseTimeMs = int(time.Since(startTime).Milliseconds())
-
metadata := models.JSON{
"action": "check_update",
"imageRef": imageRef,
@@ -160,7 +163,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
slog.String("imageRef", imageRef),
slog.String("error", logErr.Error()))
}
-
if saveErr := s.saveUpdateResult(ctx, imageRef, digestResult); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result",
slog.String("imageRef", imageRef),
@@ -177,134 +179,98 @@ type authDetails struct {
// 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, registry, repository string, regs []models.ContainerRegistry) (string, *authDetails, error) {
- registryUtils := utils.NewRegistryUtils()
+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",
- slog.String("registry", registry),
+ slog.String("registry", regHost),
slog.String("repository", repository))
- authURL, err := registryUtils.CheckAuth(ctx, registry)
+ authURL, err := rc.CheckAuth(ctx, regHost)
if err != nil {
slog.DebugContext(ctx, "Registry auth check failed",
- slog.String("registry", registry),
+ slog.String("registry", regHost),
slog.String("error", err.Error()))
return "", nil, fmt.Errorf("failed to check auth: %w", err)
}
// No auth required
if authURL == "" {
- slog.DebugContext(ctx, "Registry does not require auth",
- slog.String("registry", registry),
- slog.String("repository", repository))
- return "", &authDetails{Method: "none", Registry: registry}, nil
+ return "", &authDetails{Method: "none", Registry: regHost}, nil
}
// 1) Try anonymous (works for many public repos)
- slog.DebugContext(ctx, "Attempting anonymous token acquisition",
- slog.String("registry", registry),
- slog.String("repository", repository))
- anonToken, anonErr := registryUtils.GetToken(ctx, authURL, repository, nil)
-
- switch {
- case anonErr != nil:
- slog.DebugContext(ctx, "Anonymous token attempt failed",
- slog.String("registry", registry),
- slog.String("repository", repository),
- slog.String("error", anonErr.Error()))
- case anonToken != "":
- slog.DebugContext(ctx, "Anonymous token acquired",
- slog.String("registry", registry),
- slog.String("repository", repository))
- return anonToken, &authDetails{Method: "anonymous", Registry: registry}, nil
- default:
- slog.DebugContext(ctx, "Anonymous token attempt returned empty token",
- slog.String("registry", registry),
- slog.String("repository", repository))
+ anonToken, anonErr := rc.GetToken(ctx, authURL, repository, nil)
+ if anonErr == nil && anonToken != "" {
+ return anonToken, &authDetails{Method: "anonymous", Registry: regHost}, nil
}
// 2) Try each matching enabled registry credential
var lastErr error
for i, reg := range regs {
if reg.Username == "" || reg.Token == "" {
- slog.DebugContext(ctx, "Skipping credential (missing username or token)",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL))
continue
}
-
- slog.DebugContext(ctx, "Trying credential for registry",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL),
- slog.String("username", reg.Username),
- slog.String("repository", repository))
-
decrypted, decErr := utils.Decrypt(reg.Token)
if decErr != nil {
- slog.DebugContext(ctx, "Credential decrypt failed",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL),
- slog.String("username", reg.Username),
- slog.String("error", decErr.Error()))
lastErr = decErr
continue
}
-
- creds := &utils.RegistryCredentials{
- Username: reg.Username,
- Token: decrypted,
- }
- token, err := registryUtils.GetToken(ctx, authURL, repository, creds)
+ creds := &registry.Credentials{Username: reg.Username, Token: decrypted}
+ token, err := rc.GetToken(ctx, authURL, repository, creds)
if err == nil && token != "" {
- slog.DebugContext(ctx, "Credential succeeded acquiring token",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL),
- slog.String("username", reg.Username))
- return token, &authDetails{Method: "credential", Username: reg.Username, Registry: registry}, nil
+ return token, &authDetails{Method: "credential", Username: reg.Username, Registry: regHost}, nil
}
-
if err != nil {
- slog.DebugContext(ctx, "Credential token attempt failed",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL),
- slog.String("username", reg.Username),
- slog.String("error", err.Error()))
lastErr = err
} else {
- slog.DebugContext(ctx, "Credential token attempt returned empty token",
- slog.Int("index", i),
- slog.String("registryURL", reg.URL),
- slog.String("username", reg.Username))
- lastErr = fmt.Errorf("empty token returned")
+ lastErr = fmt.Errorf("empty token (cred idx %d)", i)
}
}
- slog.DebugContext(ctx, "No usable token found after trying all methods",
- slog.String("registry", registry),
- slog.String("repository", repository))
-
if lastErr != nil {
return "", nil, fmt.Errorf("failed to get registry token: %w", lastErr)
}
return "", nil, fmt.Errorf("failed to get registry token")
}
+const (
+ UpdateScopeNone = "none" // Allow any update that matches format structure
+ UpdateScopeMajor = "major" // Require same major (allow minor/patch changes)
+ UpdateScopeMinor = "minor" // Require same major+minor (allow patch changes)
+ UpdateScopePatch = "patch" // Require same major+minor+patch (effectively for digest-only)
+)
+
+func (s *ImageUpdateService) getUpdateScope() string { return UpdateScopeNone }
+
func (s *ImageUpdateService) checkDigestUpdate(ctx context.Context, parts *ImageParts, registries []models.ContainerRegistry) (*dto.ImageUpdateResponse, error) {
- startTime := time.Now()
- registryUtils := utils.NewRegistryUtils()
+ rc := registry.NewClient()
token, auth, err := s.getRegistryToken(ctx, parts.Registry, parts.Repository, registries)
if err != nil {
return nil, fmt.Errorf("failed to get registry token: %w", err)
}
- slog.DebugContext(ctx, "Using registry auth method",
- slog.String("method", auth.Method),
- slog.String("registry", parts.Registry),
- slog.String("username", auth.Username))
-
normalizedRepo := s.normalizeRepository(parts.Registry, parts.Repository)
- remoteDigest, err := registryUtils.GetLatestDigest(ctx, parts.Registry, normalizedRepo, parts.Tag, token)
+
+ start := time.Now()
+ remoteDigest, _, err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)
+ if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
+ challenge := err.Error()
+ enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)
+ if newTok, method, user, aErr := registry.AcquireTokenViaChallenge(ctx, parts.Registry, normalizedRepo, challenge, enabledRegs); aErr == nil && newTok != "" {
+ token = newTok
+ auth.Method = method
+ auth.Username = user
+ if rd2, _, rd2Err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token); rd2Err == nil {
+ remoteDigest = rd2
+ err = nil
+ } else {
+ err = rd2Err
+ }
+ }
+ }
+ elapsed := time.Since(start)
if err != nil {
return nil, fmt.Errorf("failed to get remote digest: %w", err)
}
@@ -315,14 +281,13 @@ func (s *ImageUpdateService) checkDigestUpdate(ctx context.Context, parts *Image
}
hasUpdate := localDigest != remoteDigest
-
return &dto.ImageUpdateResponse{
HasUpdate: hasUpdate,
UpdateType: "digest",
CurrentDigest: localDigest,
LatestDigest: remoteDigest,
CheckTime: time.Now(),
- ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
+ ResponseTimeMs: int(elapsed.Milliseconds()),
AuthMethod: auth.Method,
AuthUsername: auth.Username,
AuthRegistry: auth.Registry,
@@ -351,7 +316,8 @@ func (s *ImageUpdateService) checkTagUpdate(ctx context.Context, parts *ImagePar
return nil, fmt.Errorf("failed to get tags: %w", err)
}
- latestVersion := s.findLatestCompatibleVersion(currentVersion, tags)
+ updateScope := s.getUpdateScope()
+ latestVersion := s.findLatestCompatibleVersionWithScope(currentVersion, tags, updateScope)
if latestVersion == nil {
return &dto.ImageUpdateResponse{
HasUpdate: false,
@@ -367,7 +333,6 @@ func (s *ImageUpdateService) checkTagUpdate(ctx context.Context, parts *ImagePar
}
hasUpdate := s.isNewerVersion(latestVersion, currentVersion)
-
return &dto.ImageUpdateResponse{
HasUpdate: hasUpdate,
UpdateType: "tag",
@@ -382,8 +347,72 @@ func (s *ImageUpdateService) checkTagUpdate(ctx context.Context, parts *ImagePar
}, nil
}
+func (s *ImageUpdateService) findLatestCompatibleVersionWithScope(current *VersionInfo, tags []string, updateScope string) *VersionInfo {
+ var latest *VersionInfo
+ for _, tag := range tags {
+ version := s.parseVersion(tag)
+ if version == nil || version.FormatStr != current.FormatStr {
+ continue
+ }
+ if !s.matchesVersionStructure(current, version) {
+ continue
+ }
+ if !s.isAllowedByUpdateScope(current, version, updateScope) {
+ continue
+ }
+ if latest == nil || s.isNewerVersion(version, latest) {
+ latest = version
+ }
+ }
+ return latest
+}
+
+// matchesVersionStructure ensures minor/patch presence matches between versions
+func (s *ImageUpdateService) matchesVersionStructure(base, candidate *VersionInfo) bool {
+ // Minor presence must match (both Some or both None)
+ if (base.Minor == nil) != (candidate.Minor == nil) {
+ return false
+ }
+
+ // Patch presence must match (both Some or both None)
+ if (base.Patch == nil) != (candidate.Patch == nil) {
+ return false
+ }
+
+ return true
+}
+
+func (s *ImageUpdateService) isAllowedByUpdateScope(base, candidate *VersionInfo, updateScope string) bool {
+ switch updateScope {
+ case UpdateScopeMajor:
+ // Require same major
+ return base.Major != nil && candidate.Major != nil &&
+ *base.Major == *candidate.Major
+
+ case UpdateScopeMinor:
+ // Require same major and minor
+ return base.Major != nil && candidate.Major != nil &&
+ base.Minor != nil && candidate.Minor != nil &&
+ *base.Major == *candidate.Major &&
+ *base.Minor == *candidate.Minor
+
+ case UpdateScopePatch:
+ // Require same major, minor, and patch
+ return base.Major != nil && candidate.Major != nil &&
+ base.Minor != nil && candidate.Minor != nil &&
+ base.Patch != nil && candidate.Patch != nil &&
+ *base.Major == *candidate.Major &&
+ *base.Minor == *candidate.Minor &&
+ *base.Patch == *candidate.Patch
+
+ default: // UpdateScopeNone
+ // Allow any version with matching structure
+ return true
+ }
+}
+
func (s *ImageUpdateService) getImageTags(ctx context.Context, parts *ImageParts, registries []models.ContainerRegistry) ([]string, *authDetails, error) {
- registryUtils := utils.NewRegistryUtils()
+ rc := registry.NewClient()
token, auth, err := s.getRegistryToken(ctx, parts.Registry, parts.Repository, registries)
if err != nil {
@@ -397,7 +426,25 @@ func (s *ImageUpdateService) getImageTags(ctx context.Context, parts *ImageParts
slog.String("authMethod", auth.Method),
slog.String("authUser", auth.Username))
- tags, err := registryUtils.GetImageTags(ctx, parts.Registry, normalizedRepo, token)
+ tags, err := rc.GetImageTags(ctx, parts.Registry, normalizedRepo, token)
+ if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
+ challenge := err.Error()
+ if idx := strings.Index(strings.ToLower(challenge), "bearer "); idx >= 0 {
+ challenge = challenge[idx:]
+ }
+ enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)
+ if newTok, method, user, aErr := registry.AcquireTokenViaChallenge(ctx, parts.Registry, normalizedRepo, challenge, enabledRegs); aErr == nil && newTok != "" {
+ token = newTok
+ auth.Method = method
+ auth.Username = user
+ if retryTags, rErr := rc.GetImageTags(ctx, parts.Registry, normalizedRepo, token); rErr == nil {
+ tags = retryTags
+ err = nil
+ } else {
+ err = rErr
+ }
+ }
+ }
if err != nil {
return nil, nil, err
}
@@ -405,36 +452,19 @@ func (s *ImageUpdateService) getImageTags(ctx context.Context, parts *ImageParts
}
func (s *ImageUpdateService) parseVersion(tag string) *VersionInfo {
- // Handle semantic versioning patterns
- if matches := utils.SemanticVersionRegex.FindStringSubmatch(tag); matches != nil {
+ if matches := semanticVersionRegex.FindStringSubmatch(tag); matches != nil {
major, _ := strconv.Atoi(matches[1])
minor, _ := strconv.Atoi(matches[2])
patch, _ := strconv.Atoi(matches[3])
-
- return &VersionInfo{
- Major: &major,
- Minor: &minor,
- Patch: &patch,
- FormatStr: "semantic",
- }
+ return &VersionInfo{Major: &major, Minor: &minor, Patch: &patch, FormatStr: "semantic"}
}
-
- // Handle date-based versioning (YYYY.MM.DD)
- if matches := utils.DateVersionRegex.FindStringSubmatch(tag); matches != nil {
+ if matches := dateVersionRegex.FindStringSubmatch(tag); matches != nil {
year, _ := strconv.Atoi(matches[1])
month, _ := strconv.Atoi(matches[2])
day, _ := strconv.Atoi(matches[3])
-
- return &VersionInfo{
- Major: &year,
- Minor: &month,
- Patch: &day,
- FormatStr: "date",
- }
+ return &VersionInfo{Major: &year, Minor: &month, Patch: &day, FormatStr: "date"}
}
-
- // Handle simple numeric versioning
- if matches := utils.NumericVersionRegex.FindStringSubmatch(tag); matches != nil {
+ if matches := numericVersionRegex.FindStringSubmatch(tag); matches != nil {
major, _ := strconv.Atoi(matches[1])
var minor, patch *int
if len(matches) > 2 && matches[2] != "" {
@@ -445,55 +475,11 @@ func (s *ImageUpdateService) parseVersion(tag string) *VersionInfo {
p, _ := strconv.Atoi(matches[3])
patch = &p
}
-
- return &VersionInfo{
- Major: &major,
- Minor: minor,
- Patch: patch,
- FormatStr: "numeric",
- }
+ return &VersionInfo{Major: &major, Minor: minor, Patch: patch, FormatStr: "numeric"}
}
-
return nil
}
-func (s *ImageUpdateService) findLatestCompatibleVersion(current *VersionInfo, tags []string) *VersionInfo {
- var latest *VersionInfo
-
- for _, tag := range tags {
- version := s.parseVersion(tag)
- if version == nil || version.FormatStr != current.FormatStr {
- continue
- }
-
- // Check compatibility based on semantic versioning rules
- if !s.isCompatibleVersion(current, version) {
- continue
- }
-
- if latest == nil || s.isNewerVersion(version, latest) {
- latest = version
- }
- }
-
- return latest
-}
-
-func (s *ImageUpdateService) isCompatibleVersion(base, candidate *VersionInfo) bool {
- // Same format is required
- if base.FormatStr != candidate.FormatStr {
- return false
- }
-
- // For semantic versioning, ensure major version compatibility
- if base.FormatStr == "semantic" {
- return base.Major != nil && candidate.Major != nil && *base.Major == *candidate.Major
- }
-
- // For other formats, allow any newer version
- return true
-}
-
func (s *ImageUpdateService) isNewerVersion(newer, current *VersionInfo) bool {
if newer.Major != nil && current.Major != nil {
if *newer.Major > *current.Major {
@@ -503,7 +489,6 @@ func (s *ImageUpdateService) isNewerVersion(newer, current *VersionInfo) bool {
return false
}
}
-
if newer.Minor != nil && current.Minor != nil {
if *newer.Minor > *current.Minor {
return true
@@ -512,45 +497,38 @@ func (s *ImageUpdateService) isNewerVersion(newer, current *VersionInfo) bool {
return false
}
}
-
if newer.Patch != nil && current.Patch != nil {
return *newer.Patch > *current.Patch
}
-
return false
}
func (s *ImageUpdateService) parseImageReference(imageRef string) *ImageParts {
- var registry, repository, tag string
-
+ var registryHost, repository, tag string
if strings.Contains(imageRef, "@sha256:") {
digestParts := strings.Split(imageRef, "@")
if len(digestParts) != 2 {
return nil
}
-
repoWithRegistry := digestParts[0]
parts := strings.Split(repoWithRegistry, "/")
-
if strings.Contains(parts[0], ".") || strings.Contains(parts[0], ":") {
- registry = parts[0]
+ registryHost = parts[0]
repository = strings.Join(parts[1:], "/")
} else {
- registry = "docker.io"
+ registryHost = "docker.io"
if len(parts) == 1 {
repository = "library/" + parts[0]
} else {
repository = repoWithRegistry
}
}
-
tag = "latest"
} else {
parts := strings.Split(imageRef, "/")
-
switch {
case len(parts) == 1:
- registry = "docker.io"
+ registryHost = "docker.io"
if strings.Contains(parts[0], ":") {
repoParts := strings.Split(parts[0], ":")
repository = "library/" + repoParts[0]
@@ -560,9 +538,8 @@ func (s *ImageUpdateService) parseImageReference(imageRef string) *ImageParts {
tag = "latest"
}
case strings.Contains(parts[0], ".") || strings.Contains(parts[0], ":"):
- registry = parts[0]
+ registryHost = parts[0]
repository = strings.Join(parts[1:], "/")
-
if strings.Contains(repository, ":") {
repoParts := strings.Split(repository, ":")
repository = repoParts[0]
@@ -571,9 +548,8 @@ func (s *ImageUpdateService) parseImageReference(imageRef string) *ImageParts {
tag = "latest"
}
default:
- registry = "docker.io"
+ registryHost = "docker.io"
repository = imageRef
-
if strings.Contains(repository, ":") {
repoParts := strings.Split(repository, ":")
repository = repoParts[0]
@@ -583,12 +559,7 @@ func (s *ImageUpdateService) parseImageReference(imageRef string) *ImageParts {
}
}
}
-
- return &ImageParts{
- Registry: registry,
- Repository: repository,
- Tag: tag,
- }
+ return &ImageParts{Registry: registryHost, Repository: repository, Tag: tag}
}
func (s *ImageUpdateService) getImageRefByID(ctx context.Context, imageID string) (string, error) {
@@ -599,12 +570,10 @@ func (s *ImageUpdateService) getImageRefByID(ctx context.Context, imageID string
defer dockerClient.Close()
imageID = strings.TrimPrefix(imageID, "sha256:")
-
inspectResponse, err := dockerClient.ImageInspect(ctx, imageID)
if err != nil {
return "", fmt.Errorf("image not found: %w", err)
}
-
if len(inspectResponse.RepoTags) > 0 {
for _, tag := range inspectResponse.RepoTags {
if tag != "<none>:<none>" {
@@ -612,19 +581,16 @@ func (s *ImageUpdateService) getImageRefByID(ctx context.Context, imageID string
}
}
}
-
if len(inspectResponse.RepoDigests) > 0 {
for _, digest := range inspectResponse.RepoDigests {
if digest != "<none>@<none>" {
digestParts := strings.Split(digest, "@")
if len(digestParts) == 2 {
- imageRef := digestParts[0] + ":latest"
- return imageRef, nil
+ return digestParts[0] + ":latest", nil
}
}
}
}
-
return "", fmt.Errorf("no valid repository tags or digests found for image")
}
@@ -647,16 +613,13 @@ func (s *ImageUpdateService) getAllImageRefs(ctx context.Context, limit int) ([]
imageRefs = append(imageRefs, tag)
}
}
-
if limit > 0 && len(imageRefs) >= limit {
break
}
}
-
if limit > 0 && len(imageRefs) > limit {
imageRefs = imageRefs[:limit]
}
-
return imageRefs, nil
}
@@ -671,39 +634,37 @@ func (s *ImageUpdateService) getLocalImageDigest(ctx context.Context, imageRef s
if err != nil {
return "", fmt.Errorf("failed to inspect image: %w", err)
}
-
if len(inspectResponse.RepoDigests) > 0 {
digestParts := strings.Split(inspectResponse.RepoDigests[0], "@")
if len(digestParts) == 2 {
return digestParts[1], nil
}
}
-
return inspectResponse.ID, nil
}
-func (s *ImageUpdateService) versionToString(version *VersionInfo) string {
- result := ""
- if version.Major != nil {
- result = strconv.Itoa(*version.Major)
+func (s *ImageUpdateService) versionToString(v *VersionInfo) string {
+ out := ""
+ if v.Major != nil {
+ out = strconv.Itoa(*v.Major)
}
- if version.Minor != nil {
- result += "." + strconv.Itoa(*version.Minor)
+ if v.Minor != nil {
+ out += "." + strconv.Itoa(*v.Minor)
}
- if version.Patch != nil {
- result += "." + strconv.Itoa(*version.Patch)
+ if v.Patch != nil {
+ out += "." + strconv.Itoa(*v.Patch)
}
- return result
+ return out
}
// Returns all enabled credentials whose URL matches the image registry domain (normalized)
-func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, registry string) []models.ContainerRegistry {
- normalizedDomain := s.normalizeRegistryURL(registry)
+func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, regHost string) []models.ContainerRegistry {
+ normalizedDomain := s.normalizeRegistryURL(regHost)
registries, err := s.registryService.GetAllRegistries(ctx)
if err != nil {
slog.DebugContext(ctx, "Failed to load registries for image",
- slog.String("registry", registry),
+ slog.String("registry", regHost),
slog.String("error", err.Error()))
return nil
}
@@ -720,7 +681,7 @@ func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, registry
}
slog.DebugContext(ctx, "Matched registry credentials for image",
- slog.String("registry", registry),
+ slog.String("registry", regHost),
slog.String("normalizedDomain", normalizedDomain),
slog.Int("matchCount", len(matches)))
@@ -735,37 +696,33 @@ func (s *ImageUpdateService) getRegistriesForImage(ctx context.Context, registry
}
func (s *ImageUpdateService) normalizeRegistryURL(url string) string {
- url = strings.TrimSpace(url)
- url = strings.ToLower(url)
+ url = strings.TrimSpace(strings.ToLower(url))
url = strings.TrimPrefix(url, "https://")
url = strings.TrimPrefix(url, "http://")
url = strings.TrimSuffix(url, "/")
- if url == "docker.io" || url == "registry-1.docker.io" || url == "index.docker.io" {
+ switch url {
+ case "docker.io", "registry-1.docker.io", "index.docker.io":
return "docker.io"
}
-
return url
}
-func (s *ImageUpdateService) normalizeRepository(registry, repository string) string {
- if registry == "docker.io" {
- if !strings.Contains(repository, "/") {
- return "library/" + repository
- }
+func (s *ImageUpdateService) normalizeRepository(regHost, repo string) string {
+ if regHost == "docker.io" && !strings.Contains(repo, "/") {
+ return "library/" + repo
}
- return repository
+ return repo
}
func (s *ImageUpdateService) isSpecialTag(tag string) bool {
- specialTags := []string{
+ special := []string{
"latest", "stable", "unstable", "dev", "devel", "development",
"test", "testing", "prod", "production", "main", "master",
"stage", "staging", "canary", "nightly", "edge", "next",
}
-
- for _, special := range specialTags {
- if tag == special {
+ for _, v := range special {
+ if tag == v {
return true
}
}
@@ -775,7 +732,6 @@ func (s *ImageUpdateService) isSpecialTag(tag string) bool {
func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID string) (*dto.ImageUpdateResponse, error) {
imageRef, err := s.getImageRefByID(ctx, imageID)
if err != nil {
- // Log error event
metadata := models.JSON{
"action": "check_update_by_id",
"imageID": imageID,
@@ -788,12 +744,10 @@ func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID s
}
return nil, fmt.Errorf("failed to get image reference: %w", err)
}
-
result, err := s.CheckImageUpdate(ctx, imageRef)
if err != nil {
return nil, err
}
-
if saveErr := s.saveUpdateResultByID(ctx, imageID, result); saveErr != nil {
slog.WarnContext(ctx, "Failed to save update result by ID",
slog.String("imageID", imageID),
@@ -807,12 +761,10 @@ func (s *ImageUpdateService) saveUpdateResult(ctx context.Context, imageRef stri
if parts == nil {
return fmt.Errorf("invalid image reference")
}
-
imageID, err := s.getImageIDByRef(ctx, imageRef)
if err != nil {
return fmt.Errorf("failed to get image ID: %w", err)
}
-
return s.saveUpdateResultByID(ctx, imageID, result)
}
@@ -821,17 +773,14 @@ func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID s
if result.Error != "" {
lastError = &result.Error
}
-
var latestVersion *string
if result.LatestVersion != "" {
latestVersion = &result.LatestVersion
}
-
var currentDigest *string
if result.CurrentDigest != "" {
currentDigest = &result.CurrentDigest
}
-
var latestDigest *string
if result.LatestDigest != "" {
latestDigest = &result.LatestDigest
@@ -847,15 +796,13 @@ func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID s
currentVersion = image.Tag
}
- var authMethod *string
+ var authMethod, authUsername, authRegistry *string
if result.AuthMethod != "" {
authMethod = &result.AuthMethod
}
- var authUsername *string
if result.AuthUsername != "" {
authUsername = &result.AuthUsername
}
- var authRegistry *string
if result.AuthRegistry != "" {
authRegistry = &result.AuthRegistry
}
@@ -894,24 +841,286 @@ func (s *ImageUpdateService) getImageIDByRef(ctx context.Context, imageRef strin
if err != nil {
return "", fmt.Errorf("image not found: %w", err)
}
-
return inspectResponse.ID, nil
}
-func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string) (map[string]*dto.ImageUpdateResponse, error) {
+type batchCred struct {
+ username string
+ token string
+}
+
+type regAuth struct {
+ token string
+ auth *authDetails
+}
+
+type batchImage struct {
+ ref string
+ parts *ImageParts
+}
+
+func (s *ImageUpdateService) parseAndGroupImages(imageRefs []string) (map[string]map[string]struct{}, map[string]*dto.ImageUpdateResponse, []batchImage) {
+ regRepos := make(map[string]map[string]struct{})
results := make(map[string]*dto.ImageUpdateResponse)
+ var images []batchImage
+
+ for _, ref := range imageRefs {
+ parts := s.parseImageReference(ref)
+ if parts == nil {
+ results[ref] = &dto.ImageUpdateResponse{
+ Error: "Invalid image reference format",
+ CheckTime: time.Now(),
+ ResponseTimeMs: 0,
+ }
+ continue
+ }
+ if _, ok := regRepos[parts.Registry]; !ok {
+ regRepos[parts.Registry] = make(map[string]struct{})
+ }
+ regRepos[parts.Registry][s.normalizeRepository(parts.Registry, parts.Repository)] = struct{}{}
+ images = append(images, batchImage{ref: ref, parts: parts})
+ }
+ return regRepos, results, images
+}
+
+func (s *ImageUpdateService) buildCredentialMap(ctx context.Context) (map[string]batchCred, []models.ContainerRegistry) {
+ enabledRegs, err := s.registryService.GetEnabledRegistries(ctx)
+ if err != nil {
+ slog.DebugContext(ctx, "Failed to load enabled registries", slog.String("error", err.Error()))
+ return map[string]batchCred{}, nil
+ }
+ credMap := make(map[string]batchCred, len(enabledRegs))
+ normalizeHost := func(u string) string {
+ u = strings.TrimSpace(u)
+ u = strings.TrimPrefix(u, "https://")
+ u = strings.TrimPrefix(u, "http://")
+ return strings.TrimSuffix(u, "/")
+ }
+ for _, r := range enabledRegs {
+ if r.Username == "" || r.Token == "" {
+ continue
+ }
+ host := normalizeHost(r.URL)
+ if host == "" {
+ continue
+ }
+ dec, decErr := utils.Decrypt(r.Token)
+ if decErr != nil {
+ slog.DebugContext(ctx, "Decrypt registry token failed",
+ slog.String("registryURL", r.URL),
+ slog.String("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))
+ normalizeHost := func(u string) string {
+ u = strings.TrimSpace(u)
+ u = strings.TrimPrefix(u, "https://")
+ u = strings.TrimPrefix(u, "http://")
+ return strings.TrimSuffix(u, "/")
+ }
+
+ for regHost, set := range regRepos {
+ repos := make([]string, 0, len(set))
+ for r := range set {
+ repos = append(repos, r)
+ }
- for _, imageRef := range imageRefs {
- result, err := s.CheckImageUpdate(ctx, imageRef)
+ authURL, err := rc.CheckAuth(ctx, regHost)
if err != nil {
- results[imageRef] = &dto.ImageUpdateResponse{
- Error: err.Error(),
- CheckTime: time.Now(),
+ slog.DebugContext(ctx, "Auth probe failed",
+ slog.String("registry", regHost),
+ slog.String("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
+ }
+ // Anonymous multi-scope
+ if anonToken, anonErr := rc.GetTokenMulti(ctx, authURL, repos, nil); anonErr == nil && anonToken != "" {
+ regAuthMap[regHost] = regAuth{token: anonToken, auth: &authDetails{Method: "anonymous", Registry: regHost}}
+ continue
+ }
+ // Credential attempt
+ host := normalizeHost(regHost)
+ 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 != "" {
+ regAuthMap[regHost] = regAuth{
+ token: tok,
+ auth: &authDetails{Method: "credential", Username: c.username, Registry: regHost},
+ }
+ continue
}
- } else {
- results[imageRef] = result
}
+ // Fallback unknown
+ regAuthMap[regHost] = regAuth{token: "", auth: &authDetails{Method: "unknown", Registry: regHost}}
}
+ return regAuthMap
+}
+
+func (s *ImageUpdateService) checkSingleImageInBatch(
+ ctx context.Context,
+ rc *registry.Client,
+ authMap map[string]regAuth,
+ enabledRegs []models.ContainerRegistry,
+ parts *ImageParts,
+ updateScope string,
+) *dto.ImageUpdateResponse {
+
+ 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") {
+ challenge := digestErr.Error()
+ if idx := strings.Index(strings.ToLower(challenge), "bearer "); idx >= 0 {
+ challenge = challenge[idx:]
+ }
+ if newTok, method, user, aErr := registry.AcquireTokenViaChallenge(ctx, parts.Registry, normalizedRepo, challenge, enabledRegs); aErr == nil && newTok != "" {
+ token = newTok
+ auth.Method = method
+ auth.Username = user
+ // retry once
+ if rd2, _, rd2Err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token); rd2Err == nil {
+ remoteDigest = rd2
+ digestErr = nil
+ } else {
+ digestErr = rd2Err
+ }
+ }
+ }
+ if digestErr != nil {
+ return &dto.ImageUpdateResponse{
+ 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",
+ }
+ }
+
+ localDigest, ldErr := s.getLocalImageDigest(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
+ if ldErr != nil {
+ return &dto.ImageUpdateResponse{
+ 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",
+ }
+ }
+
+ hasDigestUpdate := localDigest != remoteDigest
+
+ // Tag update path only if digest unchanged and tag is version-like
+ if !hasDigestUpdate && !s.isSpecialTag(parts.Tag) {
+ curVer := s.parseVersion(parts.Tag)
+ if curVer != nil {
+ tags, tagErr := rc.GetImageTags(ctx, parts.Registry, normalizedRepo, token)
+ if tagErr == nil {
+ if latestVer := s.findLatestCompatibleVersionWithScope(curVer, tags, updateScope); latestVer != nil && s.isNewerVersion(latestVer, curVer) {
+ return &dto.ImageUpdateResponse{
+ HasUpdate: true,
+ UpdateType: "tag",
+ CurrentVersion: parts.Tag,
+ LatestVersion: s.versionToString(latestVer),
+ CheckTime: time.Now(),
+ ResponseTimeMs: int(time.Since(start).Milliseconds()),
+ AuthMethod: auth.Method,
+ AuthUsername: auth.Username,
+ AuthRegistry: auth.Registry,
+ UsedCredential: auth.Method == "credential",
+ }
+ }
+ }
+ }
+ }
+
+ return &dto.ImageUpdateResponse{
+ HasUpdate: hasDigestUpdate,
+ UpdateType: "digest",
+ CurrentDigest: localDigest,
+ LatestDigest: remoteDigest,
+ CheckTime: time.Now(),
+ ResponseTimeMs: int(time.Since(start).Milliseconds()),
+ AuthMethod: auth.Method,
+ AuthUsername: auth.Username,
+ AuthRegistry: auth.Registry,
+ UsedCredential: auth.Method == "credential",
+ }
+}
+
+func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs []string) (map[string]*dto.ImageUpdateResponse, error) {
+ startBatch := time.Now()
+ results := make(map[string]*dto.ImageUpdateResponse, len(imageRefs))
+ if len(imageRefs) == 0 {
+ return results, nil
+ }
+
+ rc := registry.NewClient()
+
+ // Parse & group
+ regRepos, initialResults, images := s.parseAndGroupImages(imageRefs)
+ for k, v := range initialResults {
+ results[k] = v
+ }
+
+ // Credentials + enabled registry list (for challenge retries)
+ credMap, enabledRegs := s.buildCredentialMap(ctx)
+
+ // Registry auth map
+ regAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)
+
+ // Concurrency
+ updateScope := s.getUpdateScope()
+ outCh := make(chan struct {
+ ref string
+ res *dto.ImageUpdateResponse
+ }, len(images))
+
+ wg := sync.WaitGroup{}
+ wg.Add(len(images))
+ for _, img := range images {
+ go func() {
+ defer wg.Done()
+ res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, img.parts, updateScope)
+ // Persist
+ _ = s.saveUpdateResult(ctx, img.ref, res)
+ outCh <- struct {
+ ref string
+ res *dto.ImageUpdateResponse
+ }{ref: img.ref, res: res}
+ }()
+ }
+
+ wg.Wait()
+ close(outCh)
+
+ for it := range outCh {
+ results[it.ref] = it.res
+ }
+
+ slog.DebugContext(ctx, "Batch image update check complete",
+ slog.Int("count", len(results)),
+ slog.Int64("elapsedMs", time.Since(startBatch).Milliseconds()))
return results, nil
}
@@ -921,7 +1130,6 @@ func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int) (map
if err != nil {
return nil, fmt.Errorf("failed to get image references: %w", err)
}
-
return s.CheckMultipleImages(ctx, imageRefs)
}
@@ -939,7 +1147,6 @@ func (s *ImageUpdateService) TriggerBulkUpdateCheck(ctx context.Context, imageID
successCount := 0
errorCount := 0
-
for _, imageID := range imageIDs {
_, err := s.CheckImageUpdateByID(ctx, imageID)
if err != nil {
@@ -979,19 +1186,13 @@ func (s *ImageUpdateService) DeleteUpdateRecord(ctx context.Context, imageID str
func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {
subQuery := s.db.WithContext(ctx).Model(&models.Image{}).Select("id")
-
return s.db.WithContext(ctx).
Where("id NOT IN (?)", subQuery).
Delete(&models.ImageUpdateRecord{}).Error
}
func (s *ImageUpdateService) GetUpdateSummary(ctx context.Context) (*dto.ImageUpdateSummaryResponse, error) {
- var totalImages int64
- var imagesWithUpdates int64
- var digestUpdates int64
- var tagUpdates int64
- var errorsCount int64
-
+ var totalImages, imagesWithUpdates, digestUpdates, tagUpdates, errorsCount int64
s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Count(&totalImages)
s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ?", true).Count(&imagesWithUpdates)
s.db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "digest").Count(&digestUpdates)
@@ -1012,27 +1213,22 @@ func (s *ImageUpdateService) GetAvailableVersions(ctx context.Context, imageRef
if parts == nil {
return nil, fmt.Errorf("invalid image reference format")
}
-
registries := s.getRegistriesForImage(ctx, parts.Registry)
-
tags, _, err := s.getImageTags(ctx, parts, registries)
if err != nil {
return nil, fmt.Errorf("failed to get tags: %w", err)
}
-
if limit > 0 && len(tags) > limit {
tags = tags[:limit]
}
-
var latest string
currentVersion := s.parseVersion(parts.Tag)
if currentVersion != nil {
- latestVersion := s.findLatestCompatibleVersion(currentVersion, tags)
- if latestVersion != nil {
+ updateScope := s.getUpdateScope()
+ if latestVersion := s.findLatestCompatibleVersionWithScope(currentVersion, tags, updateScope); latestVersion != nil {
latest = s.versionToString(latestVersion)
}
}
-
return &dto.ImageVersionsResponse{
ImageRef: imageRef,
Current: parts.Tag,
diff --git a/backend/internal/utils/registry/auth.go b/backend/internal/utils/registry/auth.go
new file mode 100644
index 000000000..7765607c1
--- /dev/null
+++ b/backend/internal/utils/registry/auth.go
@@ -0,0 +1,235 @@
+package registry
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+
+ "github.com/ofkm/arcane-backend/internal/models"
+ "github.com/ofkm/arcane-backend/internal/utils"
+)
+
+type Credentials struct {
+ Username string
+ Token string
+}
+
+func (c *Client) GetRegistryURL(registry string) string {
+ switch registry {
+ case DefaultRegistry, "docker.io":
+ return "https://index.docker.io"
+ default:
+ if !strings.HasPrefix(registry, "http") {
+ return "https://" + registry
+ }
+ return 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 "", ""
+ }
+ idx := strings.Index(header, " ")
+ if idx == -1 {
+ return "", ""
+ }
+ raw := header[idx+1:]
+ 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)
+ if err != nil {
+ return "", err
+ }
+ defer 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)
+ if err != nil {
+ return "", err
+ }
+ defer 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 := utils.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 {
+ u = strings.TrimSpace(u)
+ u = strings.TrimPrefix(u, "https://")
+ u = strings.TrimPrefix(u, "http://")
+ u = strings.TrimSuffix(u, "/")
+ return strings.ToLower(u)
+}
+
+func normalizeRepositoryForDockerIO(registryHost, repo string) string {
+ r := normalizeHost(registryHost)
+ if r == "docker.io" || r == DefaultRegistry || r == "index.docker.io" {
+ if !strings.Contains(repo, "/") {
+ return "library/" + repo
+ }
+ if strings.Count(repo, "/") == 0 {
+ return "library/" + repo
+ }
+ }
+ return repo
+}
diff --git a/backend/internal/utils/registry/client.go b/backend/internal/utils/registry/client.go
new file mode 100644
index 000000000..73c58a950
--- /dev/null
+++ b/backend/internal/utils/registry/client.go
@@ -0,0 +1,14 @@
+package registry
+
+import (
+ "net/http"
+)
+
+// Client provides helper methods for Docker/OCI registries.
+type Client struct {
+ http *http.Client
+}
+
+func NewClient() *Client {
+ return &Client{http: &http.Client{}}
+}
diff --git a/backend/internal/utils/registry/constants.go b/backend/internal/utils/registry/constants.go
new file mode 100644
index 000000000..655d01ca3
--- /dev/null
+++ b/backend/internal/utils/registry/constants.go
@@ -0,0 +1,3 @@
+package registry
+
+const DefaultRegistry = "registry-1.docker.io"
diff --git a/backend/internal/utils/registry/digest.go b/backend/internal/utils/registry/digest.go
new file mode 100644
index 000000000..c63dbcd9b
--- /dev/null
+++ b/backend/internal/utils/registry/digest.go
@@ -0,0 +1,69 @@
+package registry
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+ "strings"
+ "time"
+)
+
+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.Set("Accept",
+ "application/vnd.docker.distribution.manifest.list.v2+json, "+
+ "application/vnd.docker.distribution.manifest.v2+json, "+
+ "application/vnd.oci.image.index.v1+json, "+
+ "application/vnd.oci.image.manifest.v1+json")
+ if token != "" {
+ req.Header.Set("Authorization", "Bearer "+token)
+ }
+
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode == http.StatusUnauthorized {
+ h := resp.Header.Get("WWW-Authenticate")
+ if h == "" {
+ h = resp.Header.Get("Www-Authenticate")
+ }
+ if h != "" {
+ return "", fmt.Errorf("unauthorized: %s", h)
+ }
+ return "", fmt.Errorf("manifest request failed with status: 401")
+ }
+ if resp.StatusCode != http.StatusOK {
+ return "", fmt.Errorf("manifest request failed with status: %d", resp.StatusCode)
+ }
+
+ d := resp.Header.Get("Docker-Content-Digest")
+ if d == "" {
+ d = resp.Header.Get("docker-content-digest")
+ }
+ if d == "" {
+ etag := resp.Header.Get("Etag")
+ if etag != "" && strings.HasPrefix(etag, "sha256:") {
+ d = strings.Trim(etag, `"`)
+ }
+ }
+ if d == "" {
+ return "", fmt.Errorf("no digest header found in response")
+ }
+ 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/reference.go b/backend/internal/utils/registry/reference.go
new file mode 100644
index 000000000..0b8ad900f
--- /dev/null
+++ b/backend/internal/utils/registry/reference.go
@@ -0,0 +1,65 @@
+package registry
+
+import (
+ "fmt"
+ "strings"
+)
+
+func (c *Client) SplitImageReference(reference string) (string, string, string, error) {
+ if reference == "" {
+ return "", "", "", fmt.Errorf("empty reference provided")
+ }
+
+ splits := strings.Split(reference, "/")
+ var registry, repositoryAndTag string
+
+ switch len(splits) {
+ case 1:
+ registry = DefaultRegistry
+ repositoryAndTag = reference
+ default:
+ switch {
+ case splits[0] == "docker.io":
+ registry = DefaultRegistry
+ repositoryAndTag = strings.Join(splits[1:], "/")
+ case splits[0] == "localhost" || strings.Contains(splits[0], ".") || strings.Contains(splits[0], ":"):
+ registry = splits[0]
+ repositoryAndTag = strings.Join(splits[1:], "/")
+ default:
+ registry = DefaultRegistry
+ repositoryAndTag = reference
+ }
+ }
+
+ repositoryAndTag = strings.Split(repositoryAndTag, "@")[0]
+ tagSplits := strings.Split(repositoryAndTag, ":")
+ var repository, tag string
+ switch len(tagSplits) {
+ case 1:
+ repository = tagSplits[0]
+ tag = "latest"
+ case 2:
+ repository = tagSplits[0]
+ tag = tagSplits[1]
+ default:
+ return "", "", "", fmt.Errorf("invalid reference format: %s", repositoryAndTag)
+ }
+
+ if !strings.Contains(repository, "/") && registry == DefaultRegistry {
+ repository = "library/" + repository
+ }
+ return registry, repository, tag, nil
+}
+
+// ExtractRegistryDomain normalizes docker hub to docker.io
+func ExtractRegistryDomain(imageRef string) (string, error) {
+ c := NewClient()
+ reg, _, _, err := c.SplitImageReference(imageRef)
+ if err != nil {
+ return "", err
+ }
+ if reg == DefaultRegistry {
+ return "docker.io", nil
+ }
+ return reg, nil
+}
diff --git a/backend/internal/utils/registry/registry_test.go b/backend/internal/utils/registry/registry_test.go
new file mode 100644
index 000000000..cb29af6bb
--- /dev/null
+++ b/backend/internal/utils/registry/registry_test.go
@@ -0,0 +1,150 @@
+package registry
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strings"
+ "testing"
+ "time"
+)
+
+func TestSplitImageReference(t *testing.T) {
+ t.Parallel()
+ c := NewClient()
+ tests := []struct {
+ ref, reg, repo, tag string
+ }{
+ {"nginx", DefaultRegistry, "library/nginx", "latest"},
+ {"nginx:alpine", DefaultRegistry, "library/nginx", "alpine"},
+ {"docker.io/library/redis:7", DefaultRegistry, "library/redis", "7"},
+ {"ghcr.io/acme/api:1.2.3", "ghcr.io", "acme/api", "1.2.3"},
+ }
+ for _, tc := range tests {
+ r, repo, tag, err := c.SplitImageReference(tc.ref)
+ if err != nil {
+ t.Fatalf("err: %v", err)
+ }
+ if r != tc.reg || repo != tc.repo || tag != tc.tag {
+ t.Fatalf("got (%s,%s,%s) want (%s,%s,%s)", r, repo, tag, tc.reg, tc.repo, tc.tag)
+ }
+ }
+}
+
+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)
+ }
+}
+
+func TestGetImageTagsPagination(t *testing.T) {
+ t.Parallel()
+ var server *httptest.Server
+ type tagsResp struct {
+ Tags []string `json:"tags"`
+ }
+ handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.URL.Path == "/v2/org/repo/tags/list" && (r.URL.RawQuery == "" || r.URL.RawQuery == "page=1"):
+ page2 := server.URL + "/v2/org/repo/tags/list?page=2"
+ w.Header().Set("Link", `<`+page2+`>; rel="next"`)
+ if err := json.NewEncoder(w).Encode(tagsResp{Tags: []string{"a", "b"}}); err != nil {
+ http.Error(w, "encode error: "+err.Error(), http.StatusInternalServerError)
+ }
+ case r.URL.Path == "/v2/org/repo/tags/list" && r.URL.RawQuery == "page=2":
+ if err := json.NewEncoder(w).Encode(tagsResp{Tags: []string{"c"}}); err != nil {
+ http.Error(w, "encode error: "+err.Error(), http.StatusInternalServerError)
+ }
+ default:
+ http.NotFound(w, r)
+ }
+ })
+ server = httptest.NewServer(handler)
+ defer server.Close()
+
+ c := NewClient()
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+
+ tags, err := c.GetImageTags(ctx, server.URL, "org/repo", "")
+ if err != nil {
+ t.Fatalf("err: %v", err)
+ }
+ if strings.Join(tags, ",") != "a,b,c" {
+ t.Fatalf("tags %v", tags)
+ }
+}
diff --git a/backend/internal/utils/registry/tags.go b/backend/internal/utils/registry/tags.go
new file mode 100644
index 000000000..26d86a85b
--- /dev/null
+++ b/backend/internal/utils/registry/tags.go
@@ -0,0 +1,89 @@
+package registry
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "strings"
+ "time"
+)
+
+func (c *Client) GetImageTags(ctx context.Context, registry, repository, token string) ([]string, error) {
+ url := fmt.Sprintf("%s/v2/%s/tags/list", c.GetRegistryURL(registry), repository)
+
+ var all []string
+ next := url
+ for next != "" {
+ reqCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+ defer cancel()
+
+ req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, next, nil)
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Accept", "application/json")
+ if token != "" {
+ req.Header.Set("Authorization", "Bearer "+token)
+ }
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ func() {
+ defer resp.Body.Close()
+ if resp.StatusCode == http.StatusUnauthorized {
+ h := resp.Header.Get("WWW-Authenticate")
+ if h == "" {
+ h = resp.Header.Get("Www-Authenticate")
+ }
+ if h != "" {
+ err = fmt.Errorf("unauthorized: %s", h)
+ } else {
+ err = fmt.Errorf("tags request failed with status: 401")
+ }
+ return
+ }
+ if resp.StatusCode != http.StatusOK {
+ err = fmt.Errorf("tags request failed with status: %d", resp.StatusCode)
+ return
+ }
+ var body struct {
+ Tags []string `json:"tags"`
+ }
+ if decErr := json.NewDecoder(resp.Body).Decode(&body); decErr != nil {
+ err = decErr
+ return
+ }
+ all = append(all, body.Tags...)
+ next = parseLinkHeader(resp.Header.Get("Link"))
+ }()
+ if err != nil {
+ return nil, err
+ }
+ }
+ return all, nil
+}
+
+func (c *Client) GetImageTagsTimed(ctx context.Context, registry, repository, token string) ([]string, time.Duration, error) {
+ start := time.Now()
+ t, err := c.GetImageTags(ctx, registry, repository, token)
+ return t, time.Since(start), err
+}
+
+func parseLinkHeader(h string) string {
+ if h == "" {
+ return ""
+ }
+ for _, part := range strings.Split(h, ",") {
+ p := strings.TrimSpace(part)
+ if strings.Contains(p, `rel="next"`) {
+ l := strings.Index(p, "<")
+ r := strings.Index(p, ">")
+ if l != -1 && r > l {
+ return p[l+1 : r]
+ }
+ }
+ }
+ return ""
+}
diff --git a/backend/internal/utils/registry/test_connection.go b/backend/internal/utils/registry/test_connection.go
new file mode 100644
index 000000000..6b5ba2b24
--- /dev/null
+++ b/backend/internal/utils/registry/test_connection.go
@@ -0,0 +1,72 @@
+package registry
+
+import (
+ "context"
+ "fmt"
+ "strings"
+ "time"
+)
+
+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"`
+}
+
+func TestRegistryConnection(ctx context.Context, registryURL string, creds *Credentials) (*TestResult, error) {
+ c := NewClient()
+ res := &TestResult{
+ URL: registryURL,
+ Domain: registryURL,
+ Timestamp: time.Now(),
+ Errors: []string{},
+ }
+
+ reg := trimScheme(registryURL)
+ if reg == "docker.io" {
+ reg = DefaultRegistry
+ }
+
+ authURL, err := c.CheckAuth(ctx, reg)
+ if err != nil {
+ res.Errors = append(res.Errors, fmt.Sprintf("Ping failed: %v", err))
+ res.PingSuccess = false
+ } else {
+ res.PingSuccess = true
+ }
+
+ if authURL != "" && creds != nil {
+ tok, err := c.GetToken(ctx, authURL, "library/hello-world", creds)
+ if err != nil {
+ res.Errors = append(res.Errors, fmt.Sprintf("Auth failed: %v", err))
+ res.AuthSuccess = false
+ } else {
+ res.AuthSuccess = tok != ""
+ }
+ } else {
+ res.AuthSuccess = authURL == ""
+ }
+
+ tags, err := c.GetImageTags(ctx, reg, "library/hello-world", "")
+ if err != nil {
+ res.Errors = append(res.Errors, fmt.Sprintf("Catalog failed: %v", err))
+ res.CatalogSuccess = false
+ } else {
+ res.CatalogSuccess = len(tags) > 0
+ }
+
+ res.OverallSuccess = res.PingSuccess && res.AuthSuccess && res.CatalogSuccess
+ return res, nil
+}
+
+func trimScheme(u string) string {
+ u = strings.TrimPrefix(u, "https://")
+ u = strings.TrimPrefix(u, "http://")
+ u = strings.TrimSuffix(u, "/")
+ return u
+}
diff --git a/backend/internal/utils/registry_utils.go b/backend/internal/utils/registry_utils.go
deleted file mode 100644
index f7f774ddf..000000000
--- a/backend/internal/utils/registry_utils.go
+++ /dev/null
@@ -1,383 +0,0 @@
-package utils
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "net/http"
- "regexp"
- "strings"
- "time"
-)
-
-const DEFAULT_REGISTRY = "registry-1.docker.io"
-
-// RegistryUtils provides helper methods for Docker/OCI registries.
-// A shared HTTP client is used; per-method timeouts are enforced via context.
-type RegistryUtils struct {
- client *http.Client
-}
-
-var (
- SemanticVersionRegex = regexp.MustCompile(`^(\d+)\.(\d+)\.(\d+)(?:-.*)?$`)
- DateVersionRegex = regexp.MustCompile(`^(\d{4})\.(\d{1,2})\.(\d{1,2})$`)
- NumericVersionRegex = regexp.MustCompile(`^(\d+)(?:\.(\d+))?(?:\.(\d+))?$`)
-)
-
-type RegistryCredentials struct {
- Username string
- Token string
-}
-
-type RegistryTestResult 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"`
-}
-
-func NewRegistryUtils() *RegistryUtils {
- return &RegistryUtils{
- client: &http.Client{}, // timeouts applied via context per request below
- }
-}
-
-// SplitImageReference splits an image reference into registry, repository, and tag.
-// Defaults: registry=docker hub, tag=latest. Strips any digest suffix.
-func (r *RegistryUtils) SplitImageReference(reference string) (string, string, string, error) {
- if reference == "" {
- return "", "", "", fmt.Errorf("empty reference provided")
- }
-
- splits := strings.Split(reference, "/")
- var registry, repositoryAndTag string
-
- switch len(splits) {
- case 1:
- registry = DEFAULT_REGISTRY
- repositoryAndTag = reference
- default:
- switch {
- case splits[0] == "docker.io":
- registry = DEFAULT_REGISTRY
- repositoryAndTag = strings.Join(splits[1:], "/")
- case splits[0] == "localhost" || strings.Contains(splits[0], ".") || strings.Contains(splits[0], ":"):
- registry = splits[0]
- repositoryAndTag = strings.Join(splits[1:], "/")
- default:
- registry = DEFAULT_REGISTRY
- repositoryAndTag = reference
- }
- }
-
- // strip any digest suffix
- repositoryAndTag = strings.Split(repositoryAndTag, "@")[0]
-
- tagSplits := strings.Split(repositoryAndTag, ":")
- var repository, tag string
-
- switch len(tagSplits) {
- case 1:
- repository = tagSplits[0]
- tag = "latest"
- case 2:
- repository = tagSplits[0]
- tag = tagSplits[1]
- default:
- return "", "", "", fmt.Errorf("invalid reference format: too many colons in %s", repositoryAndTag)
- }
-
- repositoryComponents := strings.Split(repository, "/")
- if len(repositoryComponents) == 1 && registry == DEFAULT_REGISTRY {
- repository = "library/" + repository
- }
-
- return registry, repository, tag, nil
-}
-
-func (r *RegistryUtils) GetRegistryURL(registry string) string {
- switch registry {
- case DEFAULT_REGISTRY, "docker.io":
- return "https://index.docker.io"
- default:
- if !strings.HasPrefix(registry, "http") {
- return "https://" + registry
- }
- return registry
- }
-}
-
-// CheckAuth pings the v2 endpoint and returns the auth realm URL if auth is required.
-func (r *RegistryUtils) CheckAuth(ctx context.Context, registry string) (string, error) {
- url := fmt.Sprintf("%s/v2/", r.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 := r.client.Do(req)
- if err != nil {
- return "", err
- }
- defer resp.Body.Close()
-
- if resp.StatusCode == http.StatusUnauthorized {
- authHeader := resp.Header.Get("WWW-Authenticate")
- if authHeader != "" {
- authURL := r.parseWWWAuthenticate(authHeader)
- return authURL, nil
- }
- }
-
- return "", nil
-}
-
-func (r *RegistryUtils) parseWWWAuthenticate(header string) string {
- if strings.HasPrefix(header, "Bearer ") {
- parts := strings.Split(header[7:], ",")
- for _, part := range parts {
- part = strings.TrimSpace(part)
- if strings.HasPrefix(part, "realm=") {
- realm := strings.Trim(part[6:], `"`)
- return realm
- }
- }
- }
- return ""
-}
-
-func (r *RegistryUtils) getServiceName(authURL string) string {
- if strings.Contains(authURL, "auth.docker.io") {
- return "registry.docker.io"
- }
-
- urlParts := strings.Split(strings.TrimPrefix(authURL, "https://"), "/")
- if len(urlParts) > 0 {
- return urlParts[0]
- }
- return "registry"
-}
-
-// GetToken fetches a Bearer token for the given repository scope.
-func (r *RegistryUtils) GetToken(ctx context.Context, authURL, repository string, credentials *RegistryCredentials) (string, error) {
- serviceName := r.getServiceName(authURL)
- tokenURL := fmt.Sprintf("%s?service=%s&scope=repository:%s:pull", authURL, serviceName, repository)
-
- ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
- defer cancel()
-
- req, err := http.NewRequestWithContext(ctx, http.MethodGet, tokenURL, nil)
- if err != nil {
- return "", err
- }
-
- if credentials != nil && credentials.Username != "" && credentials.Token != "" {
- req.SetBasicAuth(credentials.Username, credentials.Token)
- }
-
- resp, err := r.client.Do(req)
- if err != nil {
- return "", err
- }
- defer resp.Body.Close()
-
- if resp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("token request failed with status: %d", resp.StatusCode)
- }
-
- var tokenResp struct {
- Token string `json:"token"`
- }
-
- if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
- return "", err
- }
-
- return tokenResp.Token, nil
-}
-
-// GetLatestDigest returns the current manifest digest for the given repository:tag.
-func (r *RegistryUtils) GetLatestDigest(ctx context.Context, registry, repository, tag string, token string) (string, error) {
- url := fmt.Sprintf("%s/v2/%s/manifests/%s", r.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.Set("Accept", "application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.docker.distribution.manifest.v2+json, application/vnd.oci.image.index.v1+json")
-
- if token != "" {
- req.Header.Set("Authorization", "Bearer "+token)
- }
-
- resp, err := r.client.Do(req)
- if err != nil {
- return "", err
- }
- defer resp.Body.Close()
-
- if resp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("manifest request failed with status: %d", resp.StatusCode)
- }
-
- digest := resp.Header.Get("Docker-Content-Digest")
- if digest == "" {
- digest = resp.Header.Get("docker-content-digest")
- }
- if digest == "" {
- etag := resp.Header.Get("Etag")
- if etag != "" && strings.HasPrefix(etag, "sha256:") {
- digest = strings.Trim(etag, `"`)
- }
- }
-
- if digest == "" {
- return "", fmt.Errorf("no digest header found in response")
- }
-
- return digest, nil
-}
-
-// GetImageTags returns all tags for the given repository, following pagination.
-func (r *RegistryUtils) GetImageTags(ctx context.Context, registry, repository string, token string) ([]string, error) {
- url := fmt.Sprintf("%s/v2/%s/tags/list", r.GetRegistryURL(registry), repository)
-
- var allTags []string
- nextURL := url
-
- for nextURL != "" {
- ctxReq, cancel := context.WithTimeout(ctx, 30*time.Second)
- defer cancel()
-
- req, err := http.NewRequestWithContext(ctxReq, http.MethodGet, nextURL, nil)
- if err != nil {
- return nil, err
- }
-
- req.Header.Set("Accept", "application/json")
-
- if token != "" {
- req.Header.Set("Authorization", "Bearer "+token)
- }
-
- resp, err := r.client.Do(req)
- if err != nil {
- return nil, err
- }
- defer resp.Body.Close()
-
- if resp.StatusCode != http.StatusOK {
- return nil, fmt.Errorf("tags request failed with status: %d", resp.StatusCode)
- }
-
- var tagsResp struct {
- Tags []string `json:"tags"`
- }
- if err := json.NewDecoder(resp.Body).Decode(&tagsResp); err != nil {
- return nil, err
- }
-
- allTags = append(allTags, tagsResp.Tags...)
-
- linkHeader := resp.Header.Get("Link")
- nextURL = r.parseLinkHeader(linkHeader)
- }
-
- return allTags, nil
-}
-
-func (r *RegistryUtils) parseLinkHeader(linkHeader string) string {
- if linkHeader == "" {
- return ""
- }
-
- parts := strings.Split(linkHeader, ",")
- for _, part := range parts {
- part = strings.TrimSpace(part)
- if strings.Contains(part, `rel="next"`) {
- start := strings.Index(part, "<")
- end := strings.Index(part, ">")
- if start != -1 && end != -1 && end > start {
- return part[start+1 : end]
- }
- }
- }
-
- return ""
-}
-
-// TestRegistryConnection runs a simple ping/auth/tags check against a registry.
-func TestRegistryConnection(ctx context.Context, registryURL string, credentials *RegistryCredentials) (*RegistryTestResult, error) {
- registryUtils := NewRegistryUtils()
-
- result := &RegistryTestResult{
- URL: registryURL,
- Domain: registryURL,
- Timestamp: time.Now(),
- Errors: []string{},
- }
-
- registry := strings.TrimPrefix(strings.TrimPrefix(registryURL, "https://"), "http://")
- if registry == "docker.io" {
- registry = DEFAULT_REGISTRY
- }
-
- authURL, err := registryUtils.CheckAuth(ctx, registry)
- if err != nil {
- result.Errors = append(result.Errors, fmt.Sprintf("Ping failed: %v", err))
- result.PingSuccess = false
- } else {
- result.PingSuccess = true
- }
-
- if authURL != "" && credentials != nil {
- token, err := registryUtils.GetToken(ctx, authURL, "library/hello-world", credentials)
- if err != nil {
- result.Errors = append(result.Errors, fmt.Sprintf("Auth failed: %v", err))
- result.AuthSuccess = false
- } else {
- result.AuthSuccess = token != ""
- }
- } else {
- result.AuthSuccess = authURL == ""
- }
-
- tags, err := registryUtils.GetImageTags(ctx, registry, "library/hello-world", "")
- if err != nil {
- result.Errors = append(result.Errors, fmt.Sprintf("Catalog access failed: %v", err))
- result.CatalogSuccess = false
- } else {
- result.CatalogSuccess = len(tags) > 0
- }
-
- result.OverallSuccess = result.PingSuccess && result.AuthSuccess && result.CatalogSuccess
-
- return result, nil
-}
-
-// ExtractRegistryDomain normalizes the image ref to a registry domain (docker.io for hub).
-func ExtractRegistryDomain(imageRef string) (string, error) {
- registryUtils := NewRegistryUtils()
- registry, _, _, err := registryUtils.SplitImageReference(imageRef)
- if err != nil {
- return "", fmt.Errorf("failed to extract registry domain: %w", err)
- }
-
- if registry == DEFAULT_REGISTRY {
- return "docker.io", nil
- }
-
- return registry, nil
-}
diff --git a/backend/internal/utils/registry_utils_test.go b/backend/internal/utils/registry_utils_test.go
deleted file mode 100644
index a0b048c8b..000000000
--- a/backend/internal/utils/registry_utils_test.go
+++ /dev/null
@@ -1,267 +0,0 @@
-package utils
-
-import (
- "context"
- "encoding/base64"
- "encoding/json"
- "net/http"
- "net/http/httptest"
- "strings"
- "testing"
- "time"
-)
-
-func TestSplitImageReference(t *testing.T) {
- t.Parallel()
-
- tests := []struct {
- name string
- ref string
- wantReg string
- wantRepo string
- wantTag string
- wantError bool
- }{
- {
- name: "docker hub short name adds library and latest",
- ref: "nginx",
- wantReg: DEFAULT_REGISTRY,
- wantRepo: "library/nginx",
- wantTag: "latest",
- },
- {
- name: "docker hub explicit tag",
- ref: "nginx:alpine",
- wantReg: DEFAULT_REGISTRY,
- wantRepo: "library/nginx",
- wantTag: "alpine",
- },
- {
- name: "docker.io prefix normalizes to default",
- ref: "docker.io/library/redis:7",
- wantReg: DEFAULT_REGISTRY,
- wantRepo: "library/redis",
- wantTag: "7",
- },
- {
- name: "ghcr with org/repo:tag",
- ref: "ghcr.io/acme/api:1.2.3",
- wantReg: "ghcr.io",
- wantRepo: "acme/api",
- wantTag: "1.2.3",
- },
- {
- name: "ghcr default tag latest",
- ref: "ghcr.io/owner/repo",
- wantReg: "ghcr.io",
- wantRepo: "owner/repo",
- wantTag: "latest",
- },
- {
- name: "localhost registry with port",
- ref: "localhost:5000/myrepo:dev",
- wantReg: "localhost:5000",
- wantRepo: "myrepo",
- wantTag: "dev",
- },
- {
- name: "strip digest suffix",
- ref: "ghcr.io/acme/api:1.2.3@sha256:deadbeef",
- wantReg: "ghcr.io",
- wantRepo: "acme/api",
- wantTag: "1.2.3",
- },
- }
-
- r := NewRegistryUtils()
- for _, tc := range tests {
- t.Run(tc.name, func(t *testing.T) {
- reg, repo, tag, err := r.SplitImageReference(tc.ref)
- if tc.wantError {
- if err == nil {
- t.Fatalf("expected error, got nil")
- }
- return
- }
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if reg != tc.wantReg || repo != tc.wantRepo || tag != tc.wantTag {
- t.Fatalf("got (%q,%q,%q), want (%q,%q,%q)", reg, repo, tag, tc.wantReg, tc.wantRepo, tc.wantTag)
- }
- })
- }
-}
-
-func TestGetRegistryURL(t *testing.T) {
- t.Parallel()
-
- r := NewRegistryUtils()
- if got := r.GetRegistryURL("docker.io"); got != "https://index.docker.io" {
- t.Fatalf("docker.io mapped to %q, want https://index.docker.io", got)
- }
- if got := r.GetRegistryURL(DEFAULT_REGISTRY); got != "https://index.docker.io" {
- t.Fatalf("DEFAULT_REGISTRY mapped to %q, want https://index.docker.io", got)
- }
- if got := r.GetRegistryURL("ghcr.io"); got != "https://ghcr.io" {
- t.Fatalf("ghcr.io mapped to %q, want https://ghcr.io", got)
- }
- if got := r.GetRegistryURL("https://custom.registry:8443"); got != "https://custom.registry:8443" {
- t.Fatalf("https url changed to %q", got)
- }
-}
-
-func TestExtractRegistryDomain(t *testing.T) {
- t.Parallel()
-
- tests := []struct {
- ref string
- want string
- }{
- {"nginx:alpine", "docker.io"},
- {"docker.io/library/redis:7", "docker.io"},
- {"ghcr.io/acme/api:1.2.3", "ghcr.io"},
- {"localhost:5000/repo:dev", "localhost:5000"},
- }
-
- for _, tc := range tests {
- t.Run(tc.ref, func(t *testing.T) {
- got, err := ExtractRegistryDomain(tc.ref)
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if got != tc.want {
- t.Fatalf("got %q, want %q", got, tc.want)
- }
- })
- }
-}
-
-func TestCheckAuthParsesRealm(t *testing.T) {
- t.Parallel()
-
- realm := "https://auth.example/token"
- 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="example.org"`)
- http.Error(w, "unauthorized", http.StatusUnauthorized)
- return
- }
- w.WriteHeader(http.StatusOK)
- }))
- defer srv.Close()
-
- utils := NewRegistryUtils()
- got, err := utils.CheckAuth(context.Background(), srv.URL)
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if got != realm {
- t.Fatalf("realm = %q, want %q", got, realm)
- }
-}
-
-func TestGetToken(t *testing.T) {
- t.Parallel()
-
- // Fake auth server returning a token
- srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if ah := r.Header.Get("Authorization"); ah != "" {
- if !strings.HasPrefix(ah, "Basic ") {
- t.Fatalf("expected Basic auth header, got %q", ah)
- }
- if _, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(ah, "Basic ")); err != nil {
- t.Fatalf("bad basic auth header: %v", err)
- }
- }
-
- _ = r.ParseForm()
- _, _ = r.Form.Get("service"), r.Form.Get("scope")
-
- if err := json.NewEncoder(w).Encode(map[string]string{"token": "abc123"}); err != nil {
- t.Fatalf("encode token response: %v", err)
- }
- }))
- defer srv.Close()
-
- utils := NewRegistryUtils()
- token, err := utils.GetToken(context.Background(), srv.URL, "library/hello-world", &RegistryCredentials{
- Username: "user",
- Token: "pass",
- })
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if token != "abc123" {
- t.Fatalf("token = %q, want abc123", token)
- }
-}
-
-func TestGetLatestDigest(t *testing.T) {
- t.Parallel()
-
- // Fake registry returning a digest header on HEAD
- 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)
- }
- if !strings.Contains(r.Header.Get("Accept"), "manifest") {
- t.Fatalf("missing Accept header for manifests")
- }
- w.Header().Set("Docker-Content-Digest", "sha256:deadbeef")
- w.WriteHeader(http.StatusOK)
- }))
- defer srv.Close()
-
- utils := NewRegistryUtils()
- digest, err := utils.GetLatestDigest(context.Background(), srv.URL, "org/repo", "latest", "")
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- if digest != "sha256:deadbeef" {
- t.Fatalf("digest = %q, want sha256:deadbeef", digest)
- }
-}
-
-func TestGetImageTagsPagination(t *testing.T) {
- t.Parallel()
-
- var server *httptest.Server
-
- type tagsResp struct {
- Tags []string `json:"tags"`
- }
-
- handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- switch {
- case r.URL.Path == "/v2/org/repo/tags/list" && (r.URL.RawQuery == "" || r.URL.RawQuery == "page=1"):
- page2URL := server.URL + "/v2/org/repo/tags/list?page=2"
- w.Header().Set("Link", `<`+page2URL+`>; rel="next"`)
- if err := json.NewEncoder(w).Encode(tagsResp{Tags: []string{"a", "b"}}); err != nil {
- t.Fatalf("encode page1: %v", err)
- }
- case r.URL.Path == "/v2/org/repo/tags/list" && r.URL.RawQuery == "page=2":
- if err := json.NewEncoder(w).Encode(tagsResp{Tags: []string{"c"}}); err != nil {
- t.Fatalf("encode page2: %v", err)
- }
- default:
- http.NotFound(w, r)
- }
- })
-
- server = httptest.NewServer(handler)
- defer server.Close()
-
- utils := NewRegistryUtils()
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
- defer cancel()
-
- tags, err := utils.GetImageTags(ctx, server.URL, "org/repo", "")
- if err != nil {
- t.Fatalf("unexpected error: %v", err)
- }
- got := strings.Join(tags, ",")
- if got != "a,b,c" {
- t.Fatalf("tags = %q, want %q", got, "a,b,c")
- }
-}
diff --git a/docker-compose.yml b/docker-compose.yml
index 67bcafb6b..1d605c2a9 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -7,7 +7,7 @@ services:
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- arcane-data:/app/data
- - /host/path/to/stacks:/app/data/projects
+ - /host/path/to/projects:/app/data/projects
environment:
- PUID=1000
- PGID=1000