Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 30768cc32..5e00abbb3 100644--- a/backend/internal/api/image_update_handler.go+++ b/backend/internal/api/image_update_handler.go@@ -2,7 +2,6 @@ package apiimport ("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.goindex 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.goindex 74f27b2f7..f072fa02e 100644--- a/backend/internal/services/image_update_service.go+++ b/backend/internal/services/image_update_service.go@@ -3,14 +3,13 @@ package servicesimport ("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.DBsettingsService *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 strireturn 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, reporeturn "", 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 *Imagereturn 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 stringif 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 RepoDigestsif 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, imageRefsregAuthMap := s.buildRegistryAuthMap(ctx, rc, regRepos, credMap)- updateScope := s.getUpdateScope()outCh := make(chan struct {ref stringres *dto.ImageUpdateResponse@@ -1128,7 +871,7 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefsfor _, 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 stringres *dto.ImageUpdateResponse@@ -1224,75 +967,6 @@ func (s *ImageUpdateService) GetUpdateSummary(ctx context.Context) (*dto.ImageUpTotalImages: 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.gonew file mode 100644index 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)+ })+ }+}