Skip to content

Modern Docker Management, Designed for Everyone

feat: allow for tag based updates for containers (#3865)

Kyle Mendellf8f456a62b86
diff --git a/backend/go.mod b/backend/go.mod
index d60537356..d60414e7d 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -72,7 +72,7 @@ require (
go.getarcane.app/streams v0.4.3
go.getarcane.app/sys/cgroup v0.2.3
go.getarcane.app/sys/crypto v0.2.1
- go.getarcane.app/updater v0.8.1
+ go.getarcane.app/updater v0.9.1
go.uber.org/fx v1.24.0
go.yaml.in/yaml/v4 v4.0.0-rc.6
golang.org/x/crypto v0.56.0
diff --git a/backend/go.sum b/backend/go.sum
index 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/psDOzjWN2vUr6KhKyNWg
go.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.go
index 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.go
index 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.go
index 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.Co
filteredContainers := 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.Summa
return 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).Error
if 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.go
index 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 *testi
require.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.go
index 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, u
if 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 string
tag string
@@ -704,7 +738,7 @@ func (s *ImageService) GetUpdateInfoByImageRefs(ctx context.Context, imageRefs [
var updateRecords []imageupdate.ImageUpdateRecord
if 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[str
return 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.go
index 54788f225..f4b072181 100644
--- a/backend/internal/image/service_test.go
+++ b/backend/internal/image/service_test.go
@@ -2,6 +2,7 @@ package image
import (
"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.go
index 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 stri
if 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 stri
if 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 s
if 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]*im
for _, 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, imageID
func (s *ImageUpdateService) GetUnnotifiedUpdates(ctx context.Context) (map[string]*ImageUpdateRecord, error) {
var records []ImageUpdateRecord
if 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, imageRefs
return 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.DB
if 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.Con
if 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.go
index 6c89a5d1a..dbeac59e9 100644
--- a/backend/internal/imageupdate/model.go
+++ b/backend/internal/imageupdate/model.go
@@ -2,6 +2,8 @@ package imageupdate
import (
"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.go
index 4b080f427..4cc1f87d3 100644
--- a/backend/internal/imageupdate/service_test.go
+++ b/backend/internal/imageupdate/service_test.go
@@ -1,6 +1,7 @@
package imageupdate
import (
+ "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, remo
manifestPath := 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, remoteDigest
manifestPath := 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) *httpt
t.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.go
new file mode 100644
index 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.go
index 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.go
index 83ed3083f..b15579a7e 100644
--- a/backend/internal/project/project_details.go
+++ b/backend/internal/project/project_details.go
@@ -2,6 +2,7 @@ package project
import (
"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 string
resp.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 string
resp.RunningCount = runningCount
resp.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 string
if 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) []projec
Image: 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 string
refs []string
+ services []composetypes.ServiceConfig
}
sem := make(chan struct{}, maxConcurrentComposeReads)
@@ -468,11 +480,7 @@ func (s *ProjectService) enrichProjectsWithUpdateInfoInternal(
var wg sync.WaitGroup
for _, 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.services
allImageRefs = 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.Cont
return 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.go
index 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 err
diff --git a/backend/internal/project/project_listing.go b/backend/internal/project/project_listing.go
index 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, icon
resolvedIcon := 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 string
Image: 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.go
index 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.go
index 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 *t
imageService := 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.T
imageService := 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(&registry.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.go
index 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, image
return 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 T
credentials, credErr := s.getMatchingRegistryCredentialsInternal(ctx, registryHost, externalCreds)
var lastErr error
var lastResult *containerregistry.DigestResult
for _, 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 = err
if !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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 handle
appCtx: 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.go
index 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.Ima
10,
)
- 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, s
if 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 s
func 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.Con
return 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.go
index 720fbad47..9c3f951ff 100644
--- a/backend/internal/updater/service_test.go
+++ b/backend/internal/updater/service_test.go
@@ -1,7 +1,12 @@
package updater
import (
+ "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, projectID
return 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_ProjectFailureDoesNotBlockOtherProjectsInte
result, 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.go
new file mode 100644
index 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.go
index 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, nil
diff --git a/backend/pkg/projects/custom_labels.go b/backend/pkg/projects/custom_labels.go
index 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.go
index 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.go
index 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.go
index 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, repositoryCand
return 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.sql
new file mode 100644
index 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.sql
new file mode 100644
index 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.json
index 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.ts
index 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>, prefix
specs = 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.svelte
index 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.svelte
index 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.ts
index 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.ts
index 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.ts
index 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.svelte
index 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 @@
<ImageUpdateItem
updateInfo={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.svelte
index 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.svelte
index 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.sum
index 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.go
index 48ada04bd..3aed865fb 100644
--- a/types/container/container.go
+++ b/types/container/container.go
@@ -867,6 +867,9 @@ type Summary struct {
// Required: false
IconDarkURL 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: false
diff --git a/types/imageupdate/image_update.go b/types/imageupdate/image_update.go
index 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: true
diff --git a/types/project/project.go b/types/project/project.go
index 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 | error
diff --git a/types/updater/updater.go b/types/updater/updater.go
index 5fe869448..f0c438485 100644
--- a/types/updater/updater.go
+++ b/types/updater/updater.go
@@ -164,3 +164,9 @@ type Status struct {
// Required: true
ProjectIds []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"`
+}