Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
feat: allow for tag based updates for containers (#3865)
Kyle Mendellf8f456a62b86
diff --git a/backend/go.mod b/backend/go.modindex d60537356..d60414e7d 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -72,7 +72,7 @@ require (go.getarcane.app/streams v0.4.3go.getarcane.app/sys/cgroup v0.2.3go.getarcane.app/sys/crypto v0.2.1- go.getarcane.app/updater v0.8.1+ go.getarcane.app/updater v0.9.1go.uber.org/fx v1.24.0go.yaml.in/yaml/v4 v4.0.0-rc.6golang.org/x/crypto v0.56.0diff --git a/backend/go.sum b/backend/go.sumindex 5d97a1305..52a7d411e 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -746,8 +746,8 @@ go.getarcane.app/sys/cgroup v0.2.3 h1:+eGLUC+3Ct+BNcPBQwC/g/psDOzjWN2vUr6KhKyNWggo.getarcane.app/sys/cgroup v0.2.3/go.mod h1:1ksFb/psBkQlOsS9D6OFydd9Evpb0mCoJzyCyb9RoL8=go.getarcane.app/sys/crypto v0.2.1 h1:A2HFmCRnDAj4/gl96apUifmw95verB5HCaPyNsHSAl8=go.getarcane.app/sys/crypto v0.2.1/go.mod h1:bA7dHfhnUCXl06+RxBJjwtoLR01J9WSZft6yoVnW4jE=-go.getarcane.app/updater v0.8.1 h1:KFI5xcC7e7Iug+hgCcWjj0pk4+u3gND3QluKVtEehzs=-go.getarcane.app/updater v0.8.1/go.mod h1:UGkeFc6Ev1eGDxB6P+/IA7twbzKPcbtbca8xdRLL3hs=+go.getarcane.app/updater v0.9.1 h1:kQsBIKRAEsCv1xgt7BMClStuNDj8JB2TrjY4djhgTa4=+go.getarcane.app/updater v0.9.1/go.mod h1:rMRAzw2KX5S8Ptjs4HAoN7inIHqxdSFsCHcrQWWK+vw=go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=diff --git a/backend/internal/container/service.go b/backend/internal/container/service.goindex 3100c917f..3d3239535 100644--- a/backend/internal/container/service.go+++ b/backend/internal/container/service.go@@ -41,7 +41,9 @@ import ("github.com/samber/hot"containerstats "go.getarcane.app/streams/stats""go.getarcane.app/sys/cgroup"+ "go.getarcane.app/updater""go.getarcane.app/updater/labels"+ "go.getarcane.app/updater/pkg/utils/tagpolicy")type ContainerService struct {@@ -550,7 +552,7 @@ func (s *ContainerService) tryRedeployViaComposeProjectInternal(ctx context.Cont"service", serviceName,)- if err := s.projectService.UpdateProjectServices(ctx, proj.ID, []string{serviceName}, user); err != nil {+ if err := s.projectService.UpdateProjectServices(ctx, proj.ID, []string{serviceName}, user, false); err != nil {s.eventService.LogErrorEvent(ctx, event.EventTypeContainerError, "container", containerID, containerName, user.ID, user.Username, "0", err, database.JSON{"action": "redeploy","step": "compose_update_services",@@ -1437,8 +1439,7 @@ func (s *ContainerService) ListContainersPaginated(}dockerContainers = FilterInternalContainers(dockerContainers, includeInternal)- imageIDs := CollectImageIDs(dockerContainers)- updateInfoMap := s.getUpdateInfoMapInternal(ctx, imageIDs)+ updateInfoMap := s.getUpdateInfoMapInternal(ctx, dockerContainers)currentContainerID, currentContainerErr := cgroup.CurrentContainerID()items := s.BuildSummaries(dockerContainers, updateInfoMap, currentContainerID, currentContainerErr)@@ -1604,24 +1605,46 @@ func CollectImageIDs(containers []container.Summary) []string {return imageIDs}-func (s *ContainerService) getUpdateInfoMapInternal(ctx context.Context, imageIDs []string) map[string]*imagetypes.UpdateInfo {- if s.imageService == nil || len(imageIDs) == 0 {- return make(map[string]*imagetypes.UpdateInfo)+func (s *ContainerService) getUpdateInfoMapInternal(ctx context.Context, containers []container.Summary) map[string]*imagetypes.UpdateInfo {+ result := make(map[string]*imagetypes.UpdateInfo)+ if s.imageService == nil || len(containers) == 0 {+ return result}-- updateInfoMap, err := s.imageService.GetUpdateInfoByImageIDs(ctx, imageIDs)+ updates, err := s.imageService.GetUpdateInfoByImageIDs(ctx, CollectImageIDs(containers))if err != nil {slog.WarnContext(ctx, "Failed to fetch image update info for containers", "error", err)- return make(map[string]*imagetypes.UpdateInfo)+ } else {+ maps.Copy(result, updates)+ }+ scoped, err := s.imageService.GetUpdateInfoByContainers(ctx, containers)+ if err != nil {+ slog.WarnContext(ctx, "Failed to fetch container tag update info", "error", err)+ return result+ }+ for id, info := range scoped {+ result["container::"+id] = info}- return updateInfoMap+ return result}func (s *ContainerService) BuildSummaries(containers []container.Summary, updateInfoMap map[string]*imagetypes.UpdateInfo, currentContainerID string, currentContainerErr error) []containertypes.Summary {items := make([]containertypes.Summary, 0, len(containers))for _, dc := range containers {summary := containertypes.NewSummary(dc)- if info, exists := updateInfoMap[dc.ImageID]; exists {+ key := dc.ImageID+ policy := updater.DefaultLabelPolicy().TagPolicy(dc.Labels)+ resolved, policyErr := tagpolicy.Resolve(dc.Image, policy)+ summary.UpdateStrategy = resolved.Strategy+ if policyErr != nil {+ summary.UpdateStrategy = policy.Strategy+ if summary.UpdateStrategy == "" {+ summary.UpdateStrategy = "auto"+ }+ }+ if policyErr != nil || resolved.Strategy == "tag" {+ key = "container::" + dc.ID+ }+ if info, exists := updateInfoMap[key]; exists {summary.UpdateInfo = info}summary.RedeployDisabled = labels.ShouldDisableArcaneServerRedeploy(summary.Labels, summary.ID, currentContainerID, currentContainerErr)diff --git a/backend/internal/container/service_test.go b/backend/internal/container/service_test.goindex e78fe7a10..b15848357 100644--- a/backend/internal/container/service_test.go+++ b/backend/internal/container/service_test.go@@ -554,3 +554,27 @@ func TestRecreateContainerDaemonCorrelationInternal(t *testing.T) {require.True(t, events.ShouldSuppressDaemonEvent("container", "old-id", "", ""))require.True(t, events.ShouldSuppressDaemonEvent("container", "new-id", "", ""))}++func TestBuildSummariesUsesContainerTagPolicyUpdates(t *testing.T) {+ service := &ContainerService{}+ strategyLabel := "com.getarcaneapp.arcane.updater.strategy"+ containers := []container.Summary{+ {ID: "first", Image: "app:3.1.0", ImageID: "shared-image"},+ {ID: "second", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{strategyLabel: "auto"}},+ {ID: "unchecked", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{strategyLabel: "tag"}},+ {ID: "digest", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{strategyLabel: "digest"}},+ }+ updates := map[string]*imagetypes.UpdateInfo{+ "shared-image": {HasUpdate: true, UpdateType: "digest"},+ "container::first": {HasUpdate: true, UpdateType: "tag", LatestVersion: "3.2.0"},+ "container::second": {HasUpdate: true, UpdateType: "tag", LatestVersion: "4.0.0"},+ }+ items := service.BuildSummaries(containers, updates, "", nil)+ require.Equal(t, "tag", items[0].UpdateStrategy)+ require.Equal(t, "tag", items[1].UpdateStrategy)+ require.Equal(t, "digest", items[3].UpdateStrategy)+ require.Equal(t, "3.2.0", items[0].UpdateInfo.LatestVersion)+ require.Equal(t, "4.0.0", items[1].UpdateInfo.LatestVersion)+ require.Nil(t, items[2].UpdateInfo)+ require.Equal(t, "digest", items[3].UpdateInfo.UpdateType)+}diff --git a/backend/internal/dashboard/service.go b/backend/internal/dashboard/service.goindex d65c10323..405e31c31 100644--- a/backend/internal/dashboard/service.go+++ b/backend/internal/dashboard/service.go@@ -37,7 +37,9 @@ import (versiontypes "github.com/getarcaneapp/arcane/types/v2/version"volumetypes "github.com/getarcaneapp/arcane/types/v2/volume""go.getarcane.app/sys/cgroup"+ "go.getarcane.app/updater""go.getarcane.app/updater/labels"+ "go.getarcane.app/updater/pkg/utils/tagpolicy")const (@@ -386,7 +388,7 @@ func (s *DashboardService) getPendingResourceUpdatesCountInternal(ctx context.CofilteredContainers := container.FilterInternalContainers(allContainers, false)standaloneContainers := filterStandaloneDockerContainersInternal(filteredContainers)- containerCount, err := s.getPendingContainerUpdatesCountForImageIDsInternal(ctx, container.CollectImageIDs(standaloneContainers))+ containerCount, err := s.getPendingContainerUpdatesCountInternal(ctx, standaloneContainers)if err != nil {return 0, err}@@ -410,20 +412,28 @@ func filterStandaloneDockerContainersInternal(containers []dockercontainer.Summareturn filtered}-func (s *DashboardService) getPendingContainerUpdatesCountForImageIDsInternal(ctx context.Context, imageIDs []string) (int, error) {- if s.db == nil || len(imageIDs) == 0 {+func (s *DashboardService) getPendingContainerUpdatesCountInternal(ctx context.Context, containers []dockercontainer.Summary) (int, error) {+ if s.db == nil || len(containers) == 0 {return 0, nil}-+ var imageIDs, containerIDs []string+ for _, c := range containers {+ if labels.IsUpdateDisabled(c.Labels) {+ continue+ }+ policy, policyErr := tagpolicy.Resolve(c.Image, updater.DefaultLabelPolicy().TagPolicy(c.Labels))+ if policyErr != nil || policy.Strategy == "tag" {+ containerIDs = append(containerIDs, c.ID)+ } else {+ imageIDs = append(imageIDs, c.ImageID)+ }+ }var count int64- err := s.db.WithContext(ctx).- Model(&imageupdate.ImageUpdateRecord{}).- Where("id IN ? AND has_update = ?", imageIDs, true).- Count(&count).Error+ err := s.db.WithContext(ctx).Model(&imageupdate.ImageUpdateRecord{}).+ Where("has_update = ? AND ((container_id = ? AND id IN ?) OR container_id IN ?)", true, "", imageIDs, containerIDs).Count(&count).Errorif err != nil {return 0, errors.WrapIf(err, "failed to count pending container updates")}-return int(count), nil}diff --git a/backend/internal/dashboard/service_test.go b/backend/internal/dashboard/service_test.goindex e782a6aae..401cdccf3 100644--- a/backend/internal/dashboard/service_test.go+++ b/backend/internal/dashboard/service_test.go@@ -39,6 +39,7 @@ import ("github.com/moby/moby/client""github.com/stretchr/testify/assert""github.com/stretchr/testify/require"+ "go.getarcane.app/updater/labels""go.uber.org/fx/fxtest""gorm.io/gorm")@@ -428,3 +429,29 @@ func TestDashboardService_GetSnapshot_CachesFullSnapshotsPerIconCatalog(t *testirequire.NoError(t, err)require.Same(t, userSnapshot, userAgain)}++func TestPendingContainerCountUsesScopedTagRecords(t *testing.T) {+ db, _ := setupDashboardServiceTestDB(t)+ records := []imageupdate.ImageUpdateRecord{+ {ID: "shared", HasUpdate: true},+ {ID: "container::first", ContainerID: "first", ImageID: "shared", HasUpdate: true},+ {ID: "container::other-project", ContainerID: "other-project", ImageID: "shared", HasUpdate: true},+ }+ require.NoError(t, db.Create(&records).Error)+ service := &DashboardService{db: db}+ containers := []dockercontainer.Summary{+ {ID: "first", Image: "app:1.2.3", ImageID: "shared", Labels: map[string]string{}},+ {ID: "unchecked", Image: "app:1.2.3", ImageID: "shared"},+ }+ count, err := service.getPendingContainerUpdatesCountInternal(t.Context(), containers)+ require.NoError(t, err)+ require.Equal(t, 1, count)+ containers = append(containers, dockercontainer.Summary{ID: "digest", Image: "app:latest", ImageID: "shared"})+ count, err = service.getPendingContainerUpdatesCountInternal(t.Context(), containers)+ require.NoError(t, err)+ require.Equal(t, 2, count)+ containers[0].Labels[labels.LabelUpdater] = "off"+ count, err = service.getPendingContainerUpdatesCountInternal(t.Context(), containers)+ require.NoError(t, err)+ require.Equal(t, 1, count)+}diff --git a/backend/internal/image/image.go b/backend/internal/image/image.goindex 6f2c0c00a..7d3188a42 100644--- a/backend/internal/image/image.go+++ b/backend/internal/image/image.go@@ -34,6 +34,9 @@ import ("github.com/moby/moby/client""github.com/samber/hot""github.com/samber/mo"+ "go.getarcane.app/updater"+ "go.getarcane.app/updater/labels"+ "go.getarcane.app/updater/pkg/utils/tagpolicy""golang.org/x/sync/errgroup""gorm.io/gorm")@@ -171,7 +174,7 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, uif s.db != nil {if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {- return tx.Delete(&imageupdate.ImageUpdateRecord{}, "id = ?", id).Error+ return tx.Delete(&imageupdate.ImageUpdateRecord{}, "id = ? OR image_id = ?", id, id).Error}); err != nil {slog.WarnContext(ctx, "failed to delete image update record", "id", id, "error", err)}@@ -614,7 +617,7 @@ func (s *ImageService) cleanupImageUpdateRecordsAfterPruneInternal(ctx context.C}if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {- return tx.Where("id IN ?", idsToDelete).Delete(&imageupdate.ImageUpdateRecord{}).Error+ return tx.Where("id IN ? OR image_id IN ?", idsToDelete, idsToDelete).Delete(&imageupdate.ImageUpdateRecord{}).Error}); err != nil {slog.WarnContext(ctx, "failed to clean up image update records after prune", "error", err)}@@ -648,18 +651,49 @@ func (s *ImageService) GetUpdateInfoByImageIDs(ctx context.Context, imageIDs []s}var updateRecords []imageupdate.ImageUpdateRecord- if err := s.db.WithContext(ctx).Where("id IN ?", imageIDs).Find(&updateRecords).Error; err != nil {+ if err := s.db.WithContext(ctx).Where("container_id = ? AND project_id = ? AND id IN ?", "", "", imageIDs).Find(&updateRecords).Error; err != nil {return nil, errors.WrapIf(err, "failed to fetch update records")}result := make(map[string]*imagetypes.UpdateInfo, len(updateRecords))for i := range updateRecords {- result[updateRecords[i].ID] = buildUpdateInfo(&updateRecords[i])+ result[updateRecords[i].ID] = updateRecords[i].UpdateInfo()}return result, nil}+// GetUpdateInfoByContainers returns checks matching each container's current policy.+func (s *ImageService) GetUpdateInfoByContainers(ctx context.Context, containers []container.Summary) (map[string]*imagetypes.UpdateInfo, error) {+ result := make(map[string]*imagetypes.UpdateInfo)+ if s.db == nil || len(containers) == 0 {+ return result, nil+ }+ containerIDs := make([]string, 0, len(containers))+ policies := make(map[string]string, len(containers))+ for _, cnt := range containers {+ policy, policyErr := tagpolicy.Resolve(cnt.Image, updater.DefaultLabelPolicy().TagPolicy(cnt.Labels))+ if (policyErr == nil && policy.Strategy == "digest") || labels.IsUpdateDisabled(cnt.Labels) {+ continue+ }+ containerIDs = append(containerIDs, cnt.ID)+ policies[cnt.ID] = imageref.UpdatePolicyKey(cnt.Image, cnt.Labels)+ }+ if len(containerIDs) == 0 {+ return result, nil+ }+ var records []imageupdate.ImageUpdateRecord+ if err := s.db.WithContext(ctx).Where("container_id IN ?", containerIDs).Find(&records).Error; err != nil {+ return nil, errors.WrapIf(err, "failed to fetch container update records")+ }+ for i := range records {+ if records[i].PolicyKey == policies[records[i].ContainerID] {+ result[records[i].ContainerID] = records[i].UpdateInfo()+ }+ }+ return result, nil+}+type imageRefUpdateLookup struct {originalRef stringtag string@@ -704,7 +738,7 @@ func (s *ImageService) GetUpdateInfoByImageRefs(ctx context.Context, imageRefs [var updateRecords []imageupdate.ImageUpdateRecordif err := s.db.WithContext(ctx).- Where("tag IN ? AND repository IN ?", tags, repositoryCandidates).+ Where("container_id = ? AND project_id = ? AND tag IN ? AND repository IN ?", "", "", tags, repositoryCandidates).Order("check_time DESC").Find(&updateRecords).Error; err != nil {return nil, errors.WrapIf(err, "failed to fetch update records by image refs")@@ -712,7 +746,7 @@ func (s *ImageService) GetUpdateInfoByImageRefs(ctx context.Context, imageRefs [for _, lookup := range lookups {if record := selectLatestMatchingImageUpdateRecordInternal(lookup, updateRecords); record != nil {- result[lookup.originalRef] = buildUpdateInfo(record)+ result[lookup.originalRef] = record.UpdateInfo()}}@@ -764,14 +798,14 @@ func (s *ImageService) ListImagesPaginated(ctx context.Context, params paginatio}if s.db != nil && len(imageIDs) > 0 {- if err := s.db.WithContext(ctx).Where("id IN ?", imageIDs).Find(&updateRecords).Error; err != nil {+ if err := s.db.WithContext(ctx).Where("id IN ? OR image_id IN ?", imageIDs, imageIDs).Find(&updateRecords).Error; err != nil {return nil, pagination.Response{}, errors.WrapIf(err, "failed to fetch image update records")}}projectIDByName := s.BuildProjectIDMap(ctx, containers)usageMap := BuildVolumeUsageMap(containers, projectIDByName)- updateMap := buildUpdateMap(updateRecords)+ updateMap := buildUpdateMapInternal(updateRecords)items := MapDockerImagesToDTOs(dockerImages, containers, usageMap, updateMap, nil)@@ -968,10 +1002,24 @@ func BuildVolumeUsageMap(containers []container.Summary, projectIDByName map[strreturn usageMap}-func buildUpdateMap(records []imageupdate.ImageUpdateRecord) map[string]*imageupdate.ImageUpdateRecord {+func buildUpdateMapInternal(records []imageupdate.ImageUpdateRecord) map[string]*imageupdate.ImageUpdateRecord {updateMap := make(map[string]*imageupdate.ImageUpdateRecord, len(records))for i := range records {- updateMap[records[i].ID] = &records[i]+ if records[i].ContainerID == "" {+ updateMap[records[i].ID] = &records[i]+ }+ }+ for i := range records {+ record := &records[i]+ if record.ContainerID == "" || record.ImageID == "" || !record.HasUpdate {+ continue+ }+ // A shared image can have several container policies and target tags.+ aggregate := &imageupdate.ImageUpdateRecord{ID: record.ImageID, HasUpdate: true, CheckTime: record.CheckTime}+ if existing := updateMap[record.ImageID]; existing != nil && existing.CheckTime.After(aggregate.CheckTime) {+ aggregate.CheckTime = existing.CheckTime+ }+ updateMap[record.ImageID] = aggregate}return updateMap}@@ -1049,24 +1097,6 @@ func determineRepoAndTag(di image.Summary) (repo, tag string) {return "<none>", "<none>"}-func buildUpdateInfo(updateRecord *imageupdate.ImageUpdateRecord) *imagetypes.UpdateInfo {- return &imagetypes.UpdateInfo{- HasUpdate: updateRecord.HasUpdate,- UpdateType: updateRecord.UpdateType,- CurrentVersion: updateRecord.CurrentVersion,- LatestVersion: mo.PointerToOption(updateRecord.LatestVersion).OrEmpty(),- CurrentDigest: mo.PointerToOption(updateRecord.CurrentDigest).OrEmpty(),- LatestDigest: mo.PointerToOption(updateRecord.LatestDigest).OrEmpty(),- CheckTime: updateRecord.CheckTime,- ResponseTimeMs: updateRecord.ResponseTimeMs,- Error: mo.PointerToOption(updateRecord.LastError).OrEmpty(),- AuthMethod: mo.PointerToOption(updateRecord.AuthMethod).OrEmpty(),- AuthUsername: mo.PointerToOption(updateRecord.AuthUsername).OrEmpty(),- AuthRegistry: mo.PointerToOption(updateRecord.AuthRegistry).OrEmpty(),- UsedCredential: updateRecord.UsedCredential,- }-}-func collectPinnedReferencesByImageIDInternal(containers []container.Summary) map[string][]string {if len(containers) == 0 {return nil@@ -1136,7 +1166,7 @@ func MapDockerImagesToDTOs(dockerImages []image.Summary, containers []container.}if updateRecord, exists := updateMap[di.ID]; exists {- imageDto.UpdateInfo = buildUpdateInfo(updateRecord)+ imageDto.UpdateInfo = updateRecord.UpdateInfo()}if vulnerabilityMap != nil {diff --git a/backend/internal/image/service_test.go b/backend/internal/image/service_test.goindex 54788f225..f4b072181 100644--- a/backend/internal/image/service_test.go+++ b/backend/internal/image/service_test.go@@ -2,6 +2,7 @@ package imageimport ("github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref""github.com/getarcaneapp/arcane/backend/v2/internal/settings"@@ -35,6 +36,7 @@ import ("github.com/getarcaneapp/arcane/types/v2/containerregistry"imagetypes "github.com/getarcaneapp/arcane/types/v2/image""github.com/getarcaneapp/arcane/types/v2/vulnerability"+ "github.com/moby/moby/api/types/container"dockercontainer "github.com/moby/moby/api/types/container"dockertypesimage "github.com/moby/moby/api/types/image"dockerregistry "github.com/moby/moby/api/types/registry"@@ -687,3 +689,55 @@ type testProjectRow struct {}func (testProjectRow) TableName() string { return "projects" }++func TestImageServiceContainerTagUpdatesStayScoped(t *testing.T) {+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})+ require.NoError(t, err)+ require.NoError(t, db.AutoMigrate(&imageupdate.ImageUpdateRecord{}))+ svc := &ImageService{db: &database.DB{DB: db}}+ now := time.Now().UTC()+ firstLabels := map[string]string{"com.getarcaneapp.arcane.updater.strategy": "tag", "com.getarcaneapp.arcane.updater.constraint": "3.x"}+ secondLabels := map[string]string{"com.getarcaneapp.arcane.updater.strategy": "tag", "com.getarcaneapp.arcane.updater.constraint": "4.x"}+ firstTarget, secondTarget := "3.2.0", "4.0.0"+ records := []imageupdate.ImageUpdateRecord{+ {ID: "shared-image", Repository: "docker.io/library/example", Tag: "3.1.0", CurrentVersion: "3.1.0", UpdateType: "digest", CheckTime: now},+ {ID: "container::first", PolicyKey: imageref.UpdatePolicyKey("example:3.1.0", firstLabels), ContainerID: "first", ImageID: "shared-image", Repository: "docker.io/library/example", Tag: "3.1.0", CurrentVersion: "3.1.0", LatestVersion: &firstTarget, HasUpdate: true, UpdateType: "tag", CheckTime: now.Add(time.Second)},+ {ID: "container::second", PolicyKey: imageref.UpdatePolicyKey("example:3.1.0", secondLabels), ContainerID: "second", ImageID: "shared-image", Repository: "docker.io/library/example", Tag: "3.1.0", CurrentVersion: "3.1.0", LatestVersion: &secondTarget, HasUpdate: true, UpdateType: "tag", CheckTime: now.Add(2 * time.Second)},+ }+ require.NoError(t, db.Create(&records).Error)+ scoped, err := svc.GetUpdateInfoByContainers(t.Context(), []container.Summary{{ID: "first", Image: "example:3.1.0", Labels: firstLabels}, {ID: "second", Image: "example:3.1.0", Labels: secondLabels}, {ID: "unseen"}})+ require.NoError(t, err)+ require.Len(t, scoped, 2)+ require.Equal(t, firstTarget, scoped["first"].LatestVersion)+ require.Equal(t, secondTarget, scoped["second"].LatestVersion)+ byImage, err := svc.GetUpdateInfoByImageIDs(t.Context(), []string{"shared-image"})+ require.NoError(t, err)+ require.False(t, byImage["shared-image"].HasUpdate)+ require.Equal(t, "digest", byImage["shared-image"].UpdateType)+ byRef, err := svc.GetUpdateInfoByImageRefs(t.Context(), []string{"example:3.1.0"})+ require.NoError(t, err)+ require.False(t, byRef["example:3.1.0"].HasUpdate)+ require.Empty(t, byRef["example:3.1.0"].LatestVersion)+ for _, ordered := range [][]imageupdate.ImageUpdateRecord{records, {records[2], records[1], records[0]}} {+ aggregate := buildUpdateMapInternal(ordered)["shared-image"]+ require.True(t, aggregate.HasUpdate)+ require.Empty(t, aggregate.CurrentVersion)+ require.Nil(t, aggregate.LatestVersion)+ require.Nil(t, aggregate.LatestDigest)+ require.Empty(t, aggregate.UpdateType)+ require.Equal(t, records[2].CheckTime, aggregate.CheckTime)+ }+ for _, currentLabels := range []map[string]string{+ {},+ {"com.getarcaneapp.arcane.updater.strategy": "digest"},+ {"com.getarcaneapp.arcane.updater.strategy": "tag", "com.getarcaneapp.arcane.updater.constraint": "3.1.x"},+ {"com.getarcaneapp.arcane.updater.strategy": "tag", "com.getarcaneapp.arcane.updater.constraint": "3.x", "com.getarcaneapp.arcane.updater.tag-pattern": ".*"},+ {"com.getarcaneapp.arcane.updater.strategy": "tag", "com.getarcaneapp.arcane.updater.constraint": "3.x", "com.getarcaneapp.arcane.updater": "false"},+ } {+ checks, err := svc.GetUpdateInfoByContainers(t.Context(), []container.Summary{{ID: "first", Image: "example:3.1.0", Labels: currentLabels}, {ID: "second", Image: "example:3.1.0", Labels: secondLabels}})+ require.NoError(t, err)+ require.NotContains(t, checks, "first")+ require.Contains(t, checks, "second")+ }++}diff --git a/backend/internal/imageupdate/image_update.go b/backend/internal/imageupdate/image_update.goindex 227c360d6..94410804f 100644--- a/backend/internal/imageupdate/image_update.go+++ b/backend/internal/imageupdate/image_update.go@@ -290,6 +290,15 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef striif err == nil && digestResult == nil {err = errors.New("digest update check returned no result")}+ var tagRefs []string+ if digestResult == nil || digestResult.UpdateType != UpdateTypeLocal {+ tagRefs = append(tagRefs, imageRef)+ }+ containerUpdates, tagErr := s.checkContainerTagUpdatesInternal(ctx, tagRefs, nil)+ if tagErr != nil {+ s.completeImageUpdateActivityInternal(ctx, activityID, false, tagErr.Error())+ return digestResult, tagErr+ }if err != nil {result := &imageupdate.Response{Error: err.Error(),@@ -309,7 +318,12 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef striif saveErr := s.saveUpdateResultWithSnapshotInternal(ctx, imageRef, result, snapshot); saveErr != nil {slog.WarnContext(ctx, "Failed to save update result", "imageRef", imageRef, "error", saveErr.Error())}+ attachContainerUpdatesInternal(map[string]*imageupdate.Response{imageRef: result}, containerUpdates)s.completeImageUpdateActivityInternal(ctx, activityID, false, result.Error)+ if result.HasUpdate {+ s.SendBatchUpdateNotifications(ctx)+ return result, nil+ }return result, err}@@ -335,6 +349,10 @@ func (s *ImageUpdateService) CheckImageUpdate(ctx context.Context, imageRef stri}s.notifyImageUpdateInternal(ctx, imageRef, digestResult, snapshot)+ attachContainerUpdatesInternal(map[string]*imageupdate.Response{imageRef: digestResult}, containerUpdates)+ if len(containerUpdates) > 0 {+ s.SendBatchUpdateNotifications(ctx)+ }finalMessage := "Image update check completed"if digestResult.HasUpdate {@@ -914,8 +932,10 @@ func (s *ImageUpdateService) CheckImageUpdateByID(ctx context.Context, imageID sif err != nil {return nil, err}- if saveErr := s.saveUpdateResultByIDInternal(ctx, imageID, result, s.parseImageReference(imageRef)); saveErr != nil {- slog.WarnContext(ctx, "Failed to save update result by ID", "imageID", imageID, "error", saveErr.Error())+ if len(result.ContainerUpdates) == 0 {+ if saveErr := s.saveUpdateResultByIDInternal(ctx, imageID, result, s.parseImageReference(imageRef)); saveErr != nil {+ slog.WarnContext(ctx, "Failed to save update result by ID", "imageID", imageID, "error", saveErr.Error())+ }}return result, nil}@@ -969,7 +989,14 @@ func countBatchResultOutcomesInternal(imageRefs []string, results map[string]*imfor _, imageRef := range imageRefs {result := results[imageRef]- if result != nil && strings.TrimSpace(result.Error) == "" {+ hasError := result == nil+ if result != nil {+ hasError = strings.TrimSpace(result.Error) != ""+ for _, containerUpdate := range result.ContainerUpdates {+ hasError = hasError || containerUpdate.Error != ""+ }+ }+ if !hasError {successCount++continue}@@ -1236,7 +1263,7 @@ func (s *ImageUpdateService) StoredUpdateByImageID(ctx context.Context, imageIDfunc (s *ImageUpdateService) GetUnnotifiedUpdates(ctx context.Context) (map[string]*ImageUpdateRecord, error) {var records []ImageUpdateRecordif err := s.db.WithContext(ctx).- Where("has_update = ? AND notification_sent = ?", true, false).+ Where("has_update = ? AND notification_sent = ? AND project_id = ?", true, false, "").Find(&records).Error; err != nil {return nil, errors.WrapIf(err, "failed to get unnotified updates")}@@ -1633,6 +1660,17 @@ func (s *ImageUpdateService) CheckMultipleImages(ctx context.Context, imageRefsreturn results, err}+ var tagRefs []string+ for _, imageRef := range imageRefs {+ if res := results[imageRef]; res != nil && res.UpdateType != UpdateTypeLocal {+ tagRefs = append(tagRefs, imageRef)+ }+ }+ containerUpdates, tagErr := s.checkContainerTagUpdatesInternal(scanCtx, tagRefs, resolvedCreds)+ if tagErr != nil {+ return results, tagErr+ }+ attachContainerUpdatesInternal(results, containerUpdates)successCount, errorCount := countBatchResultOutcomesInternal(imageRefs, results)slog.InfoContext(ctx, "Batch image update check completed","totalImages", len(imageRefs),@@ -1678,7 +1716,7 @@ func (s *ImageUpdateService) SendBatchUpdateNotifications(ctx context.Context) {imageIDsToMark := make([]string, 0, len(unnotifiedUpdates))for imageID, record := range unnotifiedUpdates {- imageRef := fmt.Sprintf("%s:%s", record.Repository, record.Tag)+ imageRef := containerUpdateNotificationKeyInternal(record)updatesToNotify[imageRef] = &imageupdate.Response{HasUpdate: record.HasUpdate,UpdateType: record.UpdateType,@@ -1767,14 +1805,29 @@ func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {var result *gorm.DBif len(dockerImageIDs) == 0 {- result = s.db.WithContext(ctx).Where("1 = 1").Delete(&ImageUpdateRecord{})+ result = s.db.WithContext(ctx).Where("container_id = ? AND project_id = ?", "", "").Delete(&ImageUpdateRecord{})} else {- result = s.db.WithContext(ctx).Where("id NOT IN ?", dockerImageIDs).Delete(&ImageUpdateRecord{})+ result = s.db.WithContext(ctx).Where("container_id = ? AND project_id = ? AND id NOT IN ?", "", "", dockerImageIDs).Delete(&ImageUpdateRecord{})}if result.Error != nil {return errors.WrapIf(result.Error, "failed to delete orphaned records")}+ containers, listErr := dockerClient.ContainerList(apiCtx, client.ContainerListOptions{All: true})+ if listErr != nil {+ return listErr+ }+ ids := make([]string, 0, len(containers.Items))+ for _, cnt := range containers.Items {+ ids = append(ids, cnt.ID)+ }+ scoped := s.db.WithContext(ctx).Where("container_id <> ?", "")+ if len(ids) > 0 {+ scoped = scoped.Where("container_id NOT IN ?", ids)+ }+ if err := scoped.Delete(&ImageUpdateRecord{}).Error; err != nil {+ return err+ }if result.RowsAffected > 0 {slog.InfoContext(ctx, "Cleaned up orphaned image update records", "deletedCount", result.RowsAffected)} else {@@ -1818,11 +1871,11 @@ func (s *ImageUpdateService) getUpdateSummaryForImageIDsInternal(ctx context.Conif err := s.db.WithContext(ctx).Model(&ImageUpdateRecord{}).Select(`- COALESCE(SUM(CASE WHEN has_update THEN 1 ELSE 0 END), 0) AS images_with_updates,- COALESCE(SUM(CASE WHEN has_update AND update_type = ? THEN 1 ELSE 0 END), 0) AS digest_updates,- COALESCE(SUM(CASE WHEN last_error IS NOT NULL AND last_error != '' THEN 1 ELSE 0 END), 0) AS errors_count+ COUNT(DISTINCT CASE WHEN has_update THEN COALESCE(NULLIF(image_id, ''),id) END) AS images_with_updates,+ COUNT(DISTINCT CASE WHEN has_update AND update_type = ? THEN COALESCE(NULLIF(image_id, ''),id) END) AS digest_updates,+ COUNT(DISTINCT CASE WHEN last_error IS NOT NULL AND last_error != '' THEN COALESCE(NULLIF(image_id, ''),id) END) AS errors_count`, "digest").- Where("id IN ?", imageIDs).+ Where("id IN ? OR image_id IN ?", imageIDs, imageIDs).Scan(&aggregate).Error; err != nil {return nil, err}diff --git a/backend/internal/imageupdate/model.go b/backend/internal/imageupdate/model.goindex 6c89a5d1a..dbeac59e9 100644--- a/backend/internal/imageupdate/model.go+++ b/backend/internal/imageupdate/model.go@@ -2,6 +2,8 @@ package imageupdateimport ("github.com/getarcaneapp/arcane/backend/v2/internal/database"+ imagetypes "github.com/getarcaneapp/arcane/types/v2/image"+ "github.com/samber/mo""time")@@ -9,6 +11,13 @@ import (type ImageUpdateRecord struct {database.BaseModel+ ProjectID string `json:"projectId,omitempty" gorm:"column:project_id;not null;default:'';index"`+ ServiceName string `json:"serviceName,omitempty" gorm:"column:service_name;not null;default:''"`+ PolicyKey string `json:"-" gorm:"column:policy_key;not null;default:''"`++ ContainerID string `json:"containerId,omitempty" gorm:"column:container_id;not null;default:'';index"`+ ImageID string `json:"imageId,omitempty" gorm:"column:image_id;not null;default:'';index"`+CheckTime time.Time `json:"checkTime" gorm:"column:check_time"`LatestVersion *string `json:"latestVersion,omitempty" gorm:"column:latest_version"`CurrentDigest *string `json:"currentDigest,omitempty" gorm:"column:current_digest"`@@ -58,3 +67,22 @@ func (i *ImageUpdateRecord) IsDigestUpdate() bool {func (i *ImageUpdateRecord) IsTagUpdate() bool {return i.UpdateType == UpdateTypeTag}++// UpdateInfo returns the public status of this check.+func (i *ImageUpdateRecord) UpdateInfo() *imagetypes.UpdateInfo {+ return &imagetypes.UpdateInfo{+ HasUpdate: i.HasUpdate,+ UpdateType: i.UpdateType,+ CurrentVersion: i.CurrentVersion,+ LatestVersion: mo.PointerToOption(i.LatestVersion).OrEmpty(),+ CurrentDigest: mo.PointerToOption(i.CurrentDigest).OrEmpty(),+ LatestDigest: mo.PointerToOption(i.LatestDigest).OrEmpty(),+ CheckTime: i.CheckTime,+ ResponseTimeMs: i.ResponseTimeMs,+ Error: mo.PointerToOption(i.LastError).OrEmpty(),+ AuthMethod: mo.PointerToOption(i.AuthMethod).OrEmpty(),+ AuthUsername: mo.PointerToOption(i.AuthUsername).OrEmpty(),+ AuthRegistry: mo.PointerToOption(i.AuthRegistry).OrEmpty(),+ UsedCredential: i.UsedCredential,+ }+}diff --git a/backend/internal/imageupdate/service_test.go b/backend/internal/imageupdate/service_test.goindex 4b080f427..4cc1f87d3 100644--- a/backend/internal/imageupdate/service_test.go+++ b/backend/internal/imageupdate/service_test.go@@ -1,6 +1,7 @@package imageupdateimport (+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/notifications""github.com/getarcaneapp/arcane/backend/v2/internal/kv"@@ -506,6 +507,12 @@ func TestImageUpdateService_CheckMultipleImages_ComposeBuildMissingLocallySkipsR}).Error)dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+http.Error(w, "No such image", http.StatusNotFound)}))t.Cleanup(dockerServer.Close)@@ -540,6 +547,12 @@ func newArcaneLocalImageUpdateServiceInternal(t *testing.T, imageExists bool) (*db := setupImageUpdateTestDB(t)localDigest := digest.FromString("arcane-local-build").String()dockerServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+if imageExists && strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json") {w.Header().Set("Content-Type", "application/json")assert.NoError(t, json.NewEncoder(w).Encode(dockertypesimage.InspectResponse{@@ -622,6 +635,12 @@ func TestImageUpdateService_CheckMultipleImages_OtherDottedRegistryStillChecked(func TestImageUpdateService_InspectLocalImageSnapshot_NoRepoDigestsRemainsLocal(t *testing.T) {server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+if strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json") {w.Header().Set("Content-Type", "application/json")if !assert.NoError(t, json.NewEncoder(w).Encode(dockertypesimage.InspectResponse{@@ -655,6 +674,12 @@ func newImageUpdateFallbackServer(t *testing.T, repositoryTag, localDigest, remomanifestPath := fmt.Sprintf("/v2/%s/manifests/%s", repository, tag)return httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+switch {case strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):imageRef := r.Host + "/" + repositoryTag@@ -694,6 +719,12 @@ func newImageUpdateRegistryOnlyServer(t *testing.T, repositoryTag, remoteDigestmanifestPath := fmt.Sprintf("/v2/%s/manifests/%s", repository, tag)return httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+switch {case strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):http.Error(w, "not found", http.StatusNotFound)@@ -880,6 +911,12 @@ func newImageUpdateNoRepoTagsServer(t *testing.T, imageID, localDigest string) *t.Helper()return httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+if strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json") {w.Header().Set("Content-Type", "application/json")if !assert.NoError(t, json.NewEncoder(w).Encode(dockertypesimage.InspectResponse{@@ -1970,6 +2007,12 @@ func newBlockedDockerAPIServerInternal(t *testing.T, pathContains string) *httptt.Helper()server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.HasSuffix(r.URL.Path, "/containers/json") {+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{}))+ return+ }+if strings.Contains(r.URL.Path, pathContains) {<-r.Context().Done()return@@ -2369,3 +2412,109 @@ type testProjectRow struct {}func (testProjectRow) TableName() string { return "projects" }++func TestContainerTagChecksPersistIndependentPoliciesInternal(t *testing.T) {+ db := setupImageUpdateRegistryTestDBInternal(t)+ registryServer := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if !strings.HasSuffix(r.URL.Path, "/tags/list") {+ http.NotFound(w, r)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"name": "team/app", "tags": []string{"1.0.0", "1.1.0", "2.0.0"}}))+ }))+ defer registryServer.Close()+ registryURL, err := url.Parse(registryServer.URL)+ require.NoError(t, err)+ imageRef := registryURL.Host + "/team/app:1.0.0"+ imageID := digest.FromString("shared").String()+ values := map[string]map[string]string{+ "one": {},+ "two": {labels.LabelUpdateStrategy: "auto", labels.LabelUpdateConstraint: "2.x"},+ }+ dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ switch {+ case strings.HasSuffix(r.URL.Path, "/containers/json"):+ require.NoError(t, json.NewEncoder(w).Encode([]dockertypescontainer.Summary{{ID: "one", Image: imageRef, ImageID: imageID, Labels: values["one"]}, {ID: "two", Image: imageRef, ImageID: imageID, Labels: values["two"]}}))+ case strings.Contains(r.URL.Path, "/images/"):+ require.NoError(t, json.NewEncoder(w).Encode(dockertypesimage.InspectResponse{ID: imageID, RepoTags: []string{imageRef}, RepoDigests: []string{registryURL.Host + "/team/app@" + imageID}}))+ case strings.Contains(r.URL.Path, "/containers/"):+ id := "one"+ if strings.Contains(r.URL.Path, "/two/") {+ id = "two"+ }+ require.NoError(t, json.NewEncoder(w).Encode(dockertypescontainer.InspectResponse{ID: id, Image: imageID, Config: &dockertypescontainer.Config{Image: imageRef, Labels: values[id]}}))+ default:+ t.Errorf("unexpected Docker request %s", r.URL.Path)+ http.NotFound(w, r)+ }+ }))+ defer dockerServer.Close()+ registryService := registry.NewContainerRegistryService(db, func(context.Context) (registry.RegistryDaemonClient, error) {+ return &fakeRegistryDaemonClient{distributionInspectFn: func(context.Context, string, client.DistributionInspectOptions) (client.DistributionInspectResult, error) {+ return client.DistributionInspectResult{}, errors.New("manifest not found")+ }}, nil+ }, nil, registryServer.Client())+ svc := NewImageUpdateService(db, nil, registryService, &docker.DockerClientService{Client: newImageUpdateTestDockerClientInternal(t, dockerServer)}, nil, nil, nil)+ checks, err := svc.checkContainerTagUpdatesInternal(t.Context(), []string{imageRef}, nil)+ require.NoError(t, err)+ require.Len(t, checks, 2)+ require.Equal(t, "1.1.0", checks["one"].LatestVersion)+ require.Equal(t, "2.0.0", checks["two"].LatestVersion)+ var records []ImageUpdateRecord+ require.NoError(t, db.Order("container_id").Find(&records).Error)+ require.Len(t, records, 2)+ require.Equal(t, "container::one", records[0].ID)+ require.Equal(t, imageID, records[0].ImageID)+ require.Equal(t, imageID, records[1].ImageID)+ require.True(t, records[0].HasUpdate)+ svc.eventService = event.NewEventService(db, nil, nil)+ single, checkErr := svc.CheckImageUpdate(t.Context(), imageRef)+ require.NoError(t, checkErr)+ require.True(t, single.HasUpdate)+ require.NotEmpty(t, single.Error, "keep the old-tag digest error visible")+ require.Len(t, single.ContainerUpdates, 2)+ // The image-level digest error is stored independently of container candidates.+ require.NoError(t, db.Where("container_id = ?", "").Delete(&ImageUpdateRecord{}).Error)+ // Changing one policy to an invalid expression clears its actionable state+ // without overwriting the other container's result.+ values["one"][labels.LabelUpdateConstraint] = "invalid"+ checks, err = svc.checkContainerTagUpdatesInternal(t.Context(), []string{imageRef}, nil)+ require.NoError(t, err)+ require.NotEmpty(t, checks["one"].Error)+ require.False(t, checks["one"].HasUpdate)+ records = nil+ require.NoError(t, db.Order("container_id").Find(&records).Error)+ require.False(t, records[0].HasUpdate)+ require.True(t, records[1].HasUpdate)+ limited := &imageupdate.Response{UpdateType: UpdateTypeTag, Error: "registry status: 429", CheckTime: time.Now().UTC()}+ current := dockertypescontainer.Summary{ID: "two", Image: imageRef, ImageID: imageID, Labels: values["two"]}+ require.NoError(t, svc.saveContainerTagResultInternal(t.Context(), current, limited))+ var retained ImageUpdateRecord+ require.NoError(t, db.First(&retained, "id = ?", "container::two").Error)+ require.True(t, retained.HasUpdate, "same-policy rate limits retain the last good result")+ require.Equal(t, imageref.UpdatePolicyKey(imageRef, current.Labels), retained.PolicyKey)+ current.Labels = map[string]string{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "1.x"}+ require.NoError(t, svc.saveContainerTagResultInternal(t.Context(), current, limited))+ retained = ImageUpdateRecord{}+ require.NoError(t, db.First(&retained, "id = ?", "container::two").Error)+ require.False(t, retained.HasUpdate, "a changed policy cannot inherit the previous candidate")+ require.Equal(t, imageref.UpdatePolicyKey(imageRef, current.Labels), retained.PolicyKey)+ require.Equal(t, limited.Error, *retained.LastError)++}++func TestContainerAggregationPreservesImageResultInternal(t *testing.T) {+ original := &imageupdate.Response{HasUpdate: false, UpdateType: UpdateTypeDigest, CurrentVersion: "3.20.0", LatestVersion: "3.20.0"}+ results := map[string]*imageupdate.Response{"alpine:3.20.0": original}+ scoped := &imageupdate.Response{ImageRef: "docker.io/library/alpine:3.20.0", HasUpdate: true, UpdateType: UpdateTypeTag, CurrentVersion: "3.20.0", LatestVersion: "3.20.1"}+ attachContainerUpdatesInternal(results, map[string]*imageupdate.Response{"tagged": scoped})+ require.True(t, original.HasUpdate)+ require.Same(t, scoped, original.ContainerUpdates["tagged"])+ require.NotNil(t, original.ImageUpdate)+ require.False(t, original.ImageUpdate.HasUpdate, "untagged siblings must keep the original digest result")+ require.Equal(t, UpdateTypeDigest, original.ImageUpdate.UpdateType)+ require.Nil(t, original.ImageUpdate.ContainerUpdates)+ require.Nil(t, original.ImageUpdate.ImageUpdate, "snapshot must not create recursive JSON")+}diff --git a/backend/internal/imageupdate/tag_updates.go b/backend/internal/imageupdate/tag_updates.gonew file mode 100644index 000000000..b3d315691--- /dev/null+++ b/backend/internal/imageupdate/tag_updates.go@@ -0,0 +1,217 @@+package imageupdate++import (+ "context"+ "fmt"+ "log/slog"+ "strings"+ "time"++ "emperror.dev/errors"+ "github.com/getarcaneapp/arcane/backend/v2/internal/docker"+ "github.com/getarcaneapp/arcane/backend/v2/internal/registry"+ "github.com/getarcaneapp/arcane/backend/v2/internal/settings"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref"+ "github.com/getarcaneapp/arcane/types/v2/containerregistry"+ imageupdatetypes "github.com/getarcaneapp/arcane/types/v2/imageupdate"+ "github.com/moby/moby/api/types/container"+ "github.com/moby/moby/client"+ "go.getarcane.app/updater"++ "go.getarcane.app/updater/pkg/utils/tagpolicy"+ "go.getarcane.app/updater/refs"++ "gorm.io/gorm"+)++type tagRegistryInternal struct {+ service *registry.ContainerRegistryService+ credentials []containerregistry.Credential+ docker *docker.DockerClientService+ settings *settings.SettingsService+}++func (r tagRegistryInternal) ListTags(ctx context.Context, imageRef string) ([]string, error) {+ if r.service == nil {+ return nil, errors.New("registry service unavailable")+ }+ return r.service.ListImageTags(ctx, imageRef, r.credentials)+}++func (r tagRegistryInternal) ImageDigest(ctx context.Context, imageRef string) (string, error) {+ if r.service == nil {+ return "", errors.New("registry service unavailable")+ }+ result, err := r.service.InspectImageDigest(ctx, imageRef, r.credentials)+ if err != nil {+ return "", err+ }+ if result == nil {+ return "", errors.New("registry returned no digest")+ }+ return result.Digest, nil+}++func (s *ImageUpdateService) checkContainerTagUpdatesInternal(ctx context.Context, imageRefs []string, credentials []containerregistry.Credential) (map[string]*imageupdatetypes.Response, error) {+ results := map[string]*imageupdatetypes.Response{}+ wanted := map[string]bool{}+ for _, imageRef := range imageRefs {+ if normalized := refs.NormalizeImageUpdateRef(imageRef); normalized != "" {+ wanted[normalized] = true+ }+ }+ if len(wanted) == 0 {+ return results, nil+ }+ dockerClient, err := s.dockerClientInternal(ctx)+ if err != nil {+ return results, err+ }+ apiCtx, cancel := s.dockerAPIContextInternal(ctx)+ listed, err := dockerClient.ContainerList(apiCtx, client.ContainerListOptions{All: true})+ cancel()+ if err != nil {+ return results, errors.WrapIf(err, "list containers for tag update checks")+ }++ adapter := tagRegistryInternal{service: s.registryService, credentials: credentials, docker: s.dockerService, settings: s.settingsService}+ engine, err := updater.New(updater.Config{RegistryTagLister: adapter, RegistryDigestResolver: adapter, DockerClientProvider: adapter, Settings: adapter})+ if err != nil {+ return results, err+ }+ defer func() {+ if closeErr := engine.Close(); closeErr != nil {+ slog.WarnContext(ctx, "close tag checker", "error", closeErr)+ }+ }()+ policy := updater.DefaultLabelPolicy()+ for _, cnt := range listed.Items {+ if !wanted[refs.NormalizeImageUpdateRef(cnt.Image)] {+ continue+ }+ tagPolicy, policyErr := tagpolicy.Resolve(cnt.Image, policy.TagPolicy(cnt.Labels))+ if policyErr == nil && tagPolicy.Strategy == "digest" {+ if s.db != nil {+ if err := s.db.WithContext(ctx).Where("container_id = ?", cnt.ID).Delete(&ImageUpdateRecord{}).Error; err != nil {+ return results, err+ }+ }+ continue+ }+ result := s.checkContainerTagInternal(ctx, engine, cnt)+ results[cnt.ID] = result+ if err := s.saveContainerTagResultInternal(ctx, cnt, result); err != nil {+ return results, err+ }+ }+ return results, nil+}++func (s *ImageUpdateService) checkContainerTagInternal(ctx context.Context, engine *updater.Service, cnt container.Summary) *imageupdatetypes.Response {+ start := time.Now()+ result := &imageupdatetypes.Response{CheckTime: time.Now().UTC(), UpdateType: UpdateTypeTag, ImageRef: cnt.Image}+ defer func() { result.ResponseTimeMs = int(time.Since(start).Milliseconds()) }()+ parsed, err := refs.NormalizeReference(cnt.Image)+ if err != nil {+ result.Error = err.Error()+ return result+ }+ if s.registryLimiter != nil {+ if err := s.registryLimiter.Acquire(ctx, parsed.RegistryHost); err != nil {+ result.Error = err.Error()+ return result+ }+ defer s.registryLimiter.Release(parsed.RegistryHost)+ }+ checkCtx, cancel := s.registryContextInternal(ctx)+ defer cancel()+ check, err := engine.CheckContainerUpdate(checkCtx, cnt.ID)+ if err != nil {+ result.Error = err.Error()+ return result+ }+ result.HasUpdate = check.UpdateAvailable+ result.UpdateType = check.UpdateType+ if result.UpdateType == "" {+ result.UpdateType = UpdateTypeTag+ }+ result.CurrentVersion = check.CurrentVersion+ result.CurrentDigest = check.CurrentDigest+ result.LatestDigest = check.TargetDigest+ if check.TargetRef != "" {+ target, err := refs.NormalizeReference(check.TargetRef)+ if err != nil {+ result.Error = err.Error()+ result.HasUpdate = false+ return result+ }+ result.LatestVersion = target.Tag+ }+ return result+}++func (r tagRegistryInternal) DockerClient(ctx context.Context) (*client.Client, error) {+ if r.docker == nil {+ return nil, errors.New("docker service unavailable")+ }+ return r.docker.GetClient(ctx)+}++func (r tagRegistryInternal) ExcludedContainers(ctx context.Context) ([]string, error) {+ if r.settings == nil {+ return nil, nil+ }+ return strings.Split(r.settings.GetStringSetting(ctx, "autoUpdateExcludedContainers", ""), ","), nil+}++func (s *ImageUpdateService) saveContainerTagResultInternal(ctx context.Context, cnt container.Summary, result *imageupdatetypes.Response) error {+ if s.db == nil {+ return nil+ }+ parsed, err := refs.NormalizeReference(cnt.Image)+ if err != nil {+ return err+ }+ id := "container::" + cnt.ID+ policyKey := imageref.UpdatePolicyKey(cnt.Image, cnt.Labels)+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ // A previous good result must not survive a rate limit under a different policy.+ if err := tx.Where("id = ? AND policy_key <> ?", id, policyKey).Delete(&ImageUpdateRecord{}).Error; err != nil {+ return err+ }+ if err := savePreparedUpdateResultWithTxInternal(tx, id, parsed.RegistryHost+"/"+parsed.Repository, parsed.Tag, result); err != nil {+ return err+ }+ return tx.Model(&ImageUpdateRecord{}).Where("id = ?", id).Updates(map[string]any{"container_id": cnt.ID, "image_id": cnt.ImageID, "policy_key": policyKey}).Error+ })+}++func attachContainerUpdatesInternal(results map[string]*imageupdatetypes.Response, containerUpdates map[string]*imageupdatetypes.Response) {+ for imageRef, result := range results {+ for id, update := range containerUpdates {+ if refs.NormalizeImageUpdateRef(update.ImageRef) != refs.NormalizeImageUpdateRef(imageRef) {+ continue+ }+ if result.ImageUpdate == nil {+ imageOnly := *result+ imageOnly.ContainerUpdates = nil+ result.ImageUpdate = &imageOnly+ }+ if result.ContainerUpdates == nil {+ result.ContainerUpdates = map[string]*imageupdatetypes.Response{}+ }+ result.ContainerUpdates[id] = update+ if update.HasUpdate {+ result.HasUpdate = true+ }+ }+ }+}++func containerUpdateNotificationKeyInternal(record *ImageUpdateRecord) string {+ imageRef := fmt.Sprintf("%s:%s", record.Repository, record.Tag)+ if record.ContainerID != "" {+ return imageRef + " (container " + record.ContainerID + ")"+ }+ return imageRef+}diff --git a/backend/internal/project/handler.go b/backend/internal/project/handler.goindex 0bc0ef3b2..9a0c79503 100644--- a/backend/internal/project/handler.go+++ b/backend/internal/project/handler.go@@ -966,7 +966,7 @@ func (h *ProjectHandler) updateProjectServicesActivityConfigInternal(services []SuccessMessage: "Project services updated successfully",Queue: true,Action: func(runtimeCtx context.Context, projectID string, user common.User) error {- return h.projectService.UpdateProjectServices(runtimeCtx, projectID, services, user)+ return h.projectService.UpdateProjectServices(runtimeCtx, projectID, services, user, true)},Error: projectArchivedActionErrorInternal(func(err error) error {return huma.Error400BadRequest(errors.WithMessage(err, "Failed to update project").Error())diff --git a/backend/internal/project/project_details.go b/backend/internal/project/project_details.goindex 83ed3083f..b15579a7e 100644--- a/backend/internal/project/project_details.go+++ b/backend/internal/project/project_details.go@@ -2,6 +2,7 @@ package projectimport ("github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"+ "github.com/moby/moby/api/types/container""github.com/getarcaneapp/arcane/backend/v2/internal/settings"@@ -9,6 +10,7 @@ import ("context""io""log/slog"+ "maps""path/filepath""slices""strings"@@ -19,15 +21,19 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/common"composetypes "github.com/compose-spec/compose-go/v2/types"+ dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil""github.com/getarcaneapp/arcane/backend/v2/pkg/projects""github.com/getarcaneapp/arcane/backend/v2/pkg/utils""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/iconcatalog"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/mapper"imagetypes "github.com/getarcaneapp/arcane/types/v2/image""github.com/getarcaneapp/arcane/types/v2/project""github.com/samber/mo""go.getarcane.app/sys/cgroup"+ "go.getarcane.app/updater""go.getarcane.app/updater/labels"+ "go.getarcane.app/updater/pkg/utils/tagpolicy")type ProjectServiceInfo struct {@@ -280,17 +286,7 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID stringresp.EnvContent = effectiveEnvContent}- // Enrich with details- composeFile, composeFileErr := s.ResolveProjectComposeFile(ctx, proj)- if composeFileErr == nil {- resp.ComposeFileName = filepath.Base(composeFile)- if opts.IncludeIncludeFiles {- s.enrichWithIncludeFiles(ctx, composeFile, &resp)- }- if opts.IncludeServiceConfigs {- s.enrichWithComposeServiceConfigs(ctx, proj, composeFile, &resp)- }- }+ s.enrichComposeDetailsInternal(ctx, proj, opts, &resp)s.enrichWithGitOpsInfo(ctx, proj, &resp)// Refresh runtime status/counts even when callers do not request the full@@ -303,7 +299,7 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID stringresp.RunningCount = runningCountresp.Status = string(calculateProjectStatus(services))- if opts.IncludeRuntimeServices {+ if opts.IncludeRuntimeServices || opts.IncludeUpdateInfo {resp.RuntimeServices = buildProjectRuntimeServicesInternal(services)for _, svc := range services {if svc.RedeployDisabled {@@ -317,6 +313,12 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID stringif opts.IncludeUpdateInfo {s.enrichProjectUpdateInfoInternal(ctx, &resp)}+ if !opts.IncludeRuntimeServices {+ resp.RuntimeServices = nil+ }+ if !opts.IncludeServiceConfigs {+ resp.Services = nil+ }return resp, nil}@@ -384,6 +386,7 @@ func buildProjectRuntimeServicesInternal(services []ProjectServiceInfo) []projecImage: svc.Image,Status: svc.Status,ContainerID: svc.ContainerID,+ ContainerLabels: svc.Labels,ContainerName: svc.ContainerName,Ports: svc.Ports,Health: svc.Health,@@ -442,7 +445,13 @@ func (s *ProjectService) enrichProjectUpdateInfoInternal(ctx context.Context, re}}- resp.UpdateInfo = buildProjectUpdateInfoSummaryInternal(imageRefs, updateInfoByRef)+ scoped := s.getProjectContainerUpdateInfoInternal(ctx, []project.Details{*resp})+ if len(resp.Services) > 0 {+ records := s.getProjectServiceUpdateRecordsInternal(ctx, []string{resp.ID})+ resp.UpdateInfo = BuildConfiguredUpdateInfo(resp.ID, resp.Services, updateInfoByRef, records, configuredRuntimeServiceUpdateInfoInternal(resp.Services, resp.RuntimeServices, scoped))+ return+ }+ resp.UpdateInfo = BuildUpdateInfoSummary(imageRefs, mergeProjectContainerUpdateInfoInternal(updateInfoByRef, resp.RuntimeServices, scoped))}func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(@@ -456,11 +465,14 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(imageRefsByProjectID := make(map[string][]string, len(projectsList))allImageRefs := make([]string, 0)+ servicesByProjectID := make(map[string][]composetypes.ServiceConfig, len(projectsList))+ projectIDs := make([]string, 0, len(projectsList))cfg := s.settingsService.GetSettingsOrDefaults(ctx)type imageRefsResult struct {projectID stringrefs []string+ services []composetypes.ServiceConfig}sem := make(chan struct{}, maxConcurrentComposeReads)@@ -468,11 +480,7 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(var wg sync.WaitGroupfor _, proj := range projectsList {- if refs := projects.ParseImageRefsJSON(proj.ImageRefsJSON); len(refs) > 0 {- imageRefsByProjectID[proj.ID] = refs- allImageRefs = append(allImageRefs, refs...)- continue- }+ projectIDs = append(projectIDs, proj.ID)wg.Add(1)go func(proj Project) {@@ -485,13 +493,17 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(}defer func() { <-sem }()- refs, _, err := s.getProjectImageRefsFromComposeInternal(ctx, proj, cfg)+ composeProject, err := s.getCachedComposeProjectInternal(ctx, &proj, cfg)if err != nil {- slog.WarnContext(ctx, "failed to resolve project image refs for update summary", "projectID", proj.ID, "projectName", proj.Name, "error", err)+ slog.WarnContext(ctx, "failed to resolve project services for update summary", "projectID", proj.ID, "projectName", proj.Name, "error", err)+ resultsCh <- imageRefsResult{projectID: proj.ID, refs: projects.ParseImageRefsJSON(proj.ImageRefsJSON)}return}-- resultsCh <- imageRefsResult{projectID: proj.ID, refs: refs}+ services := make([]composetypes.ServiceConfig, 0, len(composeProject.Services))+ for _, service := range composeProject.Services {+ services = append(services, service)+ }+ resultsCh <- imageRefsResult{projectID: proj.ID, refs: projects.ImageRefsFromComposeConfigs(services), services: services}}(proj)}@@ -500,6 +512,7 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(for result := range resultsCh {imageRefsByProjectID[result.projectID] = result.refs+ servicesByProjectID[result.projectID] = result.servicesallImageRefs = append(allImageRefs, result.refs...)}@@ -513,9 +526,161 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(}}+ records := s.getProjectServiceUpdateRecordsInternal(ctx, projectIDs)+ scoped := s.getProjectContainerUpdateInfoInternal(ctx, details)for i := range details {- details[i].UpdateInfo = buildProjectUpdateInfoSummaryInternal(imageRefsByProjectID[details[i].ID], updateInfoByRef)+ if services := servicesByProjectID[details[i].ID]; len(services) > 0 {+ details[i].UpdateInfo = BuildConfiguredUpdateInfo(details[i].ID, services, updateInfoByRef, records, configuredRuntimeServiceUpdateInfoInternal(services, details[i].RuntimeServices, scoped))+ continue+ }+ refs := imageRefsByProjectID[details[i].ID]+ if len(refs) == 0 {+ refs = projects.ImageRefsFromRuntimeServices(details[i].RuntimeServices)+ }+ details[i].UpdateInfo = BuildUpdateInfoSummary(refs, mergeProjectContainerUpdateInfoInternal(updateInfoByRef, details[i].RuntimeServices, scoped))+ }+}++func (s *ProjectService) getProjectServiceUpdateRecordsInternal(ctx context.Context, projectIDs []string) []imageupdate.ImageUpdateRecord {+ if s.db == nil || len(projectIDs) == 0 {+ return nil+ }+ var records []imageupdate.ImageUpdateRecord+ if err := s.db.WithContext(ctx).Where("project_id <> ? AND project_id IN ?", "", projectIDs).Find(&records).Error; err != nil {+ slog.WarnContext(ctx, "failed to fetch project service update checks", "error", err)+ return nil}+ return records+}++// BuildConfiguredUpdateInfo matches checks to current services and aggregates their results.+func BuildConfiguredUpdateInfo(projectID string, services []composetypes.ServiceConfig, byRef map[string]*imagetypes.UpdateInfo, records []imageupdate.ImageUpdateRecord, runtimeUpdates ...map[string]*imagetypes.UpdateInfo) *project.UpdateInfo {+ checks := make(map[string]*imageupdate.ImageUpdateRecord)+ for i := range records {+ if records[i].ProjectID == projectID {+ checks[records[i].ServiceName] = &records[i]+ }+ }+ serviceUpdates := make(map[string]project.ServiceUpdateInfo, len(services))+ selected := make(map[string]*imagetypes.UpdateInfo)+ runtime := make([]project.RuntimeService, 0, len(services))+ unknownRefs := make(map[string]bool)+ for _, service := range services {+ imageRef := strings.TrimSpace(service.Image)+ if imageRef == "" {+ continue+ }+ var info *imagetypes.UpdateInfo+ record := checks[service.Name]+ policy, policyErr := tagpolicy.Resolve(imageRef, updater.DefaultLabelPolicy().TagPolicy(service.Labels))+ if record != nil && record.PolicyKey == imageref.UpdatePolicyKey(imageRef, service.Labels) {+ info = record.UpdateInfo()+ } else if policyErr == nil && policy.Strategy == "digest" {+ info = byRef[imageRef]+ }++ if len(runtimeUpdates) > 0 && runtimeUpdates[0][service.Name] != nil {+ info = mergeProjectContainerUpdateInfoInternal(nil, []project.RuntimeService{{ContainerID: "preview", Image: imageRef}, {ContainerID: "runtime", Image: imageRef}}, map[string]*imagetypes.UpdateInfo{"preview": info, "runtime": runtimeUpdates[0][service.Name]})[imageRef]+ }+ serviceUpdates[service.Name] = project.ServiceUpdateInfo{ImageRef: imageRef, UpdateInfo: info}+ selected[service.Name] = info+ runtime = append(runtime, project.RuntimeService{ContainerID: service.Name, Image: imageRef})+ if info == nil {+ unknownRefs[imageRef] = true+ }+ }+ merged := mergeProjectContainerUpdateInfoInternal(nil, runtime, selected)+ for imageRef := range unknownRefs {+ if info := merged[imageRef]; info == nil || !info.HasUpdate {+ delete(merged, imageRef)+ }+ }+ summary := BuildUpdateInfoSummary(projects.ImageRefsFromComposeConfigs(services), merged)+ summary.ServiceUpdates = serviceUpdates+ return summary+}++// configuredRuntimeServiceUpdateInfoInternal also binds runtime checks to the+// current Compose source, since container labels may predate an operator edit.+func configuredRuntimeServiceUpdateInfoInternal(services []composetypes.ServiceConfig, runtime []project.RuntimeService, scoped map[string]*imagetypes.UpdateInfo) map[string]*imagetypes.UpdateInfo {+ configs := make(map[string]composetypes.ServiceConfig, len(services))+ for _, service := range services {+ configs[service.Name] = service+ }+ grouped := make(map[string][]project.RuntimeService)+ for _, service := range runtime {+ name := service.Name+ if name == "" {+ name = dockerutil.ComposeServiceLabel(service.ContainerLabels)+ }+ config, ok := configs[name]+ if !ok || scoped[service.ContainerID] == nil {+ continue+ }+ if imageref.UpdatePolicyKey(config.Image, config.Labels) != imageref.UpdatePolicyKey(service.Image, service.ContainerLabels) {+ continue+ }+ service.Image = config.Image+ grouped[name] = append(grouped[name], service)+ }+ result := make(map[string]*imagetypes.UpdateInfo, len(grouped))+ for name, replicas := range grouped {+ result[name] = mergeProjectContainerUpdateInfoInternal(nil, replicas, scoped)[strings.TrimSpace(configs[name].Image)]+ }+ return result+}++func (s *ProjectService) getProjectContainerUpdateInfoInternal(ctx context.Context, details []project.Details) map[string]*imagetypes.UpdateInfo {+ if s.imageService == nil {+ return nil+ }+ var containers []container.Summary+ for _, detail := range details {+ for _, service := range detail.RuntimeServices {+ if service.ContainerID != "" {+ containers = append(containers, container.Summary{ID: service.ContainerID, Image: service.Image, Labels: service.ContainerLabels})+ }+ }+ }+ scoped, err := s.imageService.GetUpdateInfoByContainers(ctx, containers)+ if err != nil {+ slog.WarnContext(ctx, "failed to fetch project container update info", "error", err)+ return nil+ }+ return scoped+}++func mergeProjectContainerUpdateInfoInternal(base map[string]*imagetypes.UpdateInfo, services []project.RuntimeService, scoped map[string]*imagetypes.UpdateInfo) map[string]*imagetypes.UpdateInfo {+ result := make(map[string]*imagetypes.UpdateInfo, len(base))+ maps.Copy(result, base)+ seen := make(map[string]bool)+ for _, service := range services {+ info := scoped[service.ContainerID]+ if info == nil {+ continue+ }+ imageRef := strings.TrimSpace(service.Image)+ if imageRef == "" {+ continue+ }+ merged := *info+ if seen[imageRef] {+ previous := result[imageRef]+ merged.HasUpdate = merged.HasUpdate || previous.HasUpdate+ if previous.CheckTime.After(merged.CheckTime) {+ merged.CheckTime = previous.CheckTime+ }+ if previous.LatestVersion != merged.LatestVersion || previous.LatestDigest != merged.LatestDigest || previous.UpdateType != merged.UpdateType {+ merged.LatestVersion, merged.LatestDigest, merged.UpdateType = "", "", ""+ }+ if merged.Error == "" {+ merged.Error = previous.Error+ }+ }+ result[imageRef] = &merged+ seen[imageRef] = true+ }+ return result}func (s *ProjectService) getProjectImageRefsFromComposeInternal(ctx context.Context, proj Project, cfg *settings.Settings) ([]string, []string, error) {@@ -527,7 +692,8 @@ func (s *ProjectService) getProjectImageRefsFromComposeInternal(ctx context.Contreturn projects.ImageRefsFromComposeServices(composeProject.Services), projects.BuildImageRefsFromComposeProject(composeProject), nil}-func buildProjectUpdateInfoSummaryInternal(+// BuildUpdateInfoSummary aggregates image checks into a project update summary.+func BuildUpdateInfoSummary(imageRefs []string,updateInfoByRef map[string]*imagetypes.UpdateInfo,) *project.UpdateInfo {@@ -606,7 +772,19 @@ func (s *ProjectService) enrichWithGitOpsInfo(ctx context.Context, proj *Project}}-func (s *ProjectService) enrichWithComposeServiceConfigs(ctx context.Context, proj *Project, composeFile string, resp *project.Details) {+func (s *ProjectService) enrichComposeDetailsInternal(ctx context.Context, proj *Project, opts project.DetailsOptions, resp *project.Details) {+ composeFile, err := s.ResolveProjectComposeFile(ctx, proj)+ if err != nil {+ return+ }+ resp.ComposeFileName = filepath.Base(composeFile)+ if opts.IncludeIncludeFiles {+ s.enrichWithIncludeFiles(ctx, composeFile, resp)+ }+ if !opts.IncludeServiceConfigs && !opts.IncludeUpdateInfo {+ return+ }+composeProj, loadErr := s.getCachedComposeProjectInternal(ctx, proj, nil)if loadErr != nil {slog.WarnContext(ctx, "failed to load compose service configs", "path", composeFile, "error", loadErr)diff --git a/backend/internal/project/project_lifecycle.go b/backend/internal/project/project_lifecycle.goindex 0efc660aa..6d540c067 100644--- a/backend/internal/project/project_lifecycle.go+++ b/backend/internal/project/project_lifecycle.go@@ -74,7 +74,30 @@ func (s *ProjectService) pullAndReconcileImageInternal(return nil}-func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user common.User) error {+func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user common.User, discoverTags bool) error {+ proj, err := s.getMutableProjectInternal(ctx, projectID)+ if err != nil {+ return err+ }+ if discoverTags {+ effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, servicesToUpdate...)+ if err != nil {+ return errors.WrapIf(err, "load project for service image checks")+ }+ changes, err := s.projectServiceImageChangesInternal(ctx, proj, effective)+ if err != nil {+ return err+ }+ if len(changes) > 0 {+ if _, err := s.persistProjectImageChangesInternal(ctx, projectID, changes); err != nil {+ return err+ }+ }+ }+ return s.updateProjectServicesInternal(ctx, projectID, servicesToUpdate, user)+}++func (s *ProjectService) updateProjectServicesInternal(ctx context.Context, projectID string, servicesToUpdate []string, user common.User) error {projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)if err != nil {return errdiff --git a/backend/internal/project/project_listing.go b/backend/internal/project/project_listing.goindex 851e3fe61..3fbad90ae 100644--- a/backend/internal/project/project_listing.go+++ b/backend/internal/project/project_listing.go@@ -435,11 +435,16 @@ func buildDiscoveredComposeProjectUpdateRowsInternal(}updateInfoByRef := getRuntimeContainerUpdateInfoByRefInternal(ctx, composeContainers, imageService)+ scoped := getRuntimeContainerUpdateInfoByContainerIDInternal(ctx, composeContainers, imageService)rows := make([]project.Details, 0, len(containersByProject))for projectName, projectContainers := range containersByProject {runtimeServices := buildDiscoveredRuntimeServicesInternal(projectContainers, iconCatalog)imageRefs := projects.ImageRefsFromRuntimeServices(runtimeServices)- updateInfo := buildProjectUpdateInfoSummaryInternal(imageRefs, updateInfoByRef)+ checkServices := make([]project.RuntimeService, 0, len(projectContainers))+ for _, c := range projectContainers {+ checkServices = append(checkServices, project.RuntimeService{Name: dockerutil.ComposeServiceLabel(c.Labels), ContainerID: c.ID, Image: c.Image, ContainerLabels: c.Labels})+ }+ updateInfo := BuildUpdateInfoSummary(imageRefs, mergeProjectContainerUpdateInfoInternal(updateInfoByRef, checkServices, scoped))if updateInfo == nil || !updateInfo.HasUpdate {continue}@@ -474,6 +479,18 @@ func buildDiscoveredComposeProjectUpdateRowsInternal(return rows}+func getRuntimeContainerUpdateInfoByContainerIDInternal(ctx context.Context, containers []container.Summary, imageService *image.ImageService) map[string]*imagetypes.UpdateInfo {+ if imageService == nil || len(containers) == 0 {+ return nil+ }+ scoped, err := imageService.GetUpdateInfoByContainers(ctx, containers)+ if err != nil {+ slog.WarnContext(ctx, "failed to fetch discovered project tag updates", "error", err)+ return nil+ }+ return scoped+}+func getRuntimeContainerUpdateInfoByRefInternal(ctx context.Context,composeContainers []container.Summary,@@ -565,14 +582,15 @@ func buildDiscoveredRuntimeServicesInternal(containers []container.Summary, iconresolvedIcon := iconcatalog.Resolve(iconCatalog, projects.FindArcaneIconSet(c.Labels))runtimeServices = append(runtimeServices, project.RuntimeService{- Name: serviceName,- Image: imageRef,- Status: string(c.State),- ContainerID: c.ID,- ContainerName: containerName,- Ports: projects.FormatDockerPorts(c.Ports),- IconLightURL: resolvedIcon.IconLightURL,- IconDarkURL: resolvedIcon.IconDarkURL,+ Name: serviceName,+ Image: imageRef,+ Status: string(c.State),+ ContainerID: c.ID,+ ContainerLabels: c.Labels,+ ContainerName: containerName,+ Ports: projects.FormatDockerPorts(c.Ports),+ IconLightURL: resolvedIcon.IconLightURL,+ IconDarkURL: resolvedIcon.IconDarkURL,})}@@ -736,11 +754,14 @@ func (s *ProjectService) CountProjectsWithPendingUpdates(ctx context.Context, al}}- // enrichProjectsWithUpdateInfoInternal keys off Details.ID, so the summaries- // only need identity — no status, icons or URLs are read here.+ // Runtime container IDs keep tag-policy updates scoped to their project.details := make([]project.Details, len(activeProjects))+ containersByProject := groupComposeContainersByProjectInternal(allContainers)for i, proj := range activeProjects {details[i].ID = proj.ID+ for _, c := range lookupProjectContainers(proj, containersByProject) {+ details[i].RuntimeServices = append(details[i].RuntimeServices, project.RuntimeService{Name: dockerutil.ComposeServiceLabel(c.Labels), ContainerID: c.ID, Image: c.Image, ContainerLabels: c.Labels})+ }}s.enrichProjectsWithUpdateInfoInternal(ctx, activeProjects, details)@@ -922,6 +943,7 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir stringImage: s.Image,Status: s.Status,ContainerID: s.ContainerID,+ ContainerLabels: s.Labels,ContainerName: s.ContainerName,Ports: s.Ports,Health: s.Health,diff --git a/backend/internal/project/project_update.go b/backend/internal/project/project_update.goindex 57d979761..fe5bd465d 100644--- a/backend/internal/project/project_update.go+++ b/backend/internal/project/project_update.go@@ -10,7 +10,13 @@ import ("strings""time"+ "bytes"+ "fmt"+ "io"+ "slices"+"emperror.dev/errors"+ composetypes "github.com/compose-spec/compose-go/v2/types""github.com/getarcaneapp/arcane/backend/v2/internal/common""github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/internal/event"@@ -22,6 +28,11 @@ import ("github.com/moby/moby/client""go.getarcane.app/acfs"acfstypes "go.getarcane.app/acfs/types"+ "go.getarcane.app/updater"+ "go.getarcane.app/updater/pkg/utils/tagpolicy"+ "go.getarcane.app/updater/refs"+ updatertypes "go.getarcane.app/updater/types"+ "go.yaml.in/yaml/v4""gorm.io/gorm")@@ -993,3 +1004,234 @@ func (s *ProjectService) renameRecoveryOperationsInternal() projecttypes.RenameR},}}++// UpdateProjectServiceImages persists selected service image tags before recreating them.+func (s *ProjectService) UpdateProjectServiceImages(ctx context.Context, projectID string, changes map[string]updatertypes.ServiceImageChange, user common.User) error {+ services, err := s.persistProjectImageChangesInternal(ctx, projectID, changes)+ if err != nil {+ return err+ }+ return s.updateProjectServicesInternal(ctx, projectID, services, user)+}++func (s *ProjectService) persistProjectImageChangesInternal(ctx context.Context, projectID string, changes map[string]updatertypes.ServiceImageChange) ([]string, error) {+ if len(changes) == 0 {+ return nil, errors.New("service image changes are required")+ }+ proj, err := s.getMutableProjectInternal(ctx, projectID)+ if err != nil {+ return nil, err+ }+ if proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != "" {+ return nil, errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")+ }+ effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj)+ if err != nil {+ return nil, fmt.Errorf("load project for tag update: %w", err)+ }+ if len(effective.ComposeFiles) != 1 {+ return nil, errors.New("tag updates require one authoritative Compose file; multi-file selections and overrides must be updated manually")+ }+ logical, err := acfs.LogicalPath(proj.Path, effective.ComposeFiles[0])+ if err != nil {+ return nil, fmt.Errorf("tag update Compose file must be inside the project directory: %w", err)+ }+ original, err := acfs.ReadFile(ctx, proj.Path, logical)+ if err != nil {+ return nil, fmt.Errorf("read Compose source for tag update: %w", err)+ }+ updated, services, err := prepareProjectServiceImagesInternal(original, effective, changes)+ if err != nil {+ return nil, err+ }+ if err := persistProjectServiceImagesInternal(ctx, proj.Path, logical, original, updated); err != nil {+ return nil, err+ }+ s.invalidateProjectCachesInternal(projectID)+ // Keep the desired source on deployment failure: Compose may have partially+ // recreated services, and the pending update must remain retryable.+ return services, nil+}++func prepareProjectServiceImagesInternal(source []byte, effective *composetypes.Project, changes map[string]updatertypes.ServiceImageChange) ([]byte, []string, error) {+ var document yaml.Node+ decoder := yaml.NewDecoder(bytes.NewReader(source))+ if err := decoder.Decode(&document); err != nil {+ return nil, nil, fmt.Errorf("parse Compose source: %w", err)+ }+ var extra yaml.Node+ if err := decoder.Decode(&extra); !errors.Is(err, io.EOF) {+ return nil, nil, errors.New("tag updates require a single YAML document")+ }+ if len(document.Content) != 1 {+ return nil, nil, errors.New("Compose source must contain a mapping")+ }+ if err := validateImageUpdateSourceInternal(document.Content[0]); err != nil {+ return nil, nil, err+ }+ if composeImageFieldInternal(document.Content[0], "include") != nil {+ return nil, nil, errors.New("tag updates do not rewrite Compose includes; update their source manually")+ }+ servicesNode := composeImageFieldInternal(document.Content[0], "services")+ if servicesNode == nil || servicesNode.Kind != yaml.MappingNode {+ return nil, nil, errors.New("Compose source has no services mapping")+ }+ serviceNames := make([]string, 0, len(changes))+ for name, change := range changes {+ service, ok := effective.Services[name]+ if !ok {+ return nil, nil, fmt.Errorf("service %s is not active in the Compose project", name)+ }+ expected, target := refs.NormalizeImageUpdateRef(change.ExpectedRef), refs.NormalizeImageUpdateRef(change.TargetRef)+ if expected == "" || target == "" || refs.IsImageIDLikeReference(change.ExpectedRef) || refs.IsImageIDLikeReference(change.TargetRef) {+ return nil, nil, fmt.Errorf("service %s requires mutable image references", name)+ }+ if refs.NormalizeImageUpdateRef(service.Image) != expected && refs.NormalizeImageUpdateRef(service.Image) != target {+ return nil, nil, fmt.Errorf("service %s image changed since update check: expected %s, found %s", name, change.ExpectedRef, service.Image)+ }+ serviceNode := composeImageFieldInternal(servicesNode, name)+ if composeImageFieldInternal(serviceNode, "extends") != nil {+ return nil, nil, errors.Errorf("tag updates do not rewrite extended service %s; update its source manually", name)+ }+ imageNode := composeImageFieldInternal(serviceNode, "image")+ if imageNode == nil || imageNode.Kind != yaml.ScalarNode || imageNode.Tag != "!!str" {+ return nil, nil, fmt.Errorf("service %s requires an explicit image scalar in the authoritative Compose file", name)+ }+ if !strings.Contains(imageNode.Value, "$") && refs.NormalizeImageUpdateRef(imageNode.Value) != expected && refs.NormalizeImageUpdateRef(imageNode.Value) != target {+ return nil, nil, fmt.Errorf("service %s source image changed since Compose was loaded", name)+ }+ imageNode.Value = change.TargetRef+ serviceNames = append(serviceNames, name)+ }+ slices.Sort(serviceNames)+ var output bytes.Buffer+ encoder := yaml.NewEncoder(&output)+ encoder.SetIndent(2)+ if err := encoder.Encode(&document); err != nil {+ return nil, nil, fmt.Errorf("encode updated Compose source: %w", err)+ }+ if err := encoder.Close(); err != nil {+ return nil, nil, fmt.Errorf("close updated Compose encoder: %w", err)+ }+ return output.Bytes(), serviceNames, nil+}++func validateImageUpdateSourceInternal(node *yaml.Node) error {+ if node.Kind == yaml.AliasNode || node.Anchor != "" {+ return errors.New("tag updates do not rewrite Compose YAML anchors or aliases; use explicit service images")+ }+ if node.Kind == yaml.MappingNode {+ for i := 0; i+1 < len(node.Content); i += 2 {+ if node.Content[i].Value == "<<" {+ return fmt.Errorf("tag updates do not rewrite Compose %s declarations; update their source manually", node.Content[i].Value)+ }+ }+ }+ for _, child := range node.Content {+ if err := validateImageUpdateSourceInternal(child); err != nil {+ return err+ }+ }+ return nil+}++func composeImageFieldInternal(node *yaml.Node, key string) *yaml.Node {+ if node == nil || node.Kind != yaml.MappingNode {+ return nil+ }+ for i := 0; i+1 < len(node.Content); i += 2 {+ if node.Content[i].Value == key {+ return node.Content[i+1]+ }+ }+ return nil+}++func persistProjectServiceImagesInternal(ctx context.Context, projectPath, logical string, original, updated []byte) error {+ entry, err := acfs.Stat(ctx, projectPath, logical, false)+ if err != nil {+ return fmt.Errorf("inspect Compose source: %w", err)+ }+ if entry.IsSymlink {+ return fmt.Errorf("tag updates refuse a symlinked Compose source: %s", filepath.Base(logical))+ }+ current, err := acfs.ReadFile(ctx, projectPath, logical)+ if err != nil {+ return fmt.Errorf("recheck Compose source: %w", err)+ }+ if !bytes.Equal(current, original) {+ return errors.New("Compose source changed during the image update; check updates again")+ }+ if err := acfs.Write(ctx, projectPath, logical, updated, acfs.WriteOptions{Mode: os.FileMode(entry.UnixMode).Perm()}); err != nil {+ return fmt.Errorf("persist Compose image changes: %w", err)+ }+ return nil+}++func (s *ProjectService) projectServiceImageChangesInternal(ctx context.Context, proj *Project, effective *composetypes.Project) (map[string]updatertypes.ServiceImageChange, error) {+ changes := make(map[string]updatertypes.ServiceImageChange)+ for _, name := range effective.ServiceNames() {+ change, err := s.projectServiceImageChangeInternal(ctx, proj, effective.Services[name])+ if err != nil {+ return nil, err+ }+ if change != nil {+ changes[name] = *change+ }+ }+ return changes, nil+}++func (s *ProjectService) projectServiceImageChangeInternal(ctx context.Context, proj *Project, service composetypes.ServiceConfig) (*updatertypes.ServiceImageChange, error) {+ policy := updater.DefaultLabelPolicy()+ name := service.Name+ configuredPolicy := policy.TagPolicy(service.Labels)+ if service.Build != nil && (configuredPolicy.Strategy == "" || configuredPolicy.Strategy == "auto") && configuredPolicy.Constraint == "" && configuredPolicy.TagPattern == "" {+ return nil, nil+ }+ if configuredPolicy.Strategy == "tag" && (refs.IsDigestPinnedReference(service.Image) || refs.IsImageIDLikeReference(service.Image)) {+ return nil, errors.Errorf("service %s has an immutable image reference", name)+ }+ tagPolicy, resolveErr := tagpolicy.Resolve(service.Image, configuredPolicy)+ if resolveErr != nil {+ return nil, errors.WrapIff(resolveErr, "resolve service %s update policy", name)+ }+ if tagPolicy.Strategy == "digest" {+ return nil, nil+ }+ if policy.IsUpdateDisabled(service.Labels) {+ return nil, errors.Errorf("updates are disabled for service %s", name)+ }+ if service.Build != nil {+ return nil, errors.Errorf("tag discovery is unsupported for locally built service %s", name)+ }+ if proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != "" {+ return nil, errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")+ }+ if refs.IsDigestPinnedReference(service.Image) || refs.IsImageIDLikeReference(service.Image) {+ return nil, errors.Errorf("service %s has an immutable image reference", name)+ }+ parsed, err := refs.NormalizeReference(service.Image)+ if err != nil {+ return nil, errors.WrapIff(err, "parse service %s image", name)+ }+ if s.containerRegistryService == nil {+ return nil, errors.New("registry service unavailable for tag updates")+ }+ credentials, err := s.ResolveRegistryCredentials(ctx)+ if err != nil {+ return nil, err+ }+ tags, err := s.containerRegistryService.ListImageTags(ctx, service.Image, credentials)+ if err != nil {+ return nil, errors.WrapIff(err, "list service %s image tags", name)+ }+ selected, err := tagpolicy.Select(parsed.Tag, tags, tagPolicy)+ if err != nil {+ return nil, errors.WrapIff(err, "select service %s image tag", name)+ }+ if selected != parsed.Tag {+ return &updatertypes.ServiceImageChange{ExpectedRef: service.Image, TargetRef: parsed.RegistryHost + "/" + parsed.Repository + ":" + selected}, nil+ }+ return nil, nil+}diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.goindex 529f1d27e..b0efbc1a2 100644--- a/backend/internal/project/service_test.go+++ b/backend/internal/project/service_test.go@@ -30,11 +30,13 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/image""github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate""github.com/getarcaneapp/arcane/backend/v2/internal/kv"+ "github.com/getarcaneapp/arcane/backend/v2/internal/registry""github.com/getarcaneapp/arcane/backend/v2/internal/settings""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumes""github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/projects""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/iconcatalog"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref""github.com/getarcaneapp/arcane/types/v2/containerregistry"imagetypes "github.com/getarcaneapp/arcane/types/v2/image"projecttypes "github.com/getarcaneapp/arcane/types/v2/project"@@ -55,6 +57,7 @@ import ("gorm.io/gorm""github.com/getarcaneapp/arcane/backend/v2/internal/database"+ updatertypes "go.getarcane.app/updater/types")type testBuildBuilder struct {@@ -1043,7 +1046,7 @@ func TestProjectService_UpdateProjectServicesHardFailsWhenPullFailsInternal(t *timageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, event.NewEventService(db, nil, nil))projectPath := createComposeProjectDir(t, projectsDir, "compose-update-pull-fail")- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: "+imageRef+"\n"), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: "+imageRef+"\n labels:\n com.getarcaneapp.arcane.updater.strategy: digest\n"), 0o644))projectRecord := &Project{ID: "project-update-pull-fail",@@ -1074,7 +1077,7 @@ func TestProjectService_UpdateProjectServicesHardFailsWhenPullFailsInternal(t *t}svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, nil, nil, config.Load())- err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, common.SystemUser)+ err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, common.SystemUser, true)require.Error(t, err)require.ErrorContains(t, err, "pull updated service images")assert.False(t, upCalled, "compose up must not run after a pull failure")@@ -1117,7 +1120,7 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.TimageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService)projectPath := createComposeProjectDir(t, projectsDir, "compose-update-force")- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: "+imageRef+"\n unrelated:\n image: busybox:latest\n"), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: "+imageRef+"\n labels:\n com.getarcaneapp.arcane.updater.strategy: digest\n unrelated:\n image: busybox:latest\n"), 0o644))projectRecord := &Project{ID: "project-update-force",@@ -1151,7 +1154,7 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T}svc := NewProjectService(db, settingsService, eventService, imageService, dockerService, nil, nil, nil, config.Load())- err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, common.SystemUser)+ err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, common.SystemUser, true)require.Error(t, err)assert.True(t, eventService.ShouldSuppressDaemonEvent("container", "replacement", "app", "compose-update-force"), "failed updates retain correlation through rollback grace")assert.False(t, eventService.ShouldSuppressDaemonEvent("container", "unrelated", "unrelated", "other-project"))@@ -3506,7 +3509,7 @@ func TestBuildProjectUpdateInfoSummaryInternal(t *testing.T) {for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {- summary := buildProjectUpdateInfoSummaryInternal(tt.imageRefs, tt.updates)+ summary := BuildUpdateInfoSummary(tt.imageRefs, tt.updates)require.NotNil(t, summary)assert.Equal(t, tt.wantStatus, summary.Status)assert.Equal(t, tt.wantCount, summary.ImageCount)@@ -7183,3 +7186,491 @@ func TestProjectPathMapperUsesCurrentSettingsInternal(t *testing.T) {require.Equal(t, filepath.Join(hostDir, "data"), mapped)}}++func TestPrepareProjectServiceImages(t *testing.T) {+ source := []byte("# operator configuration\nservices:\n web:\n image: \"app:${VERSION}\" # keep this comment\n environment:\n VERSION: ${VERSION}\n worker:\n image: app:${VERSION}\n")+ effective := &composetypes.Project{Services: composetypes.Services{"web": {Image: "app:1.2.0"}, "worker": {Image: "app:1.2.0"}}}+ updated, names, err := prepareProjectServiceImagesInternal(source, effective, map[string]updatertypes.ServiceImageChange{"web": {ExpectedRef: "docker.io/library/app:1.2.0", TargetRef: "app:1.3.0"}})+ require.NoError(t, err)+ require.Equal(t, []string{"web"}, names)+ require.Contains(t, string(updated), "# operator configuration")+ require.Contains(t, string(updated), "# keep this comment")+ require.Contains(t, string(updated), "image: \"app:1.3.0\"")+ require.Contains(t, string(updated), "image: app:${VERSION}")+ require.Contains(t, string(updated), "VERSION: ${VERSION}")+ require.Equal(t, "app:1.2.0", effective.Services["web"].Image)+}++func TestPrepareProjectServiceImagesRejectsUnsupportedSource(t *testing.T) {+ for _, tt := range []struct{ name, source, expected string }{+ {"stale effective image", "services:\n web:\n image: app:1.2.0\n", "app:1.1.0"},+ {"stale source image", "services:\n web:\n image: app:1.1.0\n", "app:1.2.0"},+ {"included source", "include: other.yaml\nservices:\n web:\n image: app:1.2.0\n", "app:1.2.0"},+ {"extended service", "services:\n web:\n image: app:1.2.0\n extends: base\n", "app:1.2.0"},+ {"image alias", "x-image: &image app:1.2.0\nservices:\n web:\n image: *image\n", "app:1.2.0"},+ {"missing image", "services:\n web:\n build: .\n", "app:1.2.0"},+ {"multiple documents", "services:\n web:\n image: app:1.2.0\n---\nservices: {}\n", "app:1.2.0"},+ } {+ t.Run(tt.name, func(t *testing.T) {+ effective := &composetypes.Project{Services: composetypes.Services{"web": {Image: "app:1.2.0"}}}+ updated, _, err := prepareProjectServiceImagesInternal([]byte(tt.source), effective, map[string]updatertypes.ServiceImageChange{"web": {ExpectedRef: tt.expected, TargetRef: "app:1.3.0"}})+ require.Error(t, err)+ require.Nil(t, updated)+ })+ }+}++func TestPersistProjectServiceImages(t *testing.T) {+ for _, name := range []string{"success", "concurrent edit", "symlink", "cancellation"} {+ t.Run(name, func(t *testing.T) {+ directory := t.TempDir()+ path := filepath.Join(directory, "compose.yaml")+ original := []byte("services: {}\n")+ updated := []byte("services: {web: {image: app:1.3.0}}\n")+ require.NoError(t, os.WriteFile(path, original, 0o600))+ ctx := context.Background()+ switch name {+ case "concurrent edit":+ require.NoError(t, os.WriteFile(path, []byte("# operator edit\n"), 0o600))+ case "symlink":+ require.NoError(t, os.Rename(path, filepath.Join(directory, "actual.yaml")))+ require.NoError(t, os.Symlink("actual.yaml", path))+ case "cancellation":+ var cancel context.CancelFunc+ ctx, cancel = context.WithCancel(ctx)+ cancel()+ }+ err := persistProjectServiceImagesInternal(ctx, directory, "/compose.yaml", original, updated)+ content, readErr := os.ReadFile(path)+ require.NoError(t, readErr)+ if name == "success" {+ require.NoError(t, err)+ require.Equal(t, updated, content)+ return+ }+ require.Error(t, err)+ require.NotEqual(t, updated, content)+ })+ }+}++func TestUpdateProjectServiceImagesRejectsManagedOrArchived(t *testing.T) {+ for _, name := range []string{"archived", "gitops"} {+ t.Run(name, func(t *testing.T) {+ db := setupProjectTestDB(t)+ proj := Project{ID: "image-update", Name: "image-update", Path: t.TempDir()}+ if name == "archived" {+ proj.IsArchived = true+ } else {+ proj.GitOpsManagedBy = new("sync")+ }+ require.NoError(t, db.Create(&proj).Error)+ service := &ProjectService{db: db}+ err := service.UpdateProjectServiceImages(context.Background(), proj.ID, map[string]updatertypes.ServiceImageChange{"web": {ExpectedRef: "app:1.0.0", TargetRef: "app:1.1.0"}}, common.User{})+ require.Error(t, err)+ if name == "archived" {+ require.ErrorIs(t, err, common.ErrProjectArchived)+ } else {+ require.ErrorContains(t, err, "source repository")+ }+ })+ }+}++type serviceImageCoordinatorInternal struct {+ projecttypes.ComposeCoordinator+ requests []projecttypes.ComposeServiceUpdate+ err error+}++func (c *serviceImageCoordinatorInternal) UpdateServices(_ context.Context, request projecttypes.ComposeServiceUpdate) error {+ c.requests = append(c.requests, request)+ return c.err+}++func TestUpdateProjectServiceImagesPersistsBeforeDeploymentAndRetries(t *testing.T) {+ ctx := context.Background()+ db := setupProjectTestDB(t)+ directory := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", directory)+ settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))+ projectPath := createComposeProjectDir(t, directory, "image-tags")+ source := "# keep\nservices:\n app:\n image: app:${VERSION}\n worker:\n image: app:${VERSION}\n"+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(source), 0o600))+ require.NoError(t, os.Chmod(filepath.Join(projectPath, "compose.yaml"), 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("VERSION=1.2.0\n"), 0o600))+ proj := &Project{ID: "image-tags", Name: "image-tags", Path: projectPath, Status: ProjectStatusRunning}+ require.NoError(t, db.Create(proj).Error)+ deploymentError := errors.New("deployment failed after source persistence")+ coordinator := &serviceImageCoordinatorInternal{err: deploymentError}+ service := &ProjectService{db: db, settingsService: settingsService, eventService: event.NewEventService(db, nil, nil), composeCoordinator: coordinator}+ changes := map[string]updatertypes.ServiceImageChange{"app": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"}}+ for range 2 {+ err := service.UpdateProjectServiceImages(ctx, proj.ID, changes, common.SystemUser)+ require.ErrorIs(t, err, deploymentError)+ content, err := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))+ require.NoError(t, err)+ require.Contains(t, string(content), "image: app:1.3.0")+ require.Contains(t, string(content), "image: app:${VERSION}")+ mode, err := os.Stat(filepath.Join(projectPath, "compose.yaml"))+ require.NoError(t, err)+ require.Equal(t, os.FileMode(0o600), mode.Mode().Perm())+ }+ require.Len(t, coordinator.requests, 2)+ for _, request := range coordinator.requests {+ require.Equal(t, []string{"app"}, request.Services)+ require.Equal(t, "app:1.3.0", request.Project.Services["app"].Image)+ }+ env, err := os.ReadFile(filepath.Join(projectPath, ".env"))+ require.NoError(t, err)+ require.Equal(t, "VERSION=1.2.0\n", string(env))+}++func TestUpdateProjectServiceImagesRejectsOverrideBeforeWriting(t *testing.T) {+ ctx := context.Background()+ db := setupProjectTestDB(t)+ directory := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", directory)+ settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))+ projectPath := createComposeProjectDir(t, directory, "image-overrides")+ original := []byte("services:\n app:\n image: app:1.0.0\n")+ override := []byte("services:\n app:\n image: app:1.2.0\n")+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), original, 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.override.yaml"), override, 0o600))+ proj := &Project{ID: "image-overrides", Name: "image-overrides", Path: projectPath}+ require.NoError(t, db.Create(proj).Error)+ service := &ProjectService{db: db, settingsService: settingsService}+ err = service.UpdateProjectServiceImages(ctx, proj.ID, map[string]updatertypes.ServiceImageChange{"app": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"}}, common.SystemUser)+ require.ErrorContains(t, err, "overrides")+ content, err := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))+ require.NoError(t, err)+ require.Equal(t, original, content)+ content, err = os.ReadFile(filepath.Join(projectPath, "compose.override.yaml"))+ require.NoError(t, err)+ require.Equal(t, override, content)+}++func TestDiscoveredProjectTagUpdatesRemainScoped(t *testing.T) {+ db := setupProjectTestDB(t)+ target := "3.2.0"+ tagLabels := map[string]string{labels.LabelUpdateStrategy: "tag"}+ require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "container::first", PolicyKey: imageref.UpdatePolicyKey("example:3.1.0", tagLabels), ContainerID: "first", ImageID: "shared", Repository: "docker.io/library/example", Tag: "3.1.0", HasUpdate: true, UpdateType: "tag", LatestVersion: &target, CheckTime: time.Now()}).Error)+ containers := []container.Summary{+ {ID: "first-replica", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{labels.LabelUpdateStrategy: "tag", "com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}},+ {ID: "first", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{labels.LabelUpdateStrategy: "tag", "com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}},+ {ID: "second", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{"com.docker.compose.project": "second-project", "com.docker.compose.service": "web"}},+ }+ imageSvc := image.NewImageService(db, nil, nil, nil, nil, nil)+ rows := buildDiscoveredComposeProjectUpdateRowsInternal(t.Context(), containers, nil, imageSvc, "")+ require.Len(t, rows, 1)+ require.Equal(t, "first-project", rows[0].Name)+ require.True(t, rows[0].UpdateInfo.HasUpdate)+ require.Equal(t, target, rows[0].UpdateInfo.UpdateInfoByRef["example:3.1.0"].LatestVersion)+ service := &ProjectService{imageService: image.NewImageService(db, nil, nil, nil, nil, nil)}+ detail := projecttypes.Details{ID: "tracked", RuntimeServices: []projecttypes.RuntimeService{{ContainerID: "first", Image: "example:3.1.0", ContainerLabels: tagLabels}}}+ service.enrichProjectUpdateInfoInternal(t.Context(), &detail)+ require.True(t, detail.UpdateInfo.HasUpdate)+ require.Equal(t, target, detail.UpdateInfo.UpdateInfoByRef["example:3.1.0"].LatestVersion)+ delete(containers[1].Labels, labels.LabelUpdateStrategy)+ rows = buildDiscoveredComposeProjectUpdateRowsInternal(t.Context(), containers, nil, imageSvc, "")+ require.Len(t, rows, 1, "removing tag strategy retains automatic stable-version updates")+ require.True(t, rows[0].UpdateInfo.HasUpdate)+ detail.RuntimeServices[0].ContainerLabels = containers[1].Labels+ service.enrichProjectUpdateInfoInternal(t.Context(), &detail)+ require.True(t, detail.UpdateInfo.HasUpdate, "default auto is equivalent to explicit tag for a stable full version")+ for _, policy := range []map[string]string{{labels.LabelUpdateStrategy: "digest"}, {labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "3.1.x"}, {labels.LabelUpdateStrategy: "tag", labels.LabelUpdateTagPattern: ".*"}, {labels.LabelUpdateStrategy: "tag", labels.LabelUpdater: "off"}} {+ current := map[string]string{"com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}+ for key, value := range policy {+ current[key] = value+ }+ containers[1].Labels = current+ rows = buildDiscoveredComposeProjectUpdateRowsInternal(t.Context(), containers, nil, imageSvc, "")+ require.Empty(t, rows, "stale records must not mark discovered projects updated")+ detail.RuntimeServices[0].ContainerLabels = current+ service.enrichProjectUpdateInfoInternal(t.Context(), &detail)+ require.False(t, detail.UpdateInfo.HasUpdate, "runtime fallback must not apply a stale policy")+ }++}++func TestProjectTagSummaryDoesNotMutateSharedReferenceResults(t *testing.T) {+ base := map[string]*imagetypes.UpdateInfo{"example:3.1.0": {HasUpdate: false, UpdateType: "digest"}}+ scoped := map[string]*imagetypes.UpdateInfo{+ "first": {HasUpdate: true, UpdateType: "tag", LatestVersion: "3.2.0"},+ "second": {HasUpdate: true, UpdateType: "tag", LatestVersion: "4.0.0"},+ }+ merged := mergeProjectContainerUpdateInfoInternal(base, []projecttypes.RuntimeService{{ContainerID: "first", Image: "example:3.1.0"}, {ContainerID: "second", Image: "example:3.1.0"}}, scoped)+ require.True(t, merged["example:3.1.0"].HasUpdate)+ require.Empty(t, merged["example:3.1.0"].LatestVersion)+ require.False(t, base["example:3.1.0"].HasUpdate)+ require.Equal(t, "3.2.0", scoped["first"].LatestVersion)+}++func TestCountProjectsWithPendingTagUpdatesUsesRuntimeContainers(t *testing.T) {+ db := setupProjectTestDB(t)+ settingsService, err := newSettingsServiceForTestInternal(t, t.Context(), db)+ require.NoError(t, err)+ projects := []Project{+ {Name: "first", Path: "first", ImageRefsJSON: `["example:3.1.0"]`},+ {Name: "second", Path: "second", ImageRefsJSON: `["example:3.1.0"]`},+ }+ require.NoError(t, db.Create(&projects).Error)+ require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "container::first-container", PolicyKey: imageref.UpdatePolicyKey("example:3.1.0", map[string]string{labels.LabelUpdateStrategy: "tag"}), ContainerID: "first-container", ImageID: "shared", HasUpdate: true, UpdateType: "tag"}).Error)+ service := &ProjectService{db: db, settingsService: settingsService, imageService: image.NewImageService(db, nil, nil, nil, nil, nil)}+ count, err := service.CountProjectsWithPendingUpdates(t.Context(), []container.Summary{+ {ID: "first-container", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{labels.LabelUpdateStrategy: "tag", "com.docker.compose.project": "first", "com.docker.compose.service": "web"}},+ {ID: "second-container", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{"com.docker.compose.project": "second", "com.docker.compose.service": "web"}},+ })+ require.NoError(t, err)+ require.Equal(t, 1, count)+}++type serviceTagTransportInternal struct {+ tags []string+ calls int+}++func (s *serviceTagTransportInternal) RoundTrip(request *http.Request) (*http.Response, error) {+ s.calls+++ payload, err := json.Marshal(map[string]any{"name": "library/app", "tags": s.tags})+ if err != nil {+ return nil, err+ }+ return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(string(payload))), Request: request}, nil+}++func TestProjectServiceManualUpdateDiscoversTags(t *testing.T) {+ for _, tt := range []struct {+ name string+ tags []string+ wantRef string+ wantChanged bool+ skipDiscovery bool+ wantCalls int+ strategy string+ omitLabels bool+ }{+ {name: "new tag", tags: []string{"1.2.0", "1.3.0", "2.0.0"}, wantRef: "docker.io/library/app:1.3.0", wantChanged: true, wantCalls: 1},+ {name: "same tag digest fallback", tags: []string{"1.2.0", "2.0.0"}, wantRef: "app:1.2.0", wantCalls: 1},+ {name: "planned dependency does not discover tags", tags: []string{"1.2.0", "1.3.0"}, wantRef: "app:1.2.0", skipDiscovery: true},+ {name: "unlabeled automatic tag", tags: []string{"1.2.0", "1.3.0", "2.0.0"}, wantRef: "docker.io/library/app:1.3.0", wantChanged: true, wantCalls: 1, omitLabels: true},+ {name: "explicit automatic tag", tags: []string{"1.2.0", "1.3.0", "2.0.0"}, wantRef: "docker.io/library/app:1.3.0", wantChanged: true, wantCalls: 1, strategy: "auto"},+ {name: "explicit digest optout", tags: []string{"1.2.0", "1.3.0"}, wantRef: "app:1.2.0", strategy: "digest"},+ } {+ t.Run(tt.name, func(t *testing.T) {+ ctx := context.Background()+ db := setupProjectTestDB(t)+ directory := t.TempDir()+ require.NoError(t, db.AutoMigrate(®istry.ContainerRegistry{}))+ t.Setenv("PROJECTS_DIRECTORY", directory)+ settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))+ path := createComposeProjectDir(t, directory, "manual-tag")+ source := "services:\n app:\n image: app:1.2.0\n labels:\n com.getarcaneapp.arcane.updater.strategy: tag\n com.getarcaneapp.arcane.updater.constraint: 1.x\n selected-digest:\n image: busybox:latest\n unselected:\n image: busybox:latest\n"+ if tt.omitLabels {+ source = strings.Replace(source, " labels:\n com.getarcaneapp.arcane.updater.strategy: tag\n com.getarcaneapp.arcane.updater.constraint: 1.x\n", "", 1)+ } else if tt.strategy != "" {+ source = strings.Replace(source, "strategy: tag", "strategy: "+tt.strategy, 1)+ source = strings.Replace(source, " com.getarcaneapp.arcane.updater.constraint: 1.x\n", "", 1)+ }++ require.NoError(t, os.WriteFile(filepath.Join(path, "compose.yaml"), []byte(source), 0o600))+ proj := &Project{ID: "manual-tag", Name: "manual-tag", Path: path, Status: ProjectStatusRunning}+ require.NoError(t, db.Create(proj).Error)+ deploymentError := errors.New("deployment reached")+ coordinator := &serviceImageCoordinatorInternal{err: deploymentError}+ transport := &serviceTagTransportInternal{tags: tt.tags}+ registryService := registry.NewContainerRegistryService(db, nil, nil, &http.Client{Transport: transport})+ service := &ProjectService{db: db, settingsService: settingsService, eventService: event.NewEventService(db, nil, nil), composeCoordinator: coordinator, containerRegistryService: registryService}+ err = service.UpdateProjectServices(ctx, proj.ID, []string{"app", "selected-digest"}, common.SystemUser, !tt.skipDiscovery)+ require.ErrorIs(t, err, deploymentError)+ require.Equal(t, tt.wantCalls, transport.calls)+ require.Len(t, coordinator.requests, 1)+ request := coordinator.requests[0]+ require.ElementsMatch(t, []string{"app", "selected-digest"}, request.Project.ServiceNames())+ require.Equal(t, tt.wantRef, request.Project.Services["app"].Image)+ require.Equal(t, "busybox:latest", request.Project.Services["selected-digest"].Image)+ content, err := os.ReadFile(filepath.Join(path, "compose.yaml"))+ require.NoError(t, err)+ if tt.wantChanged {+ require.Contains(t, string(content), tt.wantRef)+ } else {+ require.Equal(t, source, string(content))+ }+ })+ }+}++func TestProjectServiceManualUpdateRejectsUnsafeTagPolicies(t *testing.T) {+ for _, tt := range []struct {+ name string+ change func(*composetypes.ServiceConfig)+ }{+ {name: "disabled", change: func(s *composetypes.ServiceConfig) { s.Labels[labels.LabelUpdater] = "false" }},+ {name: "invalid constraint", change: func(s *composetypes.ServiceConfig) { s.Labels[labels.LabelUpdateConstraint] = "not semver" }},+ {name: "local build", change: func(s *composetypes.ServiceConfig) { s.Build = &composetypes.BuildConfig{Context: "."} }},+ {name: "digest pin", change: func(s *composetypes.ServiceConfig) { s.Image = "app@sha256:" + strings.Repeat("a", 64) }},+ } {+ t.Run(tt.name, func(t *testing.T) {+ config := composetypes.ServiceConfig{Image: "app:1.2.0", Labels: composetypes.Labels{labels.LabelUpdateStrategy: "tag"}}+ tt.change(&config)+ service := &ProjectService{}+ changes, err := service.projectServiceImageChangesInternal(context.Background(), &Project{}, &composetypes.Project{Services: composetypes.Services{"app": config}})+ require.Error(t, err)+ require.NotContains(t, err.Error(), "registry service unavailable")+ require.Nil(t, changes)+ })+ }+ local := composetypes.ServiceConfig{Name: "app", Image: "app:1.2.0", Build: &composetypes.BuildConfig{Context: "."}}+ changes, err := (&ProjectService{}).projectServiceImageChangesInternal(t.Context(), &Project{}, &composetypes.Project{Services: composetypes.Services{"app": local}})+ require.NoError(t, err)+ require.Empty(t, changes, "automatic inference must preserve local-build handling")++}++func TestConfiguredProjectTagChecksMatchCurrentServicePolicy(t *testing.T) {+ services := []composetypes.ServiceConfig{+ {Name: "stable", Image: "example:3.1.0", Labels: composetypes.Labels{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "3.x"}},+ {Name: "next", Image: "example:3.1.0", Labels: composetypes.Labels{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "4.x"}},+ }+ byRef := map[string]*imagetypes.UpdateInfo{"example:3.1.0": {HasUpdate: false, UpdateType: "digest", CheckTime: time.Now()}}+ unknown := BuildConfiguredUpdateInfo("project", services, byRef, nil)+ require.Equal(t, "unknown", unknown.Status)+ require.Zero(t, unknown.CheckedImageCount)+ require.Nil(t, unknown.ServiceUpdates["stable"].UpdateInfo)+ require.Nil(t, unknown.ServiceUpdates["next"].UpdateInfo)+ firstTarget, secondTarget := "3.2.0", "4.0.0"+ records := []imageupdate.ImageUpdateRecord{+ {ProjectID: "project", ServiceName: "stable", PolicyKey: imageref.UpdatePolicyKey(services[0].Image, services[0].Labels), HasUpdate: true, UpdateType: "tag", LatestVersion: &firstTarget},+ {ProjectID: "project", ServiceName: "next", PolicyKey: imageref.UpdatePolicyKey(services[1].Image, services[1].Labels), HasUpdate: true, UpdateType: "tag", LatestVersion: &secondTarget},+ }+ checked := BuildConfiguredUpdateInfo("project", services, byRef, records)+ require.Equal(t, "has_update", checked.Status)+ require.Equal(t, firstTarget, checked.ServiceUpdates["stable"].UpdateInfo.LatestVersion)+ require.Equal(t, secondTarget, checked.ServiceUpdates["next"].UpdateInfo.LatestVersion)+ require.Empty(t, checked.UpdateInfoByRef["example:3.1.0"].LatestVersion)+ services[0].Labels[labels.LabelUpdateConstraint] = "3.1.x"+ services[1].Image = "example:4.0.0"+ stale := BuildConfiguredUpdateInfo("project", services, byRef, records)+ require.Equal(t, "unknown", stale.Status)+ require.Nil(t, stale.ServiceUpdates["stable"].UpdateInfo)+ require.Nil(t, stale.ServiceUpdates["next"].UpdateInfo)+}++func TestStoppedProjectTagPolicyNeverInheritsSharedDigestCheck(t *testing.T) {+ db := setupProjectTestDB(t)+ projectsDir := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)+ settingsService, err := newSettingsServiceForTestInternal(t, t.Context(), db)+ require.NoError(t, err)+ require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", projectsDir))+ projectPath := createComposeProjectDir(t, projectsDir, "tag-stopped")+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:3.1.0\n labels:\n com.getarcaneapp.arcane.updater.strategy: tag\n com.getarcaneapp.arcane.updater.constraint: 3.x\n"), 0o644))+ projectRecord := &Project{ID: "tag-stopped", Name: "tag-stopped", DirName: new("tag-stopped"), Path: projectPath, Status: ProjectStatusStopped, ImageRefsJSON: `["nginx:3.1.0"]`}+ require.NoError(t, db.Create(projectRecord).Error)+ require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "shared-digest", Repository: "docker.io/library/nginx", Tag: "3.1.0", UpdateType: "digest", CheckTime: time.Now()}).Error)+ imageService := image.NewImageService(db, nil, nil, nil, nil, nil)+ service := NewProjectService(db, settingsService, nil, imageService, nil, nil, nil, nil, config.Load())+ detail, err := service.GetProjectDetails(t.Context(), projectRecord.ID, projecttypes.AllDetails())+ require.NoError(t, err)+ require.Equal(t, "unknown", detail.UpdateInfo.Status)+ require.Nil(t, detail.UpdateInfo.ServiceUpdates["app"].UpdateInfo)+ list := []projecttypes.Details{{ID: projectRecord.ID}}+ service.enrichProjectsWithUpdateInfoInternal(t.Context(), []Project{*projectRecord}, list)+ require.Equal(t, "unknown", list[0].UpdateInfo.Status)+ require.Nil(t, list[0].UpdateInfo.ServiceUpdates["app"].UpdateInfo)+ target := "3.2.0"+ policy := map[string]string{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "3.x"}+ require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "project::tag-stopped::app", ProjectID: projectRecord.ID, ServiceName: "app", PolicyKey: imageref.UpdatePolicyKey("nginx:3.1.0", policy), HasUpdate: true, UpdateType: "tag", LatestVersion: &target, CheckTime: time.Now()}).Error)+ detail, err = service.GetProjectDetails(t.Context(), projectRecord.ID, projecttypes.AllDetails())+ require.NoError(t, err)+ require.Equal(t, "has_update", detail.UpdateInfo.Status)+ require.Equal(t, target, detail.UpdateInfo.ServiceUpdates["app"].UpdateInfo.LatestVersion)+ service.enrichProjectsWithUpdateInfoInternal(t.Context(), []Project{*projectRecord}, list)+ require.Equal(t, "has_update", list[0].UpdateInfo.Status)+}++func TestConfiguredProjectUsesScheduledRuntimeChecks(t *testing.T) {+ for _, tt := range []struct {+ name string+ sourceRef, sourceConstraint, runtimeConstraint string+ wantUpdate bool+ }{+ {name: "scheduled automatic check", sourceRef: "example:3.1.0", wantUpdate: true},+ {name: "source image changed", sourceRef: "example:3.0.0"},+ {name: "source policy changed", sourceRef: "example:3.1.0", sourceConstraint: "3.1.x"},+ {name: "runtime policy changed", sourceRef: "example:3.1.0", runtimeConstraint: "3.1.x"},+ } {+ t.Run(tt.name, func(t *testing.T) {+ ctx := t.Context()+ db := setupProjectTestDB(t)+ directory := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", directory)+ settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))+ path := createComposeProjectDir(t, directory, "scheduled-project")+ sourceLabels := composetypes.Labels{}+ source := "services:\n web:\n image: " + tt.sourceRef + "\n"+ if tt.sourceConstraint != "" {+ sourceLabels[labels.LabelUpdateConstraint] = tt.sourceConstraint+ source += " labels:\n com.getarcaneapp.arcane.updater.constraint: " + tt.sourceConstraint + "\n"+ }+ require.NoError(t, os.WriteFile(filepath.Join(path, "compose.yaml"), []byte(source), 0o600))+ proj := Project{ID: "scheduled-project", Name: "scheduled-project", Path: path}+ require.NoError(t, db.Create(&proj).Error)+ target := "3.2.0"+ require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "container::scheduled", ContainerID: "scheduled", ImageID: "shared", PolicyKey: imageref.UpdatePolicyKey("example:3.1.0", nil), Repository: "docker.io/library/example", Tag: "3.1.0", LatestVersion: &target, HasUpdate: true, UpdateType: "tag", CheckTime: time.Now()}).Error)+ runtimeLabels := map[string]string{"com.docker.compose.project": "scheduled-project", "com.docker.compose.service": "web"}+ if tt.runtimeConstraint != "" {+ runtimeLabels[labels.LabelUpdateConstraint] = tt.runtimeConstraint+ }+ runtime := []projecttypes.RuntimeService{{Name: "web", ContainerID: "scheduled", Image: "example:3.1.0", ContainerLabels: runtimeLabels}}+ service := &ProjectService{db: db, settingsService: settingsService, imageService: image.NewImageService(db, nil, nil, nil, nil, nil)}+ detail := projecttypes.Details{ID: proj.ID, Services: []composetypes.ServiceConfig{{Name: "web", Image: tt.sourceRef, Labels: sourceLabels}}, RuntimeServices: runtime}+ service.enrichProjectUpdateInfoInternal(ctx, &detail)+ require.Equal(t, tt.wantUpdate, detail.UpdateInfo.HasUpdate)+ list := []projecttypes.Details{{ID: proj.ID, RuntimeServices: runtime}}+ service.enrichProjectsWithUpdateInfoInternal(ctx, []Project{proj}, list)+ require.Equal(t, tt.wantUpdate, list[0].UpdateInfo.HasUpdate)+ for _, info := range []*projecttypes.UpdateInfo{detail.UpdateInfo, list[0].UpdateInfo} {+ if tt.wantUpdate {+ require.Equal(t, target, info.ServiceUpdates["web"].UpdateInfo.LatestVersion)+ } else {+ require.Nil(t, info.ServiceUpdates["web"].UpdateInfo)+ require.Equal(t, "unknown", info.Status)+ }+ }+ })+ }+}++func TestConfiguredProjectAggregatesReplicaAndPreviewChecks(t *testing.T) {+ configs := []composetypes.ServiceConfig{{Name: "web", Image: "example:3.1.0"}}+ runtime := []projecttypes.RuntimeService{+ {Name: "web", ContainerID: "one", Image: "example:3.1.0"},+ {Name: "web", ContainerID: "two", Image: "docker.io/library/example:3.1.0"},+ {Name: "other", ContainerID: "unrelated", Image: "example:3.1.0"},+ }+ scoped := map[string]*imagetypes.UpdateInfo{+ "one": {HasUpdate: false, LatestVersion: "3.1.0", UpdateType: "tag"},+ "two": {HasUpdate: true, LatestVersion: "3.2.0", UpdateType: "tag"},+ "unrelated": {HasUpdate: true, LatestVersion: "4.0.0", UpdateType: "tag"},+ }+ runtimeUpdates := configuredRuntimeServiceUpdateInfoInternal(configs, runtime, scoped)+ require.Len(t, runtimeUpdates, 1)+ require.True(t, runtimeUpdates["web"].HasUpdate)+ require.Empty(t, runtimeUpdates["web"].LatestVersion, "conflicting replica targets must not choose an arbitrary version")+ previewTarget := "3.3.0"+ records := []imageupdate.ImageUpdateRecord{{ProjectID: "project", ServiceName: "web", PolicyKey: imageref.UpdatePolicyKey("example:3.1.0", nil), HasUpdate: true, LatestVersion: &previewTarget, UpdateType: "tag"}}+ summary := BuildConfiguredUpdateInfo("project", configs, nil, records, runtimeUpdates)+ require.True(t, summary.HasUpdate)+ require.Empty(t, summary.ServiceUpdates["web"].UpdateInfo.LatestVersion)+ require.Empty(t, summary.UpdateInfoByRef["example:3.1.0"].LatestVersion)+ require.Equal(t, "3.2.0", scoped["two"].LatestVersion, "aggregation must not modify shared checks")+}diff --git a/backend/internal/registry/service.go b/backend/internal/registry/service.goindex 5312b5858..45c8af033 100644--- a/backend/internal/registry/service.go+++ b/backend/internal/registry/service.go@@ -921,66 +921,71 @@ func (s *ContainerRegistryService) InspectImageDigest(ctx context.Context, imagereturn lastResult, nil}-type digestFetchFunc func(ctx context.Context, credential *resolvedRegistryCredential) (string, error)-func (s *ContainerRegistryService) inspectImageDigestViaDaemonInternal(ctx context.Context, normalizedRef, registryHost string, externalCreds []containerregistry.Credential) (*containerregistry.DigestResult, error) {dockerClient, err := s.getDockerClientInternal(ctx)if err != nil {return nil, err}- return s.inspectImageDigestWithCredentialsInternal(ctx, registryHost, "distribution inspect of "+normalizedRef, externalCreds,+ value, result, err := registryOperationWithCredentialsInternal(ctx, s, registryHost, "distribution inspect of "+normalizedRef, externalCreds,func(ctx context.Context, credential *resolvedRegistryCredential) (string, error) {return s.fetchDigestFromDaemonInternal(ctx, dockerClient, registryHost, normalizedRef, credential)})+ if result != nil {+ result.Digest = value+ }+ return result, err}func (s *ContainerRegistryService) inspectImageDigestViaRegistryInternal(ctx context.Context, registryHost, repository, tag string, externalCreds []containerregistry.Credential) (*containerregistry.DigestResult, error) {- return s.inspectImageDigestWithCredentialsInternal(ctx, registryHost, "registry manifest inspect of "+registryHost+"/"+repository+":"+tag, externalCreds,+ value, result, err := registryOperationWithCredentialsInternal(ctx, s, registryHost, "registry manifest inspect of "+registryHost+"/"+repository+":"+tag, externalCreds,func(ctx context.Context, credential *resolvedRegistryCredential) (string, error) {return s.fetchDigestFromRegistryInternal(ctx, registryHost, repository, tag, credential)})+ if result != nil {+ result.Digest = value+ }+ return result, err}// Stored credentials go first: anonymous requests share a per-registry quota with every other unauthenticated client.-func (s *ContainerRegistryService) inspectImageDigestWithCredentialsInternal(ctx context.Context, registryHost, operation string, externalCreds []containerregistry.Credential, fetch digestFetchFunc) (*containerregistry.DigestResult, error) {+func registryOperationWithCredentialsInternal[T any](ctx context.Context, s *ContainerRegistryService, registryHost, operation string, externalCreds []containerregistry.Credential, fetch func(context.Context, *resolvedRegistryCredential) (T, error)) (T, *containerregistry.DigestResult, error) {+ var zero Tcredentials, credErr := s.getMatchingRegistryCredentialsInternal(ctx, registryHost, externalCreds)var lastErr errorvar lastResult *containerregistry.DigestResultfor _, credential := range credentials {lastResult = &containerregistry.DigestResult{AuthMethod: "credential", AuthUsername: credential.Username, AuthRegistry: registryHost, UsedCredential: true}- digestValue, err := fetch(ctx, &credential)+ value, err := fetch(ctx, &credential)if err == nil {- lastResult.Digest = digestValue- return lastResult, nil+ return value, lastResult, nil}lastErr = errif !isUnauthorizedRegistryErrorInternal(err) {- return lastResult, errors.WrapIff(err, "%s failed with credentials", operation)+ return zero, lastResult, errors.WrapIff(err, "%s failed with credentials", operation)}}if lastErr != nil {// Docker Hub anonymous quotas are too small to be worth a retry; elsewhere a stale credential must not break public images.if isDockerHubRegistryInternal(registryHost) {- return lastResult, errors.WrapIff(lastErr, "%s failed", operation)+ return zero, lastResult, errors.WrapIff(lastErr, "%s failed", operation)}- slog.DebugContext(ctx, "credentialed digest lookup failed, retrying anonymously",+ slog.DebugContext(ctx, "credentialed registry lookup failed, retrying anonymously","registry", registryHost,"operation", operation,"error", lastErr.Error())}result := &containerregistry.DigestResult{AuthMethod: "anonymous", AuthRegistry: registryHost}- digestValue, err := fetch(ctx, nil)+ value, err := fetch(ctx, nil)if err == nil {- result.Digest = digestValue- return result, nil+ return value, result, nil}if credErr != nil && isUnauthorizedRegistryErrorInternal(err) {- return result, errors.WrapIff(stderrors.Join(err, credErr), "%s: anonymous access unauthorized; credential lookup failed", operation)+ return zero, result, errors.WrapIff(stderrors.Join(err, credErr), "%s: anonymous access unauthorized; credential lookup failed", operation)}- return result, errors.WrapIff(err, "%s failed", operation)+ return zero, result, errors.WrapIff(err, "%s failed", operation)}func (s *ContainerRegistryService) getDockerClientInternal(ctx context.Context) (RegistryDaemonClient, error) {diff --git a/backend/internal/registry/tags.go b/backend/internal/registry/tags.gonew file mode 100644index 000000000..dc4550c5c--- /dev/null+++ b/backend/internal/registry/tags.go@@ -0,0 +1,35 @@+package registry++import (+ "context"++ "emperror.dev/errors"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"+ "github.com/getarcaneapp/arcane/types/v2/containerregistry"+ "go.getarcane.app/updater/refs"+ updaterregistry "go.getarcane.app/updater/registry"+)++// ListImageTags discovers repository tags with the same credential precedence as+// digest checks. External credentials replace local credentials when supplied.+func (s *ContainerRegistryService) ListImageTags(ctx context.Context, imageRef string, externalCreds []containerregistry.Credential) ([]string, error) {+ if refs.IsDigestPinnedReference(imageRef) || refs.IsImageIDLikeReference(imageRef) {+ return nil, errors.New("cannot discover tags for an immutable image reference")+ }+ parts, err := refs.NormalizeReference(imageRef)+ if err != nil {+ return nil, err+ }+ lookupCtx, cancel := context.WithTimeout(ctx, timeouts.DefaultRegistry)+ defer cancel()++ tags, _, err := registryOperationWithCredentialsInternal(lookupCtx, s, parts.RegistryHost, "registry tag listing of "+parts.NormalizedRef, externalCreds,+ func(ctx context.Context, credential *resolvedRegistryCredential) ([]string, error) {+ var auth *updaterregistry.Credentials+ if credential != nil {+ auth = &updaterregistry.Credentials{Username: credential.Username, Token: credential.Token}+ }+ return updaterregistry.FetchTags(ctx, parts.RegistryHost, parts.Repository, auth, s.distributionHTTPClient)+ })+ return tags, err+}diff --git a/backend/internal/registry/tags_test.go b/backend/internal/registry/tags_test.gonew file mode 100644index 000000000..24eace92b--- /dev/null+++ b/backend/internal/registry/tags_test.go@@ -0,0 +1,104 @@+package registry++import (+ "context"+ "io"+ "net/http"+ "strings"+ "testing"++ "emperror.dev/errors"+ "github.com/getarcaneapp/arcane/types/v2/containerregistry"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestListImageTagsCredentialsInternal(t *testing.T) {+ for _, tt := range []struct {+ name string+ external []containerregistry.Credential+ wantUser string+ wantPassword string+ }{+ {name: "stored", wantUser: "stored-user", wantPassword: "stored-token"},+ {name: "external overrides stored", external: []containerregistry.Credential{{URL: "docker.io", Username: "external-user", Token: "external-token", Enabled: true}}, wantUser: "external-user", wantPassword: "external-token"},+ {name: "external excludes unrelated stored", external: []containerregistry.Credential{{URL: "other.test", Username: "external-user", Token: "external-token", Enabled: true}}},+ {name: "disabled external ignored", external: []containerregistry.Credential{{URL: "docker.io", Username: "external-user", Token: "external-token", Enabled: false}}},+ } {+ t.Run(tt.name, func(t *testing.T) {+ db := setupContainerRegistryTestDBInternal(t)+ createTestPullRegistryInternal(t, db, "https://index.docker.io/v1/", "stored-user", "stored-token")+ calls := 0+ client := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ calls+++ assert.Equal(t, "registry-1.docker.io", req.URL.Host)+ assert.Equal(t, "/v2/library/nginx/tags/list", req.URL.Path)+ user, password, _ := req.BasicAuth()+ assert.Equal(t, tt.wantUser, user)+ assert.Equal(t, tt.wantPassword, password)+ return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader(`{"name":"library/nginx","tags":["1.2.3","1.2.4"]}`)), Header: http.Header{}}, nil+ })}+ svc := NewContainerRegistryService(db, nil, nil, client)+ tags, err := svc.ListImageTags(t.Context(), "nginx:1.2.3", tt.external)+ require.NoError(t, err)+ assert.Equal(t, []string{"1.2.3", "1.2.4"}, tags)+ assert.Equal(t, 1, calls)+ })+ }+}++func TestListImageTagsDoesNotFallBackOnRateLimitInternal(t *testing.T) {+ calls := 0+ svc := NewContainerRegistryService(nil, nil, nil, &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ calls+++ return &http.Response{StatusCode: http.StatusTooManyRequests, Body: io.NopCloser(strings.NewReader("")), Header: http.Header{}}, nil+ })})+ tags, err := svc.ListImageTags(t.Context(), "registry.test/team/app:1.0.0", []containerregistry.Credential{{URL: "registry.test", Username: "user", Token: "token", Enabled: true}})+ require.Error(t, err)+ assert.Nil(t, tags)+ assert.Equal(t, 1, calls)+}++func TestListImageTagsCancellationInternal(t *testing.T) {+ svc := NewContainerRegistryService(nil, nil, nil)+ ctx, cancel := context.WithCancel(t.Context())+ cancel()+ _, err := svc.ListImageTags(ctx, "registry.test/team/app:1.0.0", nil)+ require.True(t, errors.Is(err, context.Canceled), "error = %v", err)+}++func TestListImageTagsRejectedCredentialFallbackInternal(t *testing.T) {+ for _, tt := range []struct {+ name string+ host string+ wantError bool+ wantCalls int+ }{+ {name: "private registry public image", host: "registry.test", wantCalls: 3},+ {name: "docker hub preserves quota", host: "docker.io", wantError: true, wantCalls: 2},+ } {+ t.Run(tt.name, func(t *testing.T) {+ calls := 0+ svc := NewContainerRegistryService(nil, nil, nil, &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {+ calls+++ response := &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader(`{"tags":["1.0.1"]}`)), Header: http.Header{}}+ if req.URL.Path == "/token" {+ response.StatusCode = http.StatusUnauthorized+ } else if req.Header.Get("Authorization") != "" {+ response.StatusCode = http.StatusUnauthorized+ response.Header.Set("WWW-Authenticate", `Bearer realm="https://auth.test/token"`)+ }+ return response, nil+ })})+ tags, err := svc.ListImageTags(t.Context(), tt.host+"/team/app:1.0.0", []containerregistry.Credential{{URL: tt.host, Username: "user", Token: "token", Enabled: true}})+ if tt.wantError {+ require.Error(t, err)+ assert.Nil(t, tags)+ } else {+ require.NoError(t, err)+ assert.Equal(t, []string{"1.0.1"}, tags)+ }+ assert.Equal(t, tt.wantCalls, calls)+ })+ }+}diff --git a/backend/internal/updater/handler.go b/backend/internal/updater/handler.goindex 6aa9575ad..2df50d67a 100644--- a/backend/internal/updater/handler.go+++ b/backend/internal/updater/handler.go@@ -12,6 +12,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/utils""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil""github.com/getarcaneapp/arcane/types/v2/base"+ projecttypes "github.com/getarcaneapp/arcane/types/v2/project""github.com/getarcaneapp/arcane/types/v2/updater")@@ -49,6 +50,11 @@ func RegisterUpdater(api huma.API, updaterService *UpdaterService, appCtx handleappCtx: appCtx.Context(),}+ middleware.RegisterWithPermission(api, huma.Operation{+ OperationID: "check-project-updates", Method: http.MethodPost,+ Path: "/environments/{id}/updater/projects/{projectId}/check",+ Summary: "Check project service updates", Tags: []string{"Updater"}, Security: handlerutil.DefaultOperationSecurity(),+ }, authz.PermImageUpdatesCheck, h.CheckProjectUpdates)middleware.RegisterWithPermission(api, huma.Operation{OperationID: "run-updater",Method: http.MethodPost,@@ -161,3 +167,12 @@ func (h *UpdaterHandler) UpdateContainer(ctx context.Context, input *UpdateConta},}, nil}++// CheckProjectUpdates checks Compose policies through the updater service.+func (h *UpdaterHandler) CheckProjectUpdates(ctx context.Context, input *updater.CheckProjectInput) (*handlerutil.Out[*projecttypes.UpdateInfo], error) {+ result, err := h.updaterService.CheckProjectUpdates(ctx, input.ProjectID)+ if err != nil {+ return nil, err+ }+ return &handlerutil.Out[*projecttypes.UpdateInfo]{Body: base.ApiResponse[*projecttypes.UpdateInfo]{Success: true, Data: result}}, nil+}diff --git a/backend/internal/updater/service.go b/backend/internal/updater/service.goindex 34d0b249a..d085bf018 100644--- a/backend/internal/updater/service.go+++ b/backend/internal/updater/service.go@@ -126,6 +126,7 @@ func (s *UpdaterService) configInternal() updater.Config {RunRecorder: s,Settings: s,RegistryDigestResolver: s.registryDigestResolverInternal(),+ RegistryTagLister: s,ProjectUpdater: s,SelfUpdater: s,Notifier: s,@@ -631,7 +632,7 @@ func (s *UpdaterService) PendingImageUpdates(ctx context.Context) ([]updater.Ima}var records []imageupdate.ImageUpdateRecord- if err := s.deps.DB.WithContext(ctx).Where("has_update = ?", true).Find(&records).Error; err != nil {+ if err := s.deps.DB.WithContext(ctx).Where("has_update = ? AND project_id = ?", true, "").Find(&records).Error; err != nil {return nil, errors.WrapIf(err, "query pending image updates")}@@ -649,11 +650,7 @@ func (s *UpdaterService) PendingImageUpdates(ctx context.Context) ([]updater.Ima10,)- out := make([]updater.ImageUpdateRecord, 0, len(records))- for _, record := range records {- out = append(out, imageUpdateRecordToModuleInternal(record))- }- return out, nil+ return s.scopedPendingRecordsInternal(ctx, records)}// ClearImageUpdateRecord clears a pending image update record after it is handled.@@ -703,7 +700,7 @@ func (s *UpdaterService) UpdateServices(ctx context.Context, projectID string, sif s == nil || s.deps.Projects == nil {return common.Classify(common.ErrUnavailable, errors.New("project service unavailable"))}- return s.deps.Projects.UpdateProjectServices(ctx, projectID, services, s.deps.SystemUser)+ return s.deps.Projects.UpdateProjectServices(ctx, projectID, services, s.deps.SystemUser, false)}// TriggerSelfUpdate runs Arcane's CLI-backed self-update hook.@@ -979,6 +976,7 @@ func (s *UpdaterService) trackActivityInternal(ctx context.Context, activityID sfunc imageUpdateRecordToModuleInternal(record imageupdate.ImageUpdateRecord) updater.ImageUpdateRecord {return updater.ImageUpdateRecord{ID: record.ID,+ ContainerID: record.ContainerID,Repository: record.Repository,Tag: record.Tag,HasUpdate: record.HasUpdate,@@ -1100,7 +1098,15 @@ func (s *UpdaterService) clearImageUpdateRecordForModuleInternal(ctx context.Conreturn nil}+ if record.ContainerID != "" && !strings.HasPrefix(record.ID, "container::") {+ return s.clearUnscopedRecordInternal(ctx, record)+ }query := s.deps.DB.WithContext(ctx).Model(&imageupdate.ImageUpdateRecord{})+ if record.ContainerID != "" {+ query = query.Where("container_id = ?", record.ContainerID)+ } else {+ query = query.Where("container_id = ?", "")+ }if strings.TrimSpace(record.ID) != "" {return query.Where("id = ?", record.ID).Update("has_update", false).Error}diff --git a/backend/internal/updater/service_test.go b/backend/internal/updater/service_test.goindex 720fbad47..9c3f951ff 100644--- a/backend/internal/updater/service_test.go+++ b/backend/internal/updater/service_test.go@@ -1,7 +1,12 @@package updaterimport (+ "fmt"++ composetypes "github.com/compose-spec/compose-go/v2/types"+ projectspkg "github.com/getarcaneapp/arcane/backend/v2/pkg/projects""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/notifications"+ projecttypes "github.com/getarcaneapp/arcane/types/v2/project""github.com/getarcaneapp/arcane/backend/v2/internal/settings"@@ -15,6 +20,7 @@ import ("net/http""net/http/httptest""net/url"+ "slices""strings""sync/atomic""testing"@@ -44,6 +50,7 @@ import ("go.getarcane.app/updater""go.getarcane.app/updater/labels""go.getarcane.app/updater/refs"+ updatertypes "go.getarcane.app/updater/types""gorm.io/gorm")@@ -96,9 +103,10 @@ func (f fakeUsedImageCollectorInternal) UsedImages(context.Context) (map[string]}type fakeProjectUpdaterInternal struct {- projects map[string]updater.ComposeProject- updateErrs map[string]error- calls []string+ projects map[string]updater.ComposeProject+ updateErrs map[string]error+ calls []string+ imageChanges map[string]map[string]updatertypes.ServiceImageChange}func (f *fakeProjectUpdaterInternal) ProjectByComposeName(_ context.Context, composeName string) (updater.ComposeProject, error) {@@ -116,6 +124,20 @@ func (f *fakeProjectUpdaterInternal) UpdateServices(_ context.Context, projectIDreturn f.updateErrs[projectID]}+func (f *fakeProjectUpdaterInternal) UpdateServiceImages(_ context.Context, projectID string, changes map[string]updatertypes.ServiceImageChange) error {+ if f.imageChanges == nil {+ f.imageChanges = map[string]map[string]updatertypes.ServiceImageChange{}+ }+ f.imageChanges[projectID] = changes+ services := make([]string, 0, len(changes))+ for service := range changes {+ services = append(services, service)+ }+ slices.Sort(services)+ f.calls = append(f.calls, projectID+":"+strings.Join(services, ","))+ return f.updateErrs[projectID]+}+func newUpdaterApplyPendingDockerServerInternal(t *testing.T,containers []container.Summary,@@ -679,6 +701,7 @@ func TestUpdaterService_ApplyPending_ProjectFailureDoesNotBlockOtherProjectsInte}inspectByID := map[string]container.InspectResponse{+ "container-success-new": {ID: "container-success-new", Image: newImageIDUpdated, Config: &container.Config{Image: newRefUpdated, Labels: updatedLabels}, State: &container.State{Running: true}},"container-fail": {ID: "container-fail",Image: oldImageIDFailed,@@ -765,12 +788,13 @@ func TestUpdaterService_ApplyPending_ProjectFailureDoesNotBlockOtherProjectsInteresult, err := svc.ApplyPending(ctx, arcaneupdater.Options{})require.NoError(t, err)require.NotNil(t, result)- assert.Equal(t, 3, result.Updated, "updated count should include both image pulls and the successfully updated container")+ assert.Equal(t, 1, result.Updated, "tag updates report successfully recreated containers")assert.Equal(t, 1, result.Failed, "the failed project should be recorded as failed")- assert.GreaterOrEqual(t, len(result.Items), 4)+ assert.Len(t, result.Items, 2)assert.ElementsMatch(t, []string{newRefFailed, newRefUpdated}, puller.pulled)assert.ElementsMatch(t, []string{"project-fail:app", "project-success:app"}, projectUpdater.calls)+ assert.Equal(t, updatertypes.ServiceImageChange{ExpectedRef: oldRefUpdated, TargetRef: newRefUpdated}, projectUpdater.imageChanges["project-success"]["app"])statusByResource := map[string]string{}errorByResource := map[string]string{}for _, item := range result.Items {@@ -779,7 +803,7 @@ func TestUpdaterService_ApplyPending_ProjectFailureDoesNotBlockOtherProjectsInte}assert.Equal(t, string(updater.StatusFailed), statusByResource["container-fail"])- assert.Contains(t, errorByResource["container-fail"], "project-level update failed")+ assert.Contains(t, errorByResource["container-fail"], "pull updated service images: unauthorized")assert.Equal(t, string(updater.StatusUpdated), statusByResource["container-success"])var recordedStatuses []updater.ResourceStatus@@ -1043,3 +1067,125 @@ func setupProjectTestDBInternal(t *testing.T) *database.DB {require.NoError(t, db.AutoMigrate(&project.Project{}, &settings.SettingVariable{}, &imageupdate.ImageUpdateRecord{}, &event.Event{}))return &database.DB{DB: db}}++func TestUpdaterService_ScopedPendingRecordsIsolationInternal(t *testing.T) {+ db := setupProjectTestDBInternal(t)+ imageRef := "registry.example.com/team/app:1.2.3"+ stored := []imageupdate.ImageUpdateRecord{+ {ID: "shared-image", Repository: "registry.example.com/team/app", Tag: "1.2.3", HasUpdate: true, UpdateType: imageupdate.UpdateTypeDigest},+ {ID: "container::tag-a", ContainerID: "tag-a", ImageID: "shared-image", Repository: "registry.example.com/team/app", Tag: "1.2.3", HasUpdate: true, UpdateType: imageupdate.UpdateTypeTag, LatestVersion: new("1.3.0")},+ {ID: "container::tag-b", ContainerID: "tag-b", ImageID: "shared-image", Repository: "registry.example.com/team/app", Tag: "1.2.3", HasUpdate: true, UpdateType: imageupdate.UpdateTypeTag, LatestVersion: new("1.2.4")},+ }+ require.NoError(t, db.Create(&stored).Error)+ containers := []container.Summary{+ {ID: "tag-a", Image: imageRef, ImageID: "shared-image", Labels: map[string]string{labels.LabelUpdateStrategy: "tag"}, State: container.StateRunning},+ {ID: "tag-b", Image: imageRef, ImageID: "shared-image", Labels: map[string]string{labels.LabelUpdateStrategy: "tag"}, State: container.StateRunning},+ {ID: "digest-a", Labels: map[string]string{labels.LabelUpdateStrategy: "digest"}, Image: imageRef, ImageID: "shared-image", State: container.StateRunning},+ {ID: "digest-b", Labels: map[string]string{labels.LabelUpdateStrategy: "digest"}, Image: imageRef, ImageID: "shared-image", State: container.StateRunning},+ }+ server := newUpdaterApplyPendingDockerServerInternal(t, containers, nil, nil, nil)+ dockerSvc := docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClientInternal(t, server))+ svc, err := NewUpdaterService(db, nil, dockerSvc, nil, nil, nil, nil, nil, nil, nil, nil)+ require.NoError(t, err)+ records, err := svc.PendingImageUpdates(t.Context())+ require.NoError(t, err)+ require.Len(t, records, 4)+ byContainer := map[string]updater.ImageUpdateRecord{}+ for _, record := range records {+ byContainer[record.ContainerID] = record+ }+ assert.Equal(t, "1.3.0", *byContainer["tag-a"].LatestVersion)+ assert.Equal(t, "1.2.4", *byContainer["tag-b"].LatestVersion)+ assert.Equal(t, updater.UpdateTypeDigest, byContainer["digest-a"].UpdateType)+ assert.Equal(t, updater.UpdateTypeDigest, byContainer["digest-b"].UpdateType)+ assert.Equal(t, "shared-image", byContainer["digest-b"].ID)++ require.NoError(t, svc.ClearImageUpdateRecord(t.Context(), byContainer["tag-a"]))+ var pending []imageupdate.ImageUpdateRecord+ require.NoError(t, db.Where("has_update = ?", true).Find(&pending).Error)+ var pendingIDs []string+ for _, record := range pending {+ pendingIDs = append(pendingIDs, record.ID)+ }+ assert.ElementsMatch(t, []string{"shared-image", "container::tag-b"}, pendingIDs)+}++func TestUpdaterService_SharedDigestRecordClearingInternal(t *testing.T) {+ for _, tt := range []struct {+ name string+ remainingImage string+ wantPending bool+ }{+ {name: "another container still needs image", remainingImage: "old-image", wantPending: true},+ {name: "all digest containers updated", remainingImage: "new-image", wantPending: false},+ } {+ t.Run(tt.name, func(t *testing.T) {+ db := setupProjectTestDBInternal(t)+ imageRef := "registry.example.com/team/app:1.2.3"+ record := imageupdate.ImageUpdateRecord{ID: "shared-image", Repository: "registry.example.com/team/app", Tag: "1.2.3", HasUpdate: true, UpdateType: imageupdate.UpdateTypeDigest}+ require.NoError(t, db.Create(&record).Error)+ containers := []container.Summary{+ {ID: "updated", Labels: map[string]string{labels.LabelUpdateStrategy: "digest"}, Image: imageRef, ImageID: "new-image", State: container.StateRunning},+ {ID: "remaining", Labels: map[string]string{labels.LabelUpdateStrategy: "digest"}, Image: imageRef, ImageID: tt.remainingImage, State: container.StateRunning},+ {ID: "separate-tag-policy", Image: imageRef, ImageID: "old-image", State: container.StateRunning, Labels: map[string]string{labels.LabelUpdateStrategy: "tag"}},+ }+ server := newUpdaterApplyPendingDockerServerInternal(t, containers, nil, nil, map[string]dockertypesimage.InspectResponse{imageRef: {ID: "new-image"}})+ dockerSvc := docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClientInternal(t, server))+ svc, err := NewUpdaterService(db, nil, dockerSvc, nil, nil, nil, nil, nil, nil, nil, nil)+ require.NoError(t, err)+ converted := imageUpdateRecordToModuleInternal(record)+ converted.ContainerID = "updated"+ require.NoError(t, svc.ClearImageUpdateRecord(t.Context(), converted))+ var actual imageupdate.ImageUpdateRecord+ require.NoError(t, db.First(&actual, "id = ?", record.ID).Error)+ assert.Equal(t, tt.wantPending, actual.HasUpdate)+ })+ }+}++type projectCheckRegistryInternal struct{}++func (projectCheckRegistryInternal) ListTags(context.Context, string) ([]string, error) {+ return []string{"3.20.0", "3.20.1", "3.20.2"}, nil+}++func (projectCheckRegistryInternal) ImageDigest(context.Context, string) (string, error) {+ return "sha256:" + strings.Repeat("a", 64), nil+}++func TestUpdaterProjectChecksWithoutContainersInternal(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ require.Contains(t, r.URL.Path, "/images/", "project checks must not need containers")+ w.Header().Set("Content-Type", "application/json")+ require.NoError(t, json.NewEncoder(w).Encode(dockertypesimage.InspectResponse{ID: "sha256:" + strings.Repeat("a", 64), RepoDigests: []string{"alpine@sha256:" + strings.Repeat("a", 64)}}))+ }))+ defer server.Close()+ puller := &fakeImagePullerInternal{}+ engine, err := updater.New(updater.Config{DockerClientProvider: fakeDockerClientProviderInternal{client: newTestDockerClientInternal(t, server)}, RegistryTagLister: projectCheckRegistryInternal{}, RegistryDigestResolver: projectCheckRegistryInternal{}, ImagePuller: puller})+ require.NoError(t, err)+ service := &UpdaterService{engine: engine}+ for _, metadata := range []bool{false, true} {+ for _, tt := range []struct {+ name, constraint, target string+ available bool+ }{+ {"first", "=3.20.1", "3.20.1", true},+ {"second", "=3.20.2", "3.20.2", true},+ {"control", "=3.20.0", "3.20.0", false},+ } {+ config := composetypes.ServiceConfig{Name: tt.name, Image: "alpine:3.20.0", Labels: map[string]string{labels.LabelUpdateConstraint: tt.constraint}}+ if metadata {+ model, loadErr := projectspkg.LoadComposeProjectFromContent(t.Context(), projecttypes.ComposeContentOptions{ProjectName: "metadata", WorkingDir: t.TempDir(), ComposeContent: fmt.Sprintf("x-arcane:\n updater:\n strategy: auto\nservices:\n %s:\n image: alpine:3.20.0\n x-arcane:\n updater:\n constraint: %q\n", tt.name, tt.constraint)})+ require.NoError(t, loadErr)+ config = model.Services[tt.name]+ }+ record := service.checkProjectServiceInternal(t.Context(), "project", config)+ require.Nil(t, record.LastError)+ require.Equal(t, tt.available, record.HasUpdate)+ require.Equal(t, tt.target, *record.LatestVersion)+ require.Equal(t, "project", record.ProjectID)+ require.Empty(t, record.ContainerID)+ }+ }+ require.Empty(t, puller.pulled)+}diff --git a/backend/internal/updater/tag_updates.go b/backend/internal/updater/tag_updates.gonew file mode 100644index 000000000..3de675be4--- /dev/null+++ b/backend/internal/updater/tag_updates.go@@ -0,0 +1,199 @@+package updater++import (+ "context"+ "strings"+ "time"++ composetypes "github.com/compose-spec/compose-go/v2/types"+ cerrdefs "github.com/containerd/errdefs"+ "github.com/getarcaneapp/arcane/backend/v2/internal/project"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref"+ projecttypes "github.com/getarcaneapp/arcane/types/v2/project"+ "gorm.io/gorm"++ "emperror.dev/errors"+ "github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"+ "github.com/getarcaneapp/arcane/types/v2/containerregistry"+ "github.com/moby/moby/client"+ "go.getarcane.app/updater"+ "go.getarcane.app/updater/pkg/utils/tagpolicy"+ "go.getarcane.app/updater/refs"+ updatertypes "go.getarcane.app/updater/types"+)++// ListTags supplies Arcane's registry credentials to the updater's tag checker.+func (s *UpdaterService) ListTags(ctx context.Context, imageRef string) ([]string, error) {+ if s.deps.RegistryDigestResolver == nil {+ return nil, errors.New("registry service unavailable")+ }+ var credentials []containerregistry.Credential+ if s.deps.Projects != nil {+ resolved, err := s.deps.Projects.ResolveRegistryCredentials(ctx)+ if err != nil {+ return nil, err+ }+ credentials = resolved+ }+ return s.deps.RegistryDigestResolver.ListImageTags(ctx, imageRef, credentials)+}++// UpdateServiceImages persists and redeploys the selected Compose service images.+func (s *UpdaterService) UpdateServiceImages(ctx context.Context, projectID string, changes map[string]updatertypes.ServiceImageChange) error {+ if s.deps.Projects == nil {+ return errors.New("project service unavailable")+ }+ s.appendAutoUpdateActivityMessageInternal(ctx, activityIDFromContextInternal(ctx), "Updating Compose image references", "Persisting image updates", 50)+ return s.deps.Projects.UpdateProjectServiceImages(ctx, projectID, changes, s.deps.SystemUser)+}++func (s *UpdaterService) scopedPendingRecordsInternal(ctx context.Context, records []imageupdate.ImageUpdateRecord) ([]updater.ImageUpdateRecord, error) {+ var scopedCount int64+ if err := s.deps.DB.WithContext(ctx).Model(&imageupdate.ImageUpdateRecord{}).Where("container_id <> ?", "").Limit(1).Count(&scopedCount).Error; err != nil {+ return nil, err+ }+ hasScoped := scopedCount > 0+ if !hasScoped {+ out := make([]updater.ImageUpdateRecord, 0, len(records))+ for _, record := range records {+ out = append(out, imageUpdateRecordToModuleInternal(record))+ }+ return out, nil+ }+ dockerClient, err := s.DockerClient(ctx)+ if err != nil {+ return nil, err+ }+ listed, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{All: false})+ if err != nil {+ return nil, err+ }+ out := make([]updater.ImageUpdateRecord, 0, len(records))+ for _, record := range records {+ converted := imageUpdateRecordToModuleInternal(record)+ if record.ContainerID != "" {+ out = append(out, converted)+ continue+ }+ for _, cnt := range listed.Items {+ resolved, policyErr := tagpolicy.Resolve(cnt.Image, updater.DefaultLabelPolicy().TagPolicy(cnt.Labels))+ if policyErr != nil || resolved.Strategy == "tag" {+ continue+ }+ if refs.NormalizeImageUpdateRef(cnt.Image) != refs.NormalizeImageUpdateRef(converted.ImageRef()) {+ continue+ }+ converted.ContainerID = cnt.ID+ out = append(out, converted)+ }+ }+ return out, nil+}++func (s *UpdaterService) clearUnscopedRecordInternal(ctx context.Context, record updater.ImageUpdateRecord) error {+ dockerClient, err := s.DockerClient(ctx)+ if err != nil {+ return err+ }+ target, err := dockerClient.ImageInspect(ctx, record.NewImageRef())+ if err != nil {+ return err+ }+ listed, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{All: false})+ if err != nil {+ return err+ }+ for _, cnt := range listed.Items {+ resolved, policyErr := tagpolicy.Resolve(cnt.Image, updater.DefaultLabelPolicy().TagPolicy(cnt.Labels))+ if policyErr != nil || resolved.Strategy == "tag" {+ continue+ }+ if refs.NormalizeImageUpdateRef(cnt.Image) == refs.NormalizeImageUpdateRef(record.ImageRef()) && cnt.ImageID != target.ID {+ return nil+ }+ }+ return s.deps.DB.WithContext(ctx).Model(&imageupdate.ImageUpdateRecord{}).Where("id = ? AND container_id = ?", record.ID, "").Update("has_update", false).Error+}++// CheckProjectUpdates checks effective Compose service policies without deploying containers.+func (s *UpdaterService) CheckProjectUpdates(ctx context.Context, projectID string) (*projecttypes.UpdateInfo, error) {+ if s.deps.Projects == nil || s.deps.DB == nil || s.engine == nil {+ return nil, errors.New("project update checker unavailable")+ }+ details, err := s.deps.Projects.GetProjectDetails(ctx, projectID, projecttypes.DetailsOptions{IncludeServiceConfigs: true})+ if err != nil {+ return nil, err+ }+ if len(details.Services) == 0 {+ return nil, errors.New("project has no resolved Compose services to check")+ }+ records := make([]imageupdate.ImageUpdateRecord, 0, len(details.Services))+ for _, service := range details.Services {+ if strings.TrimSpace(service.Image) == "" {+ continue+ }+ records = append(records, s.checkProjectServiceInternal(ctx, projectID, service))+ }+ if err := s.deps.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ if err := tx.Where("project_id = ?", projectID).Delete(&imageupdate.ImageUpdateRecord{}).Error; err != nil {+ return err+ }+ if len(records) == 0 {+ return nil+ }+ return tx.Create(&records).Error+ }); err != nil {+ return nil, errors.WrapIf(err, "save project update checks")+ }+ return project.BuildConfiguredUpdateInfo(projectID, details.Services, nil, records), nil+}++func (s *UpdaterService) checkProjectServiceInternal(ctx context.Context, projectID string, service composetypes.ServiceConfig) imageupdate.ImageUpdateRecord {+ record := imageupdate.ImageUpdateRecord{ID: "project::" + projectID + "::" + service.Name, ProjectID: projectID, ServiceName: service.Name, PolicyKey: imageref.UpdatePolicyKey(service.Image, service.Labels), CheckTime: time.Now().UTC()}+ parsed, err := refs.NormalizeReference(service.Image)+ if err != nil {+ record.LastError = new(err.Error())+ return record+ }+ record.Repository = parsed.RegistryHost + "/" + parsed.Repository+ record.Tag = parsed.Tag+ record.CurrentVersion = parsed.Tag+ if service.Build != nil {+ record.UpdateType = imageupdate.UpdateTypeLocal+ return record+ }+ policy := updater.DefaultLabelPolicy()+ if policy.IsUpdateDisabled(service.Labels) {+ return record+ }+ check, err := s.engine.CheckImageUpdate(ctx, updatertypes.CheckRequest{ImageRef: service.Image, Policy: policy.TagPolicy(service.Labels)})+ if err != nil {+ if cerrdefs.IsNotFound(err) {+ record.UpdateType = imageupdate.UpdateTypeNotPulled+ } else {+ record.LastError = new(err.Error())+ }+ return record+ }+ record.HasUpdate = check.UpdateAvailable+ record.UpdateType = check.UpdateType+ if check.CurrentVersion != "" {+ record.CurrentVersion = check.CurrentVersion+ }+ if check.CurrentDigest != "" {+ record.CurrentDigest = new(check.CurrentDigest)+ }+ if check.TargetDigest != "" {+ record.LatestDigest = new(check.TargetDigest)+ }+ if check.TargetRef != "" {+ target, parseErr := refs.NormalizeReference(check.TargetRef)+ if parseErr != nil {+ record.HasUpdate = false+ record.LastError = new(parseErr.Error())+ } else {+ record.LatestVersion = new(target.Tag)+ }+ }+ return record+}diff --git a/backend/internal/webhook/webhook.go b/backend/internal/webhook/webhook.goindex 57b1be9fe..400f42eff 100644--- a/backend/internal/webhook/webhook.go+++ b/backend/internal/webhook/webhook.go@@ -745,7 +745,7 @@ func (s *WebhookService) syncWebhookContainerTargetInternal(ctx context.Context,func (s *WebhookService) executeProjectWebhookActionInternal(ctx context.Context, wh *Webhook, actionType string) (*updatertypes.Result, error) {switch actionType {case WebhookActionTypeUpdate:- if err := s.projectService.UpdateProjectServices(ctx, wh.TargetID, nil, common.SystemUser); err != nil {+ if err := s.projectService.UpdateProjectServices(ctx, wh.TargetID, nil, common.SystemUser, true); err != nil {return nil, s.wrapWebhookActionErrorInternal(ctx, wh, "project", actionType, err)}return nil, nildiff --git a/backend/pkg/projects/custom_labels.go b/backend/pkg/projects/custom_labels.goindex f6edbf0f8..2b92d1334 100644--- a/backend/pkg/projects/custom_labels.go+++ b/backend/pkg/projects/custom_labels.go@@ -9,9 +9,12 @@ import ("os""path/filepath""slices"+ "strconv""strings""unicode"+ updaterlabels "go.getarcane.app/updater/labels"+"emperror.dev/errors""github.com/compose-spec/compose-go/v2/loader"composetypes "github.com/compose-spec/compose-go/v2/types"@@ -580,3 +583,97 @@ func NormalizeProjectTagColor(color projecttypes.TagColor) (projecttypes.TagColo}return normalized, nil}++// applyUpdaterMetadataInternal translates Compose metadata into the labels the+// updater already consumes, before previews or deployment use the model.+func applyUpdaterMetadataInternal(project *composetypes.Project) error {+ defaults, err := updaterMetadataLabelsInternal(project.Extensions[arcaneBlockKey])+ if err != nil {+ return errors.WrapIf(err, "x-arcane.updater")+ }+ for name, service := range project.Services {+ overrides, err := updaterMetadataLabelsInternal(service.Extensions[arcaneBlockKey])+ if err != nil {+ return errors.WrapIff(err, "service %s x-arcane.updater", name)+ }+ effective := maps.Clone(defaults)+ if effective == nil {+ effective = map[string]string{}+ }+ maps.Copy(effective, overrides)+ if len(effective) == 0 {+ continue+ }+ service.Labels = maps.Clone(service.Labels)+ if service.Labels == nil {+ service.Labels = composetypes.Labels{}+ }+ for key, value := range effective {+ if _, explicit := service.Labels[key]; !explicit {+ service.Labels[key] = value+ }+ }+ project.Services[name] = service+ }+ return nil+}++func updaterMetadataLabelsInternal(block any) (map[string]string, error) {+ arcane, ok := utils.AsStringMap(block).Get()+ if !ok {+ return nil, nil+ }+ raw, present := arcane["updater"]+ if !present {+ return nil, nil+ }+ config, ok := utils.AsStringMap(raw).Get()+ if !ok {+ return nil, errors.New("expected an updater mapping")+ }+ result := make(map[string]string, len(config))+ for key, value := range config {+ if key == "enabled" {+ enabled, err := updaterMetadataEnabledInternal(value)+ if err != nil {+ return nil, err+ }+ result[updaterlabels.LabelUpdater] = strconv.FormatBool(enabled)+ continue+ }+ var label string+ switch key {+ case "strategy":+ label = updaterlabels.LabelUpdateStrategy+ case "constraint":+ label = updaterlabels.LabelUpdateConstraint+ case "tag-pattern":+ label = updaterlabels.LabelUpdateTagPattern+ default:+ return nil, errors.Errorf("unknown updater option %q", key)+ }+ text, ok := value.(string)+ if !ok {+ return nil, errors.Errorf("updater %s must be a string", key)+ }+ text = strings.TrimSpace(text)+ if key == "strategy" && text != "auto" && text != "tag" && text != "digest" {+ return nil, errors.Errorf("unknown updater strategy %q", text)+ }+ result[label] = text+ }+ return result, nil+}++func updaterMetadataEnabledInternal(value any) (bool, error) {+ if enabled, ok := value.(bool); ok {+ return enabled, nil+ }+ if text, ok := value.(string); ok {+ enabled, err := strconv.ParseBool(strings.TrimSpace(text))+ if err == nil {+ return enabled, nil+ }+ }+ return false, errors.New("updater enabled must be a boolean")+}diff --git a/backend/pkg/projects/custom_labels_test.go b/backend/pkg/projects/custom_labels_test.goindex fc95b72ba..cb5a8fa49 100644--- a/backend/pkg/projects/custom_labels_test.go+++ b/backend/pkg/projects/custom_labels_test.go@@ -7,6 +7,9 @@ import ("strings""testing"+ composetypes "github.com/compose-spec/compose-go/v2/types"+ updaterlabels "go.getarcane.app/updater/labels"+projecttypes "github.com/getarcaneapp/arcane/types/v2/project""github.com/stretchr/testify/require")@@ -199,3 +202,97 @@ func TestNormalizeProjectTags(t *testing.T) {_, err = NormalizeProjectTags(tooMany)require.Error(t, err)}++func TestUpdaterMetadataLabelsInternal(t *testing.T) {+ const content = `x-arcane:+ icon: alpine+ updater:+ enabled: true+ strategy: tag+ constraint: "3.x"+ tag-pattern: 'v?(?P<version>\d+\.\d+\.\d+)'+services:+ inherited:+ image: alpine:3.20.0+ overridden:+ image: alpine:3.20.0+ x-arcane:+ updater:+ constraint: "=3.20.1"+ enabled: false+ explicit:+ image: alpine:3.20.0+ x-arcane:+ updater:+ constraint: "=3.20.1"+ labels:+ com.getarcaneapp.arcane.updater.strategy: digest+ com.getarcaneapp.arcane.updater.constraint: ""+ custom: keep+`+ dir := t.TempDir()+ path := filepath.Join(dir, "compose.yaml")+ require.NoError(t, os.WriteFile(path, []byte(content), 0o600))+ disk, err := LoadComposeProject(t.Context(), path, "metadata", dir, false, nil, nil, nil, false, nil, nil)+ require.NoError(t, err)+ memory, err := LoadComposeProjectFromContent(t.Context(), projecttypes.ComposeContentOptions{ComposeContent: content, WorkingDir: dir, ProjectName: "metadata"})+ require.NoError(t, err)+ for _, project := range []*composetypes.Project{disk, memory} {+ inherited := project.Services["inherited"].Labels+ require.Equal(t, "tag", inherited[updaterlabels.LabelUpdateStrategy])+ require.Equal(t, "3.x", inherited[updaterlabels.LabelUpdateConstraint])+ require.Equal(t, "true", inherited[updaterlabels.LabelUpdater])+ overridden := project.Services["overridden"].Labels+ require.Equal(t, "=3.20.1", overridden[updaterlabels.LabelUpdateConstraint])+ require.Equal(t, "false", overridden[updaterlabels.LabelUpdater])+ require.Equal(t, inherited[updaterlabels.LabelUpdateTagPattern], overridden[updaterlabels.LabelUpdateTagPattern])+ explicit := project.Services["explicit"].Labels+ require.Equal(t, "digest", explicit[updaterlabels.LabelUpdateStrategy])+ require.Equal(t, "", explicit[updaterlabels.LabelUpdateConstraint])+ require.Equal(t, "keep", explicit["custom"])+ }+ source, err := os.ReadFile(path)+ require.NoError(t, err)+ require.Equal(t, content, string(source), "loading must not rewrite source into labels")+}++func TestUpdaterMetadataValidationInternal(t *testing.T) {+ for _, config := range []string{"updater: true", "updater: {enabled: maybe}", "updater: {strategy: newest}", "updater: {constraint: 123}", "updater: {tag-pattern: []}", "updater: {unknown: true}"} {+ t.Run(config, func(t *testing.T) {+ _, err := LoadComposeProjectFromContent(t.Context(), projecttypes.ComposeContentOptions{ComposeContent: "services:\n app:\n image: alpine:3.20.0\nx-arcane:\n " + config + "\n", WorkingDir: t.TempDir(), ProjectName: "metadata"})+ require.Error(t, err)+ require.Contains(t, err.Error(), "updater")+ })+ }+}++func TestUpdaterMetadataInterpolationAndIncludesInternal(t *testing.T) {+ dir := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("UPDATE_RANGE=3.20.x\nUPDATE_ENABLED=false\n"), 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(dir, "compose.yaml"), []byte(`include:+ - included.yaml+x-arcane:+ updater:+ strategy: tag+ constraint: "${UPDATE_RANGE}"+ enabled: "${UPDATE_ENABLED}"+services:+ main:+ image: alpine:3.20.0+`), 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(dir, "included.yaml"), []byte(`services:+ child:+ image: alpine:3.20.0+ x-arcane:+ updater:+ enabled: true+ constraint: "=3.20.1"+`), 0o600))+ project, err := LoadComposeProject(t.Context(), filepath.Join(dir, "compose.yaml"), "metadata", dir, false, nil, nil, nil, false, nil, nil)+ require.NoError(t, err)+ require.Equal(t, "3.20.x", project.Services["main"].Labels[updaterlabels.LabelUpdateConstraint])+ require.Equal(t, "false", project.Services["main"].Labels[updaterlabels.LabelUpdater])+ require.Equal(t, "tag", project.Services["child"].Labels[updaterlabels.LabelUpdateStrategy])+ require.Equal(t, "=3.20.1", project.Services["child"].Labels[updaterlabels.LabelUpdateConstraint])+ require.Equal(t, "true", project.Services["child"].Labels[updaterlabels.LabelUpdater])+}diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.goindex b9df8508c..8df1f7f84 100644--- a/backend/pkg/projects/load.go+++ b/backend/pkg/projects/load.go@@ -458,6 +458,9 @@ func LoadComposeProject(}func finishLoadedProjectInternal(ctx context.Context, project *composetypes.Project, workingDir string, pathMapper projecttypes.VolumeSourcePathMapper, translateFileResources bool, rawSources map[string]string) (*composetypes.Project, error) {+ if err := applyUpdaterMetadataInternal(project); err != nil {+ return nil, err+ }project = project.WithoutUnnecessaryResources()ResolveRelativeProjectPaths(project, workingDir)diff --git a/backend/pkg/utils/imageref/update_lookup.go b/backend/pkg/utils/imageref/update_lookup.goindex c760735e9..5b07705f2 100644--- a/backend/pkg/utils/imageref/update_lookup.go+++ b/backend/pkg/utils/imageref/update_lookup.go@@ -5,6 +5,10 @@ import ("fmt""strings"+ "go.getarcane.app/updater"+ "go.getarcane.app/updater/pkg/utils/tagpolicy"+ "go.getarcane.app/updater/refs"+ref "github.com/distribution/reference""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/registryauth")@@ -55,3 +59,12 @@ func ParseUpdateLookup(imageRef string) (originalRef, tag string, repositoryCandreturn trimmedRef, tag, repositoryCandidates, true}++// UpdatePolicyKey identifies the configured reference and selection policy.+func UpdatePolicyKey(imageRef string, labels map[string]string) string {+ policy := updater.DefaultLabelPolicy().TagPolicy(labels)+ if resolved, err := tagpolicy.Resolve(imageRef, policy); err == nil {+ policy = resolved+ }+ return fmt.Sprintf("%q:%q:%q:%q:%t", refs.NormalizeImageUpdateRef(imageRef), policy.Strategy, policy.Constraint, policy.TagPattern, updater.DefaultLabelPolicy().IsUpdateDisabled(labels))+}diff --git a/backend/resources/migrations/postgres/083_add_container_image_updates.sql b/backend/resources/migrations/postgres/083_add_container_image_updates.sqlnew file mode 100644index 000000000..fddd6ebe0--- /dev/null+++ b/backend/resources/migrations/postgres/083_add_container_image_updates.sql@@ -0,0 +1,20 @@+-- +goose Up+ALTER TABLE image_updates ADD COLUMN container_id TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN image_id TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN project_id TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN service_name TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN policy_key TEXT NOT NULL DEFAULT '';+CREATE INDEX idx_image_updates_container_id ON image_updates(container_id);+CREATE INDEX idx_image_updates_image_id ON image_updates(image_id);+CREATE INDEX idx_image_updates_project_id ON image_updates(project_id);++-- +goose Down+DELETE FROM image_updates WHERE container_id <> '' OR project_id <> '';+DROP INDEX idx_image_updates_project_id;+DROP INDEX idx_image_updates_container_id;+DROP INDEX idx_image_updates_image_id;+ALTER TABLE image_updates DROP COLUMN policy_key;+ALTER TABLE image_updates DROP COLUMN service_name;+ALTER TABLE image_updates DROP COLUMN project_id;+ALTER TABLE image_updates DROP COLUMN image_id;+ALTER TABLE image_updates DROP COLUMN container_id;diff --git a/backend/resources/migrations/sqlite/083_add_container_image_updates.sql b/backend/resources/migrations/sqlite/083_add_container_image_updates.sqlnew file mode 100644index 000000000..fddd6ebe0--- /dev/null+++ b/backend/resources/migrations/sqlite/083_add_container_image_updates.sql@@ -0,0 +1,20 @@+-- +goose Up+ALTER TABLE image_updates ADD COLUMN container_id TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN image_id TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN project_id TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN service_name TEXT NOT NULL DEFAULT '';+ALTER TABLE image_updates ADD COLUMN policy_key TEXT NOT NULL DEFAULT '';+CREATE INDEX idx_image_updates_container_id ON image_updates(container_id);+CREATE INDEX idx_image_updates_image_id ON image_updates(image_id);+CREATE INDEX idx_image_updates_project_id ON image_updates(project_id);++-- +goose Down+DELETE FROM image_updates WHERE container_id <> '' OR project_id <> '';+DROP INDEX idx_image_updates_project_id;+DROP INDEX idx_image_updates_container_id;+DROP INDEX idx_image_updates_image_id;+ALTER TABLE image_updates DROP COLUMN policy_key;+ALTER TABLE image_updates DROP COLUMN service_name;+ALTER TABLE image_updates DROP COLUMN project_id;+ALTER TABLE image_updates DROP COLUMN image_id;+ALTER TABLE image_updates DROP COLUMN container_id;diff --git a/frontend/messages/en.json b/frontend/messages/en.jsonindex 5cd2608bd..878c40e56 100644--- a/frontend/messages/en.json+++ b/frontend/messages/en.json@@ -3501,5 +3501,15 @@"jobs_local_health_check": "Local environment health","jobs_health_check": "Environment health","jobs_settings_details": "Settings and details",- "jobs_health_scope_description": "Checks the health and connectivity of this environment."+ "jobs_health_scope_description": "Checks the health and connectivity of this environment.",+ "editor_compose_updater_detail": "Image update policy",+ "editor_compose_updater_info": "Project defaults apply to all services. Service updater fields override project defaults. Explicit updater labels take precedence for each field.",+ "editor_compose_updater_enabled_detail": "Enable image updates",+ "editor_compose_updater_enabled_info": "Boolean. Set to false to disable image updates for the affected services.",+ "editor_compose_updater_strategy_detail": "Update strategy",+ "editor_compose_updater_strategy_info": "Defaults to auto: complete stable semantic version tags follow newer eligible tags; moving tags such as latest and alpine follow digest changes. Set digest to keep the current tag, or tag to require version-based selection.",+ "editor_compose_updater_constraint_detail": "Version constraint",+ "editor_compose_updater_constraint_info": "Semantic version constraint for tag updates, such as 3.x or >=3.1.0 <4.0.0. Without a constraint, updates stay within the current major, or the current minor for 0.x.",+ "editor_compose_updater_tag_pattern_detail": "Tag pattern",+ "editor_compose_updater_tag_pattern_info": "Regular expression matched against the whole tag. Use a named version capture to select a variant, such as (?P<version>\\d+\\.\\d+\\.\\d+)-alpine."}diff --git a/frontend/src/lib/components/code-editor/analysis/compose-schema.ts b/frontend/src/lib/components/code-editor/analysis/compose-schema.tsindex 24bb84af6..31d894446 100644--- a/frontend/src/lib/components/code-editor/analysis/compose-schema.ts+++ b/frontend/src/lib/components/code-editor/analysis/compose-schema.ts@@ -1,3 +1,4 @@+import { m } from '#lib/paraglide/messages.js';import { tryCatch } from '#lib/utils/try-catch.js';import Ajv, { type ValidateFunction } from 'ajv';import type { Completion } from '@codemirror/autocomplete';@@ -104,6 +105,29 @@ const ARCANE_TAG_COMPLETIONS: ArcaneCompletionSpec[] = [const ARCANE_TAG_COLORS = ['gray', 'purple', 'blue', 'green', 'yellow', 'orange', 'red', 'pink'];+function getUpdaterCompletionSpecs(): ArcaneCompletionSpec[] {+ return [+ { label: 'enabled', detail: m.editor_compose_updater_enabled_detail(), info: m.editor_compose_updater_enabled_info() },+ { label: 'strategy', detail: m.editor_compose_updater_strategy_detail(), info: m.editor_compose_updater_strategy_info() },+ {+ label: 'constraint',+ detail: m.editor_compose_updater_constraint_detail(),+ info: m.editor_compose_updater_constraint_info()+ },+ {+ label: 'tag-pattern',+ detail: m.editor_compose_updater_tag_pattern_detail(),+ info: m.editor_compose_updater_tag_pattern_info()+ }+ ];+}++function getUpdaterPathIndex(path: Array<string | number>): number {+ if (isRootArcanePath(path.slice(0, 1)) && path[1] === 'updater') return 1;+ if (isServiceArcanePath(path.slice(0, 3)) && path[3] === 'updater') return 3;+ return -1;+}+function asSchemaObject(value: unknown): SchemaObject | null {if (!value || typeof value !== 'object' || Array.isArray(value)) return null;return value as SchemaObject;@@ -286,9 +310,12 @@ function toArcaneCompletion(spec: ArcaneCompletionSpec): Completion {function getArcaneCompletionOptionsForPath(path: Array<string | number>, prefix = ''): Completion[] {const normalizedPrefix = prefix.toLowerCase();+ const updaterPathIndex = getUpdaterPathIndex(path);let specs: ArcaneCompletionSpec[] = [];- if (isRootPath(path)) {+ if (updaterPathIndex >= 0 && path.length === updaterPathIndex + 1) {+ specs = getUpdaterCompletionSpecs();+ } else if (isRootPath(path)) {specs = ARCANE_ROOT_EXTENSION_COMPLETIONS;} else if (isRootArcanePath(path)) {specs = ARCANE_BLOCK_COMPLETIONS;@@ -300,6 +327,10 @@ function getArcaneCompletionOptionsForPath(path: Array<string | number>, prefixspecs = ARCANE_TAG_COMPLETIONS;}+ if (isRootArcanePath(path) || isServiceArcanePath(path)) {+ specs = [...specs, { label: 'updater', detail: m.editor_compose_updater_detail(), info: m.editor_compose_updater_info() }];+ }+return specs.filter((item) => item.label.toLowerCase().includes(normalizedPrefix)).sort((a, b) => a.label.localeCompare(b.label))@@ -360,6 +391,23 @@ function getServiceArcaneSchemaDoc(path: Array<string | number>): SchemaDoc | nu}function getArcaneSchemaDocForPath(path: Array<string | number>): SchemaDoc | null {+ const updaterPathIndex = getUpdaterPathIndex(path);+ if (updaterPathIndex >= 0) {+ const title = updaterPathIndex === 1 ? 'x-arcane.updater' : 'services.<name>.x-arcane.updater';+ if (path.length === updaterPathIndex + 1) {+ return { title, description: m.editor_compose_updater_info() };+ }+ if (path.length === updaterPathIndex + 2) {+ const field = getUpdaterCompletionSpecs().find((spec) => spec.label === path[updaterPathIndex + 1]);+ if (field)+ return {+ title: `${title}.${field.label}`,+ description: field.info,+ ...(field.label === 'strategy' ? { defaultValue: 'auto' } : {})+ };+ }+ return null;+ }if (isServiceArcanePath(path.slice(0, 3))) return getServiceArcaneSchemaDoc(path);if (path[0] !== 'x-arcane') return null;if (path.length === 1) return ARCANE_SCHEMA_DOCS['x-arcane'] ?? null;@@ -468,6 +516,18 @@ export function getCompletionOptionsForPath(export function getEnumValueCompletions(schema: SchemaObject | null, path: Array<string | number>): Completion[] {const values = new Set<string>();+ const updaterPathIndex = getUpdaterPathIndex(path);+ if (updaterPathIndex >= 0 && path.length === updaterPathIndex + 2) {+ const field = path[updaterPathIndex + 1];+ if (field === 'strategy') {+ values.add('auto');+ values.add('digest');+ values.add('tag');+ } else if (field === 'enabled') {+ values.add('true');+ values.add('false');+ }+ }if (getArcaneSchemaDocForPath(path)?.title === 'x-arcane.tags[].color') {for (const color of ARCANE_TAG_COLORS) values.add(color);}diff --git a/frontend/src/lib/components/image-update-item.svelte b/frontend/src/lib/components/image-update-item.svelteindex 244e6dd1e..80eec3baa 100644--- a/frontend/src/lib/components/image-update-item.svelte+++ b/frontend/src/lib/components/image-update-item.svelte@@ -32,6 +32,8 @@updateInfo?: ImageUpdateData;isLoadingInBackground?: boolean;imageId?: string;+ containerId?: string;+ tagUpdates?: boolean;/** Image reference for ref-scoped checks when no local image ID exists (e.g. not-pulled refs) */imageRef?: string;repo?: string;@@ -48,6 +50,8 @@updateInfo,isLoadingInBackground = false,imageId,+ containerId,+ tagUpdates = false,imageRef,repo,tag,@@ -63,12 +67,24 @@}const imageUpdateQuery = createQuery<ImageUpdateData>(() => ({- queryKey: queryKeys.images.updateCheck(environmentStore.selected?.id || '0', imageId || imageRef || ''),+ queryKey: queryKeys.images.updateCheck(+ environmentStore.selected?.id || '0',+ containerId ? `container:${containerId}` : imageId || imageRef || ''+ ),queryFn: async () => {- if (imageId) return imageService.checkImageUpdateByID(imageId);- const results = await imageService.checkMultipleImages([imageRef ?? '']);- const result = results[imageRef ?? ''];+ const result =+ imageId && !(containerId && imageRef)+ ? await imageService.checkImageUpdateByID(imageId)+ : (await imageService.checkMultipleImages([imageRef ?? '']))[imageRef ?? ''];if (!result) throw new Error(m.images_update_check_failed());+ if (containerId) {+ if (tagUpdates) {+ const scopedResult = result.containerUpdates?.[containerId];+ if (!scopedResult) throw new Error(result.error || m.images_update_check_failed());+ return { ...scopedResult, activityId: scopedResult.activityId ?? result.activityId };+ }+ return result.imageUpdate ?? result;+ }return result;},enabled: false,diff --git a/frontend/src/lib/components/project-update-item.svelte b/frontend/src/lib/components/project-update-item.svelteindex cd98febc2..cdb0a7525 100644--- a/frontend/src/lib/components/project-update-item.svelte+++ b/frontend/src/lib/components/project-update-item.svelte@@ -8,6 +8,7 @@import { Spinner } from '#lib/components/ui/spinner/index.js';import {AlertIcon,+ ArrowRightIcon,CircleArrowUpIcon,ClockIcon,DownloadIcon,@@ -41,7 +42,11 @@const updatedImageRefs = $derived(updateInfo?.updatedImageRefs ?? []);const notPulledImageRefs = $derived(updateInfo?.notPulledImageRefs ?? []);const updateInfoByRef = $derived(updateInfo?.updateInfoByRef ?? {});- const canCheck = $derived(!!onCheck && !disabled && imageRefs.length > 0);+ const serviceUpdates = $derived(Object.entries(updateInfo?.serviceUpdates ?? {}));+ const fallbackUpdatedImageRefs = $derived(+ updatedImageRefs.filter((ref) => !serviceUpdates.some(([, service]) => service.imageRef === ref))+ );+ const canCheck = $derived(!!onCheck && !disabled && (imageRefs.length > 0 || serviceUpdates.length > 0));const directCheckFromTrigger = $derived(canCheck && (status === 'unknown' || status === 'error'));const summaryText = $derived.by(() => {@@ -282,11 +287,36 @@</div>{/if}- {#if status === 'has_update' && updatedImageRefs.length > 0}+ {#if serviceUpdates.length > 0}+ <div class="space-y-2">+ <div class="text-[11px] font-medium tracking-wide text-foreground uppercase">{m.services()}</div>+ <div class="max-h-60 space-y-1 overflow-auto">+ {#each serviceUpdates as [serviceName, service] (serviceName)}+ {@const parsed = parseImageRef(service.imageRef)}+ <div class="rounded-md bg-muted px-2 py-1.5">+ <div class="flex items-center gap-2">+ <ImageUpdateItem updateInfo={service.updateInfo ?? undefined} repo={parsed.repo} tag={parsed.tag} />+ <span class="min-w-0 flex-1 text-xs font-medium break-all">{serviceName}</span>+ </div>+ <div class="mt-1 font-mono text-[11px] break-all text-muted-foreground">{service.imageRef}</div>+ {#if service.updateInfo?.hasUpdate && service.updateInfo.updateType === 'tag' && service.updateInfo.latestVersion}+ <div class="mt-1 flex flex-wrap items-center gap-1 font-mono text-xs break-all">+ <span>{parsed.tag}</span>+ <ArrowRightIcon class="size-3 shrink-0" />+ <span>{service.updateInfo.latestVersion}</span>+ </div>+ {/if}+ </div>+ {/each}+ </div>+ </div>+ {/if}++ {#if status === 'has_update' && fallbackUpdatedImageRefs.length > 0}<div class="space-y-2"><div class="text-[11px] font-medium tracking-wide text-foreground uppercase">{m.images_has_updates()}</div><div class="max-h-40 space-y-1 overflow-auto">- {#each updatedImageRefs as imageRef (imageRef)}+ {#each fallbackUpdatedImageRefs as imageRef (imageRef)}{@render refRow(imageRef)}{/each}</div>@@ -299,7 +329,7 @@<div class="text-xs leading-relaxed text-muted-foreground">{errorMessage || m.image_update_could_not_query_registry()}</div>- {:else}+ {:else if status === 'unknown'}<div class="text-xs leading-relaxed text-muted-foreground">{#if canCheck}{m.image_update_click_to_check()}diff --git a/frontend/src/lib/services/project-service.ts b/frontend/src/lib/services/project-service.tsindex e8c663950..385419855 100644--- a/frontend/src/lib/services/project-service.ts+++ b/frontend/src/lib/services/project-service.ts@@ -1,7 +1,14 @@import { m } from '#lib/paraglide/messages.js';import { environmentStore } from '#lib/stores/environment.store.svelte.js';import type { Paginated, SearchPaginationSortRequest } from '#lib/types/shared.js';-import type { Project, ProjectStatusCounts, ProjectTag, ProjectTagColor, ProjectTagOption } from '#lib/types/swarm.js';+import type {+ Project,+ ProjectStatusCounts,+ ProjectUpdateInfo,+ ProjectTag,+ ProjectTagColor,+ ProjectTagOption+} from '#lib/types/swarm.js';import type { ProjectWorkspaceFileDraft } from '#lib/types/project-workspace.js';import { readNdjsonStream } from '#lib/utils/streaming.js';import { transformPaginationParams } from '#lib/utils/tables.js';@@ -87,6 +94,13 @@ class ProjectService extends BaseAPIService {return this.handleResponse(this.api.post(`/environments/${envId}/projects`, form));}+ async checkUpdates(projectId: string): Promise<ProjectUpdateInfo> {+ const envId = await this.resolveEnvironmentId();+ return this.handleResponse(+ this.api.post(`/environments/${envId}/updater/projects/${encodeURIComponent(projectId)}/check`, {})+ );+ }+async getProject(projectId: string): Promise<Project> {const envId = await this.resolveEnvironmentId();return this.getProjectForEnvironment(envId, projectId);diff --git a/frontend/src/lib/types/docker.ts b/frontend/src/lib/types/docker.tsindex 615ce1519..10d46e26c 100644--- a/frontend/src/lib/types/docker.ts+++ b/frontend/src/lib/types/docker.ts@@ -168,6 +168,7 @@ export interface ContainerEditConfigDto {}export interface ContainerSummaryDto extends BaseContainer {+ updateStrategy?: string;ports: ContainerPorts[];hostConfig: ContainerHostConfig;networkSettings: ContainerNetworkSettings;@@ -445,6 +446,8 @@ export interface ContainerStats {// --- Image DTOs ---export interface ImageUpdateInfoDto {+ imageUpdate?: ImageUpdateInfoDto;+ containerUpdates?: Record<string, ImageUpdateInfoDto>;hasUpdate: boolean;updateType: string;currentVersion: string;diff --git a/frontend/src/lib/types/swarm.ts b/frontend/src/lib/types/swarm.tsindex 988363f56..31d977170 100644--- a/frontend/src/lib/types/swarm.ts+++ b/frontend/src/lib/types/swarm.ts@@ -584,6 +584,7 @@ export interface ProjectUpdateInfo {updatedImageRefs?: string[];notPulledImageRefs?: string[];updateInfoByRef?: Record<string, ImageUpdateData>;+ serviceUpdates?: Record<string, { imageRef: string; updateInfo?: ImageUpdateData | null }>;lastCheckedAt?: string;}diff --git a/frontend/src/routes/(app)/containers/container-table.svelte b/frontend/src/routes/(app)/containers/container-table.svelteindex e5bfac3b7..79c4f7708 100644--- a/frontend/src/routes/(app)/containers/container-table.svelte+++ b/frontend/src/routes/(app)/containers/container-table.svelte@@ -520,6 +520,11 @@<ImageUpdateItemupdateInfo={item.updateInfo}imageId={item.imageId}+ imageRef={item.image}+ containerId={item.id}+ tagUpdates={item.updateStrategy+ ? item.updateStrategy !== 'digest'+ : item.labels?.['com.getarcaneapp.arcane.updater.strategy']?.trim() === 'tag'}repo={imageRef.repo}tag={imageRef.tag}onUpdateContainer={canUpdateContainers ? () => handleUpdateContainer(item) : undefined}diff --git a/frontend/src/routes/(app)/projects/[projectId]/+page.svelte b/frontend/src/routes/(app)/projects/[projectId]/+page.svelteindex 4a1202bf5..de2d2367e 100644--- a/frontend/src/routes/(app)/projects/[projectId]/+page.svelte+++ b/frontend/src/routes/(app)/projects/[projectId]/+page.svelte@@ -52,7 +52,6 @@import { projectService } from '#lib/services/project-service.js';import { projectWorkspaceService } from '#lib/services/project-workspace-service.js';import settingsStore from '#lib/stores/config-store.js';- import { imageService } from '#lib/services/image-service.js';import { gitOpsSyncService } from '#lib/services/gitops-sync-service.js';import { environmentStore } from '#lib/stores/environment.store.svelte.js';import { hasPermission } from '#lib/utils/auth.js';@@ -218,7 +217,6 @@if (!detail) return null;return withLoadedProjectIncludeContent(detail);});- const projectImageRefs = $derived.by(() => getProjectImageRefs(project));const serverName = $derived(project?.name ?? '');const serverComposeContent = $derived(project?.composeContent ?? '');const serverEnvContent = $derived(project?.envContent ?? '');@@ -536,28 +534,6 @@}}- function getProjectImageRefs(details?: Project | null): string[] {- const refs = new Set<string>();-- for (const service of details?.services ?? []) {- const imageRef = service.image?.trim();- if (imageRef) {- refs.add(imageRef);- }- }-- if (refs.size === 0) {- for (const service of details?.runtimeServices ?? []) {- const imageRef = service.image?.trim();- if (imageRef) {- refs.add(imageRef);- }- }- }-- return [...refs];- }-function getProjectIncludeFileContents(details: Project | null | undefined): Record<string, string> {return Object.fromEntries((details?.includeFiles ?? []).flatMap((file) =>@@ -644,23 +620,15 @@const checkProjectUpdatesMutation = createMutation(() => ({mutationKey: queryKeys.projects.detailCheckUpdates(envId ?? '0', projectId),- mutationFn: async () => {- if (projectImageRefs.length === 0) {- return {};- }- return imageService.checkMultipleImages(projectImageRefs);- },- onSuccess: async (results) => {+ mutationFn: () => projectService.checkUpdates(projectId),+ onSuccess: async (result) => {const currentEnvId = envId ?? (await environmentStore.getCurrentEnvironmentId());- const firstError = Object.values(results)- .find((result) => !!result?.error?.trim())- ?.error?.trim();+ const firstError = result.errorMessage?.trim();const hasErrors = !!firstError;- const toastOptions = activityToastOptions(extractActivityId(results));if (hasErrors) {- toast.error(firstError || m.containers_check_updates_failed(), toastOptions);+ toast.error(firstError || m.containers_check_updates_failed());} else {- toast.success(m.images_update_check_completed(), toastOptions);+ toast.success(m.images_update_check_completed());}await Promise.all([refreshProjectDetails(),diff --git a/frontend/src/routes/(app)/projects/projects-table.svelte b/frontend/src/routes/(app)/projects/projects-table.svelteindex 85b15eedb..2b3aa9b4c 100644--- a/frontend/src/routes/(app)/projects/projects-table.svelte+++ b/frontend/src/routes/(app)/projects/projects-table.svelte@@ -18,7 +18,6 @@import type { ColumnSpec, MobileFieldVisibility, BulkAction } from '#lib/components/arcane-table/index.js';import { UniversalMobileCard } from '#lib/components/arcane-table/index.js';import { m } from '#lib/paraglide/messages.js';- import { imageService } from '#lib/services/image-service.js';import { projectService } from '#lib/services/project-service.js';import { FolderOpenIcon, LayersIcon, CalendarIcon, ProjectsIcon, GitBranchIcon, RefreshIcon } from '#lib/icons/index.js';import { environmentStore } from '#lib/stores/environment.store.svelte.js';@@ -82,8 +81,7 @@}async function handleCheckProjectUpdates(project: Project) {- const imageRefs = project.updateInfo?.imageRefs ?? [];- if (imageRefs.length === 0 || checkingProjectIds[project.id]) {+ if (checkingProjectIds[project.id]) {return;}@@ -95,10 +93,8 @@try {const operationResult = await tryCatch((async () => {- const results = await imageService.checkMultipleImages(imageRefs);- const firstError = Object.values(results)- .find((result) => !!result?.error?.trim())- ?.error?.trim();+ const result = await projectService.checkUpdates(project.id);+ const firstError = result.errorMessage?.trim();const hasErrors = !!firstError;if (hasErrors) {toast.error(firstError || m.containers_check_updates_failed());diff --git a/go.work.sum b/go.work.sumindex 1f49f0c54..fa1e84374 100644--- a/go.work.sum+++ b/go.work.sum@@ -2681,6 +2681,8 @@ go.getarcane.app/updater v0.7.3 h1:0RMN1ossGtsHY6QaycYEI+7piX58cm0i3AbCzcn0qj8=go.getarcane.app/updater v0.7.3/go.mod h1:lve1Gq09kl0GSubVWG+QChLKktTR7x2UkHvJ+T2yP78=go.getarcane.app/updater v0.8.0 h1:8R79Pxj9jiH9NBRwvGJAeiG1DFcdwATKM8MN/V6Sz2Q=go.getarcane.app/updater v0.8.0/go.mod h1:Hci6Hziz1tublccxm48pKvhxmmg0n3GC6tPMu4bYl3c=+go.getarcane.app/updater v0.9.1 h1:kQsBIKRAEsCv1xgt7BMClStuNDj8JB2TrjY4djhgTa4=+go.getarcane.app/updater v0.9.1/go.mod h1:rMRAzw2KX5S8Ptjs4HAoN7inIHqxdSFsCHcrQWWK+vw=go.lsp.dev/jsonrpc2 v0.10.0 h1:Pr/YcXJoEOTMc/b6OTmcR1DPJ3mSWl/SWiU1Cct6VmI=go.lsp.dev/jsonrpc2 v0.10.0/go.mod h1:fmEzIdXPi/rf6d4uFcayi8HpFP1nBF99ERP1htC72Ac=go.lsp.dev/pkg v0.0.0-20210717090340-384b27a52fb2 h1:hCzQgh6UcwbKgNSRurYWSqh8MufqRRPODRBblutn4TE=diff --git a/types/container/container.go b/types/container/container.goindex 48ada04bd..3aed865fb 100644--- a/types/container/container.go+++ b/types/container/container.go@@ -867,6 +867,9 @@ type Summary struct {// Required: falseIconDarkURL string `json:"iconDarkUrl,omitempty"`+ // UpdateStrategy is the strategy resolved by the updater for this image and policy.+ UpdateStrategy string `json:"updateStrategy,omitempty"`+// UpdateInfo contains image update information for this container.//// Required: falsediff --git a/types/imageupdate/image_update.go b/types/imageupdate/image_update.goindex 0bbd51566..348d3f1ff 100644--- a/types/imageupdate/image_update.go+++ b/types/imageupdate/image_update.go@@ -7,6 +7,13 @@ import ()type Response struct {+ // ImageUpdate preserves the image-scoped result before container-policy aggregation.+ ImageUpdate *Response `json:"imageUpdate,omitempty"`+ // ImageRef identifies the configured reference for a container-specific check.+ ImageRef string `json:"imageRef,omitempty"`+ // ContainerUpdates contains policy-specific results keyed by container ID.+ ContainerUpdates map[string]*Response `json:"containerUpdates,omitempty"`+// CheckTime is the time when the update check was performed.//// Required: truediff --git a/types/project/project.go b/types/project/project.goindex 5172787f5..d6e07fc4f 100644--- a/types/project/project.go+++ b/types/project/project.go@@ -163,6 +163,9 @@ type DeployOptions struct {// RuntimeService contains live container status information for a service.type RuntimeService struct {+ // ContainerLabels carries runtime policy inputs for server-side update aggregation.+ ContainerLabels map[string]string `json:"-"`+// Name is the service name from the compose file.//// Required: true@@ -219,8 +222,15 @@ type RuntimeService struct {RedeployDisabled bool `json:"redeployDisabled,omitempty"`}+// ServiceUpdateInfo keeps version candidates separate for services sharing an image.+type ServiceUpdateInfo struct {+ ImageRef string `json:"imageRef"`+ UpdateInfo *imagetypes.UpdateInfo `json:"updateInfo,omitempty"`+}+// UpdateInfo contains aggregated image update status for a project.type UpdateInfo struct {+ ServiceUpdates map[string]ServiceUpdateInfo `json:"serviceUpdates,omitempty"`// Status is the aggregate update status for the project.//// Values: has_update | up_to_date | not_pulled | unknown | errordiff --git a/types/updater/updater.go b/types/updater/updater.goindex 5fe869448..f0c438485 100644--- a/types/updater/updater.go+++ b/types/updater/updater.go@@ -164,3 +164,9 @@ type Status struct {// Required: trueProjectIds []string `json:"projectIds"`}++// CheckProjectInput identifies the project whose service policies should be checked.+type CheckProjectInput struct {+ EnvironmentID string `path:"id" doc:"Environment ID"`+ ProjectID string `path:"projectId" doc:"Project ID"`+}