Skip to content

Modern Docker Management, Designed for Everyone

fix: remove tag based update logic and only use digests (#627)

Kyle Mendell8f76e1ca0916
diff --git a/backend/internal/api/image_update_handler.go b/backend/internal/api/image_update_handler.go
index 30768cc32..5e00abbb3 100644
--- a/backend/internal/api/image_update_handler.go
+++ b/backend/internal/api/image_update_handler.go
@@ -2,7 +2,6 @@ package api
import (
"net/http"
- "strconv"
"github.com/gin-gonic/gin"
"github.com/ofkm/arcane-backend/internal/dto"
@@ -25,8 +24,6 @@ func NewImageUpdateHandler(group *gin.RouterGroup, imageUpdateService *services.
apiGroup.POST("/check-batch", handler.CheckMultipleImages)
apiGroup.GET("/check-all", handler.CheckAllImages)
apiGroup.GET("/summary", handler.GetUpdateSummary)
- apiGroup.GET("/versions", handler.GetImageVersions)
- apiGroup.POST("/compare", handler.CompareVersions)
}
}
@@ -151,63 +148,3 @@ func (h *ImageUpdateHandler) GetUpdateSummary(c *gin.Context) {
"data": summary,
})
}
-
-func (h *ImageUpdateHandler) GetImageVersions(c *gin.Context) {
- imageRef := c.Query("imageRef")
- if imageRef == "" {
- c.JSON(http.StatusBadRequest, gin.H{
- "success": false,
- "error": "imageRef query parameter is required",
- })
- return
- }
-
- limitStr := c.DefaultQuery("limit", "20")
- limit, err := strconv.Atoi(limitStr)
- if err != nil {
- c.JSON(http.StatusBadRequest, gin.H{
- "success": false,
- "error": "Invalid limit parameter",
- })
- return
- }
-
- versions, err := h.imageUpdateService.GetAvailableVersions(c.Request.Context(), imageRef, limit)
- if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{
- "success": false,
- "error": "Failed to get image versions: " + err.Error(),
- })
- return
- }
-
- c.JSON(http.StatusOK, gin.H{
- "success": true,
- "data": versions,
- })
-}
-
-func (h *ImageUpdateHandler) CompareVersions(c *gin.Context) {
- var req dto.CompareVersionRequest
- if err := c.ShouldBindJSON(&req); err != nil {
- c.JSON(http.StatusBadRequest, gin.H{
- "success": false,
- "error": "Invalid request format",
- })
- return
- }
-
- comparison, err := h.imageUpdateService.CompareVersions(c.Request.Context(), req.ImageRef, req.CurrentVersion, req.TargetVersion)
- if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{
- "success": false,
- "error": "Failed to compare versions: " + err.Error(),
- })
- return
- }
-
- c.JSON(http.StatusOK, gin.H{
- "success": true,
- "data": comparison,
- })
-}
diff --git a/backend/internal/dto/image_update_dto.go b/backend/internal/dto/image_update_dto.go
index a8e39ab08..df3c76995 100644
--- a/backend/internal/dto/image_update_dto.go
+++ b/backend/internal/dto/image_update_dto.go
@@ -23,34 +23,12 @@ type ImageUpdateSummaryResponse struct {
TotalImages int `json:"totalImages"`
ImagesWithUpdates int `json:"imagesWithUpdates"`
DigestUpdates int `json:"digestUpdates"`
- TagUpdates int `json:"tagUpdates"`
ErrorsCount int `json:"errorsCount"`
}
-type ImageVersionsResponse struct {
- ImageRef string `json:"imageRef"`
- Current string `json:"current"`
- Versions []string `json:"versions"`
- Latest string `json:"latest,omitempty"`
-}
-
-type VersionComparisonResponse struct {
- CurrentVersion string `json:"currentVersion"`
- TargetVersion string `json:"targetVersion"`
- IsNewer bool `json:"isNewer"`
- UpdateType string `json:"updateType"`
- ChangeLevel string `json:"changeLevel"`
-}
-
type BatchImageUpdateRequest struct {
ImageRefs []string `json:"imageRefs" binding:"required"`
Credentials []ContainerRegistryCredential `json:"credentials,omitempty"`
}
type BatchImageUpdateResponse map[string]*ImageUpdateResponse
-
-type CompareVersionRequest struct {
- CurrentVersion string `json:"currentVersion" binding:"required"`
- TargetVersion string `json:"targetVersion" binding:"required"`
- ImageRef string `json:"imageRef" binding:"required"`
-}
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 74f27b2f7..f072fa02e 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -3,14 +3,13 @@ package services
import (
"context"
"fmt"
- "regexp"
- "strconv"
"strings"
"time"
"log/slog"
"sync"
+ ref "github.com/distribution/reference"
"github.com/docker/docker/api/types/image"
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/dto"
@@ -19,12 +18,6 @@ import (
registry "github.com/ofkm/arcane-backend/internal/utils/registry"
)
-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 {
db *database.DB
settingsService *SettingsService
@@ -39,13 +32,6 @@ type ImageParts struct {
Tag string
}
-type VersionInfo struct {
- Major *int `json:"major"`
- Minor *int `json:"minor"`
- Patch *int `json:"patch"`
- FormatStr string `json:"formatStr"`
-}
-
func NewImageUpdateService(db *database.DB, settingsService *SettingsService, registryService *ContainerRegistryService, dockerService *DockerClientService, eventService *EventService) *ImageUpdateService {
return &ImageUpdateService{
db: db,
@@ -96,57 +82,6 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri
return result, err
}
- if !digestResult.HasUpdate && !s.isSpecialTag(parts.Tag) {
- tagResult, err := s.checkTagUpdate(ctx, parts, registries)
- if err != nil {
- result := &dto.ImageUpdateResponse{
- Error: err.Error(),
- CheckTime: time.Now(),
- ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
- }
- metadata := models.JSON{
- "action": "check_update",
- "imageRef": imageRef,
- "error": err.Error(),
- "checkType": "tag",
- }
- if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "Failed to log image update check error event",
- 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),
- slog.String("error", saveErr.Error()))
- }
- return result, err
- }
- if tagResult.HasUpdate {
- tagResult.ResponseTimeMs = int(time.Since(startTime).Milliseconds())
- metadata := models.JSON{
- "action": "check_update",
- "imageRef": imageRef,
- "hasUpdate": true,
- "updateType": "tag",
- "currentVersion": tagResult.CurrentVersion,
- "latestVersion": tagResult.LatestVersion,
- "responseTimeMs": tagResult.ResponseTimeMs,
- }
- if logErr := s.eventService.LogImageEvent(ctx, models.EventTypeImageScan, "", imageRef, systemUser.ID, systemUser.Username, "0", metadata); logErr != nil {
- slog.WarnContext(ctx, "Failed to log image update check event",
- 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),
- slog.String("error", saveErr.Error()))
- }
- return tagResult, nil
- }
- }
-
digestResult.ResponseTimeMs = int(time.Since(startTime).Milliseconds())
metadata := models.JSON{
"action": "check_update",
@@ -233,15 +168,6 @@ func (s *ImageUpdateService) getRegistryToken(ctx context.Context, regHost, repo
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) {
rc := registry.NewClient()
@@ -267,12 +193,28 @@ func (s *ImageUpdateService) checkDigestUpdate(ctx context.Context, parts *Image
return nil, fmt.Errorf("failed to get remote digest: %w", err)
}
- localDigest, err := s.getLocalImageDigest(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
+ // Get local image and all its digests
+ localDigest, allLocalDigests, err := s.getLocalImageDigestWithAll(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
if err != nil {
return nil, fmt.Errorf("failed to get local digest: %w", err)
}
- hasUpdate := localDigest != remoteDigest
+ hasUpdate := true
+ for _, localDig := range allLocalDigests {
+ if localDig == remoteDigest {
+ localDigest = localDig
+ hasUpdate = false
+ break
+ }
+ }
+
+ slog.DebugContext(ctx, "digest comparison",
+ slog.String("imageRef", fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag)),
+ slog.String("primaryLocalDigest", localDigest),
+ slog.Any("allLocalDigests", allLocalDigests),
+ slog.String("remoteDigest", remoteDigest),
+ slog.Bool("hasUpdate", hasUpdate))
+
return &dto.ImageUpdateResponse{
HasUpdate: hasUpdate,
UpdateType: "digest",
@@ -287,208 +229,35 @@ func (s *ImageUpdateService) checkDigestUpdate(ctx context.Context, parts *Image
}, nil
}
-func (s *ImageUpdateService) checkTagUpdate(ctx context.Context, parts *ImageParts, registries []models.ContainerRegistry) (*dto.ImageUpdateResponse, error) {
- startTime := time.Now()
-
- currentVersion := s.parseVersion(parts.Tag)
- if currentVersion == nil {
- return &dto.ImageUpdateResponse{
- HasUpdate: false,
- UpdateType: "tag",
- CurrentVersion: parts.Tag,
- CheckTime: time.Now(),
- ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
- AuthRegistry: parts.Registry,
- AuthMethod: "unknown",
- }, nil
- }
-
- tags, auth, err := s.getImageTags(ctx, parts, registries)
- if err != nil {
- return nil, fmt.Errorf("failed to get tags: %w", err)
- }
-
- updateScope := s.getUpdateScope()
- latestVersion := s.findLatestCompatibleVersionWithScope(currentVersion, tags, updateScope)
- if latestVersion == nil {
- return &dto.ImageUpdateResponse{
- HasUpdate: false,
- UpdateType: "tag",
- CurrentVersion: parts.Tag,
- CheckTime: time.Now(),
- ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
- AuthMethod: auth.Method,
- AuthUsername: auth.Username,
- AuthRegistry: auth.Registry,
- UsedCredential: auth.Method == "credential",
- }, nil
- }
-
- hasUpdate := s.isNewerVersion(latestVersion, currentVersion)
- return &dto.ImageUpdateResponse{
- HasUpdate: hasUpdate,
- UpdateType: "tag",
- CurrentVersion: parts.Tag,
- LatestVersion: s.versionToString(latestVersion),
- CheckTime: time.Now(),
- ResponseTimeMs: int(time.Since(startTime).Milliseconds()),
- AuthMethod: auth.Method,
- AuthUsername: auth.Username,
- AuthRegistry: auth.Registry,
- UsedCredential: auth.Method == "credential",
- }, 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) {
- rc := registry.NewClient()
-
- token, auth, err := s.getRegistryToken(ctx, parts.Registry, parts.Repository, registries)
+func (s *ImageUpdateService) parseImageReference(imageRef string) *ImageParts {
+ // Use the official Docker reference parser to handle all edge cases
+ named, err := ref.ParseNormalizedNamed(imageRef)
if err != nil {
- return nil, nil, fmt.Errorf("failed to get registry token: %w", err)
+ // Fallback to manual parsing if the official parser fails
+ return s.parseImageReferenceFallback(imageRef)
}
- normalizedRepo := s.normalizeRepository(parts.Registry, parts.Repository)
- slog.DebugContext(ctx, "Fetching tags",
- slog.String("registry", parts.Registry),
- slog.String("repository", normalizedRepo),
- slog.String("authMethod", auth.Method),
- slog.String("authUser", auth.Username))
+ // Extract registry
+ registry := ref.Domain(named)
- tags, err := rc.GetImageTags(ctx, parts.Registry, normalizedRepo, token)
- if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
- enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)
- authHeader, method, username, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, "", enabledRegs)
- if resolveErr == nil && authHeader != "" {
- tags, err = rc.GetImageTags(ctx, parts.Registry, normalizedRepo, authHeader)
- if err == nil {
- // update auth info to reflect how we retried
- auth = &authDetails{Method: method, Username: username, Registry: parts.Registry}
- }
- }
- }
- if err != nil {
- return nil, nil, err
- }
- return tags, auth, nil
-}
+ // Extract repository (path without registry)
+ repository := ref.Path(named)
-func (s *ImageUpdateService) parseVersion(tag string) *VersionInfo {
- 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"}
- }
- 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"}
- }
- if matches := numericVersionRegex.FindStringSubmatch(tag); matches != nil {
- major, _ := strconv.Atoi(matches[1])
- var minor, patch *int
- if len(matches) > 2 && matches[2] != "" {
- m, _ := strconv.Atoi(matches[2])
- minor = &m
- }
- if len(matches) > 3 && matches[3] != "" {
- p, _ := strconv.Atoi(matches[3])
- patch = &p
- }
- return &VersionInfo{Major: &major, Minor: minor, Patch: patch, FormatStr: "numeric"}
+ // Extract tag
+ tag := "latest"
+ if tagged, ok := named.(ref.NamedTagged); ok {
+ tag = tagged.Tag()
}
- return nil
-}
-func (s *ImageUpdateService) isNewerVersion(newer, current *VersionInfo) bool {
- if newer.Major != nil && current.Major != nil {
- if *newer.Major > *current.Major {
- return true
- }
- if *newer.Major < *current.Major {
- return false
- }
- }
- if newer.Minor != nil && current.Minor != nil {
- if *newer.Minor > *current.Minor {
- return true
- }
- if *newer.Minor < *current.Minor {
- return false
- }
- }
- if newer.Patch != nil && current.Patch != nil {
- return *newer.Patch > *current.Patch
+ return &ImageParts{
+ Registry: registry,
+ Repository: repository,
+ Tag: tag,
}
- return false
}
-func (s *ImageUpdateService) parseImageReference(imageRef string) *ImageParts {
+// Fallback parser for cases where the official parser fails
+func (s *ImageUpdateService) parseImageReferenceFallback(imageRef string) *ImageParts {
var registryHost, repository, tag string
if strings.Contains(imageRef, "@sha256:") {
digestParts := strings.Split(imageRef, "@")
@@ -608,38 +377,45 @@ func (s *ImageUpdateService) getAllImageRefs(ctx context.Context, limit int) ([]
return imageRefs, nil
}
-func (s *ImageUpdateService) getLocalImageDigest(ctx context.Context, imageRef string) (string, error) {
+func (s *ImageUpdateService) getLocalImageDigestWithAll(ctx context.Context, imageRef string) (string, []string, error) {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
- return "", fmt.Errorf("failed to connect to Docker: %w", err)
+ return "", nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
inspectResponse, err := dockerClient.ImageInspect(ctx, imageRef)
if err != nil {
- return "", fmt.Errorf("failed to inspect image: %w", err)
+ return "", nil, fmt.Errorf("failed to inspect image: %w", err)
}
+
+ var allDigests []string
+ var primaryDigest string
+
+ // Extract all digests from RepoDigests
if len(inspectResponse.RepoDigests) > 0 {
- digestParts := strings.Split(inspectResponse.RepoDigests[0], "@")
- if len(digestParts) == 2 {
- return digestParts[1], nil
+ for _, repoDigest := range inspectResponse.RepoDigests {
+ // Format: repository@sha256:...
+ digestParts := strings.Split(repoDigest, "@")
+ if len(digestParts) == 2 {
+ digest := digestParts[1]
+ allDigests = append(allDigests, digest)
+
+ // Use first digest as primary if not yet set
+ if primaryDigest == "" {
+ primaryDigest = digest
+ }
+ }
}
}
- return inspectResponse.ID, nil
-}
-func (s *ImageUpdateService) versionToString(v *VersionInfo) string {
- out := ""
- if v.Major != nil {
- out = strconv.Itoa(*v.Major)
- }
- if v.Minor != nil {
- out += "." + strconv.Itoa(*v.Minor)
+ // Fallback to image ID if no repo digests available
+ if primaryDigest == "" {
+ primaryDigest = inspectResponse.ID
+ allDigests = []string{primaryDigest}
}
- if v.Patch != nil {
- out += "." + strconv.Itoa(*v.Patch)
- }
- return out
+
+ return primaryDigest, allDigests, nil
}
// Returns all enabled credentials whose URL matches the image registry domain (normalized)
@@ -700,20 +476,6 @@ func (s *ImageUpdateService) normalizeRepository(regHost, repo string) string {
return repo
}
-func (s *ImageUpdateService) isSpecialTag(tag string) bool {
- special := []string{
- "latest", "stable", "unstable", "dev", "devel", "development",
- "test", "testing", "prod", "production", "main", "master",
- "stage", "staging", "canary", "nightly", "edge", "next",
- }
- for _, v := range special {
- if tag == v {
- return true
- }
- }
- return false
-}
-
func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID string) (*dto.ImageUpdateResponse, error) {
imageRef, err := s.getImageRefByID(ctx, imageID)
if err != nil {
@@ -1015,7 +777,6 @@ func (s *ImageUpdateService) checkSingleImageInBatch(
authMap map[string]regAuth,
enabledRegs []models.ContainerRegistry,
parts *ImageParts,
- updateScope string,
) *dto.ImageUpdateResponse {
start := time.Now()
@@ -1046,7 +807,7 @@ func (s *ImageUpdateService) checkSingleImageInBatch(
}
}
- localDigest, ldErr := s.getLocalImageDigest(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
+ localDigest, allLocalDigests, ldErr := s.getLocalImageDigestWithAll(ctx, fmt.Sprintf("%s/%s:%s", parts.Registry, parts.Repository, parts.Tag))
if ldErr != nil {
return &dto.ImageUpdateResponse{
Error: ldErr.Error(),
@@ -1059,29 +820,12 @@ func (s *ImageUpdateService) checkSingleImageInBatch(
}
}
- 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",
- }
- }
- }
+ hasDigestUpdate := true
+ for _, localDig := range allLocalDigests {
+ if localDig == remoteDigest {
+ localDigest = localDig
+ hasDigestUpdate = false
+ break
}
}
@@ -1117,7 +861,6 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
regAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)
- updateScope := s.getUpdateScope()
outCh := make(chan struct {
ref string
res *dto.ImageUpdateResponse
@@ -1128,7 +871,7 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefs
for _, img := range images {
go func(bi batchImage) {
defer wg.Done()
- res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, bi.parts, updateScope)
+ res := s.checkSingleImageInBatch(ctx, rc, regAuthMap, enabledRegs, bi.parts)
outCh <- struct {
ref string
res *dto.ImageUpdateResponse
@@ -1224,75 +967,6 @@ func (s *ImageUpdateService) GetUpdateSummary(ctx context.Context) (*dto.ImageUp
TotalImages: int(totalImages),
ImagesWithUpdates: int(imagesWithUpdates),
DigestUpdates: int(digestUpdates),
- TagUpdates: int(tagUpdates),
ErrorsCount: int(errorsCount),
}, nil
}
-
-func (s *ImageUpdateService) GetAvailableVersions(ctx context.Context, imageRef string, limit int) (*dto.ImageVersionsResponse, error) {
- parts := s.parseImageReference(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 {
- updateScope := s.getUpdateScope()
- if latestVersion := s.findLatestCompatibleVersionWithScope(currentVersion, tags, updateScope); latestVersion != nil {
- latest = s.versionToString(latestVersion)
- }
- }
- return &dto.ImageVersionsResponse{
- ImageRef: imageRef,
- Current: parts.Tag,
- Versions: tags,
- Latest: latest,
- }, nil
-}
-
-func (s *ImageUpdateService) CompareVersions(ctx context.Context, imageRef, currentVersion, targetVersion string) (*dto.VersionComparisonResponse, error) {
- currentVer := s.parseVersion(currentVersion)
- targetVer := s.parseVersion(targetVersion)
-
- if currentVer == nil || targetVer == nil {
- return &dto.VersionComparisonResponse{
- CurrentVersion: currentVersion,
- TargetVersion: targetVersion,
- IsNewer: false,
- UpdateType: "unknown",
- ChangeLevel: "unknown",
- }, nil
- }
-
- isNewer := s.isNewerVersion(targetVer, currentVer)
-
- var changeLevel string
- if currentVer.Major != nil && targetVer.Major != nil {
- switch {
- case *targetVer.Major > *currentVer.Major:
- changeLevel = "major"
- case targetVer.Minor != nil && currentVer.Minor != nil && *targetVer.Minor > *currentVer.Minor:
- changeLevel = "minor"
- default:
- changeLevel = "patch"
- }
- } else {
- changeLevel = "unknown"
- }
-
- return &dto.VersionComparisonResponse{
- CurrentVersion: currentVersion,
- TargetVersion: targetVersion,
- IsNewer: isNewer,
- UpdateType: currentVer.FormatStr,
- ChangeLevel: changeLevel,
- }, nil
-}
diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.go
new file mode 100644
index 000000000..244f0c8d4
--- /dev/null
+++ b/backend/internal/services/image_update_service_test.go
@@ -0,0 +1,271 @@
+package services
+
+import (
+ "testing"
+
+ ref "github.com/distribution/reference"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// TestParseImageReference tests the parseImageReference function with various image formats
+// This is used for digest-based update checking
+func TestImageUpdateService_ParseImageReference(t *testing.T) {
+ tests := []struct {
+ name string
+ imageRef string
+ wantRegistry string
+ wantRepository string
+ wantTag string
+ }{
+ {
+ name: "Docker Hub official image with tag",
+ imageRef: "redis:latest",
+ wantRegistry: "docker.io",
+ wantRepository: "library/redis",
+ wantTag: "latest",
+ },
+ {
+ name: "Docker Hub official image without tag",
+ imageRef: "nginx",
+ wantRegistry: "docker.io",
+ wantRepository: "library/nginx",
+ wantTag: "latest",
+ },
+ {
+ name: "Docker Hub user image",
+ imageRef: "traefik/traefik:v2.10",
+ wantRegistry: "docker.io",
+ wantRepository: "traefik/traefik",
+ wantTag: "v2.10",
+ },
+ {
+ name: "Custom registry with port",
+ imageRef: "localhost:5000/myapp:v1.0",
+ wantRegistry: "localhost:5000",
+ wantRepository: "myapp",
+ wantTag: "v1.0",
+ },
+ {
+ name: "Custom registry with subdomain",
+ imageRef: "docker.getoutline.com/outlinewiki/outline:latest",
+ wantRegistry: "docker.getoutline.com",
+ wantRepository: "outlinewiki/outline",
+ wantTag: "latest",
+ },
+ {
+ name: "GCR image",
+ imageRef: "gcr.io/google-containers/nginx:1.21",
+ wantRegistry: "gcr.io",
+ wantRepository: "google-containers/nginx",
+ wantTag: "1.21",
+ },
+ {
+ name: "GHCR image",
+ imageRef: "ghcr.io/owner/repo:main",
+ wantRegistry: "ghcr.io",
+ wantRepository: "owner/repo",
+ wantTag: "main",
+ },
+ {
+ name: "Multi-path repository",
+ imageRef: "registry.example.com/team/project/app:v2.0.0",
+ wantRegistry: "registry.example.com",
+ wantRepository: "team/project/app",
+ wantTag: "v2.0.0",
+ },
+ {
+ name: "Image with digest",
+ imageRef: "alpine@sha256:1234567890abcdef",
+ wantRegistry: "docker.io",
+ wantRepository: "library/alpine",
+ wantTag: "latest",
+ },
+ {
+ name: "Custom registry image with digest",
+ imageRef: "registry.io/app/service@sha256:abcdef123456",
+ wantRegistry: "registry.io",
+ wantRepository: "app/service",
+ wantTag: "latest",
+ },
+ }
+
+ svc := &ImageUpdateService{}
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ parts := svc.parseImageReference(tt.imageRef)
+ require.NotNil(t, parts, "parseImageReference returned nil")
+
+ assert.Equal(t, tt.wantRegistry, parts.Registry, "registry mismatch")
+ assert.Equal(t, tt.wantRepository, parts.Repository, "repository mismatch")
+ assert.Equal(t, tt.wantTag, parts.Tag, "tag mismatch")
+ })
+ }
+}
+
+// TestParseImageReference_Fallback tests edge cases that might trigger fallback parsing
+func TestImageUpdateService_ParseImageReference_Fallback(t *testing.T) {
+ svc := &ImageUpdateService{}
+
+ // Test malformed references that should still be parsed by fallback
+ tests := []struct {
+ name string
+ imageRef string
+ wantNil bool
+ }{
+ {
+ name: "Empty string",
+ imageRef: "",
+ wantNil: false, // Fallback should handle it
+ },
+ {
+ name: "Valid reference",
+ imageRef: "nginx:latest",
+ wantNil: false,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ parts := svc.parseImageReference(tt.imageRef)
+ if tt.wantNil {
+ assert.Nil(t, parts)
+ } else {
+ assert.NotNil(t, parts)
+ }
+ })
+ }
+}
+
+// TestNormalizeRepository tests repository normalization
+func TestImageUpdateService_NormalizeRepository(t *testing.T) {
+ tests := []struct {
+ name string
+ regHost string
+ repo string
+ wantNormal string
+ }{
+ {
+ name: "Docker Hub single name adds library",
+ regHost: "docker.io",
+ repo: "redis",
+ wantNormal: "library/redis",
+ },
+ {
+ name: "Docker Hub with slash unchanged",
+ regHost: "docker.io",
+ repo: "traefik/traefik",
+ wantNormal: "traefik/traefik",
+ },
+ {
+ name: "Custom registry unchanged",
+ regHost: "gcr.io",
+ repo: "project/app",
+ wantNormal: "project/app",
+ },
+ {
+ name: "Custom registry single name unchanged",
+ regHost: "gcr.io",
+ repo: "nginx",
+ wantNormal: "nginx",
+ },
+ }
+
+ svc := &ImageUpdateService{}
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ result := svc.normalizeRepository(tt.regHost, tt.repo)
+ assert.Equal(t, tt.wantNormal, result, "repository normalization mismatch")
+ })
+ }
+}
+
+// TestGetLocalImageDigestWithAll_ExtractsAllDigests tests that all digests are collected
+func TestImageUpdateService_GetLocalImageDigestWithAll_Logic(t *testing.T) {
+ // This is a unit test for the digest extraction logic
+ // In a real scenario, you'd need to mock Docker client
+ t.Run("Multiple digests in RepoDigests", func(t *testing.T) {
+ // This test demonstrates the expected behavior
+ // In practice, you'd use a mock Docker client
+ repoDigests := []string{
+ "docker.io/library/redis@sha256:abc123",
+ "redis@sha256:def456",
+ }
+
+ var allDigests []string
+ for _, repoDigest := range repoDigests {
+ parts := splitRepoDigest(repoDigest)
+ if parts != nil {
+ allDigests = append(allDigests, parts.digest)
+ }
+ }
+
+ assert.Len(t, allDigests, 2)
+ assert.Contains(t, allDigests, "sha256:abc123")
+ assert.Contains(t, allDigests, "sha256:def456")
+ })
+}
+
+// Helper function to test digest splitting
+type repoDigestParts struct {
+ repo string
+ digest string
+}
+
+func splitRepoDigest(repoDigest string) *repoDigestParts {
+ parts := splitString(repoDigest, "@")
+ if len(parts) == 2 {
+ return &repoDigestParts{
+ repo: parts[0],
+ digest: parts[1],
+ }
+ }
+ return nil
+}
+
+func splitString(s, sep string) []string {
+ var result []string
+ start := 0
+ for i := 0; i < len(s); i++ {
+ if s[i:i+len(sep)] == sep {
+ result = append(result, s[start:i])
+ start = i + len(sep)
+ i += len(sep) - 1
+ }
+ }
+ result = append(result, s[start:])
+ return result
+}
+
+// TestDockerReferenceCompatibility ensures our parser is compatible with Docker's reference package
+func TestImageUpdateService_DockerReferenceCompatibility(t *testing.T) {
+ tests := []struct {
+ name string
+ imageRef string
+ }{
+ {"Docker Hub official", "nginx:latest"},
+ {"Docker Hub user", "traefik/traefik:v2.0"},
+ {"Custom registry", "gcr.io/project/app:v1"},
+ {"With port", "localhost:5000/app:tag"},
+ {"Multi-path", "registry.io/team/project/app:latest"},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ // Test that official parser can handle it
+ named, err := ref.ParseNormalizedNamed(tt.imageRef)
+ require.NoError(t, err, "official parser failed")
+
+ // Test our parser
+ svc := &ImageUpdateService{}
+ parts := svc.parseImageReference(tt.imageRef)
+ require.NotNil(t, parts, "our parser returned nil")
+
+ // Verify they produce the same results
+ assert.Equal(t, ref.Domain(named), parts.Registry)
+ assert.Equal(t, ref.Path(named), parts.Repository)
+ })
+ }
+}