Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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 = ®istry.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.goindex 740e21413..1f2c2933e 100644--- a/backend/internal/services/image_update_service.go+++ b/backend/internal/services/image_update_service.go@@ -3,17 +3,27 @@ package servicesimport ("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 striCheckTime: 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 strislog.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 striCheckTime: 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 strislog.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 strislog.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 strislog.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 requiredif 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 credentialvar lastErr errorfor 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 = decErrcontinue}-- creds := &utils.RegistryCredentials{- Username: reg.Username,- Token: decrypted,- }- token, err := registryUtils.GetToken(ctx, authURL, repository, creds)+ creds := ®istry.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 *ImageParreturn 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 *ImagePartsslog.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 *intif 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 stringif 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 stringdefer 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 sif 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 eventmetadata := 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 striif 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 sif result.Error != "" {lastError = &result.Error}-var latestVersion *stringif result.LatestVersion != "" {latestVersion = &result.LatestVersion}-var currentDigest *stringif result.CurrentDigest != "" {currentDigest = &result.CurrentDigest}-var latestDigest *stringif result.LatestDigest != "" {latestDigest = &result.LatestDigest@@ -847,15 +796,13 @@ func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID scurrentVersion = image.Tag}- var authMethod *string+ var authMethod, authUsername, authRegistry *stringif result.AuthMethod != "" {authMethod = &result.AuthMethod}- var authUsername *stringif result.AuthUsername != "" {authUsername = &result.AuthUsername}- var authRegistry *stringif result.AuthRegistry != "" {authRegistry = &result.AuthRegistry}@@ -894,24 +841,286 @@ func (s *ImageUpdateService) getImageIDByRef(ctx context.Context, imageRef strinif 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 := ®istry.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) (mapif 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, imageIDsuccessCount := 0errorCount := 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 strfunc (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 int64s.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, imageRefif 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 stringcurrentVersion := 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.godeleted file mode 100644index 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.godeleted file mode 100644index 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.ymlindex 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/projectsenvironment:- PUID=1000- PGID=1000