Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: keep selected tag on self-update and refresh stale project update status
Kyle Mendelle862615fc4e4
diff --git a/backend/cli/recovery/recovery.go b/backend/cli/recovery/recovery.goindex 15a931827..5c35a45fb 100644--- a/backend/cli/recovery/recovery.go+++ b/backend/cli/recovery/recovery.go@@ -134,7 +134,7 @@ func runRestoreInternal(cmd *cobra.Command, _ []string) error {if finalizeRestoredBackupErr := finalizeRestoredBackupInternal(ctx, manifest.Environment["DATABASE_URL"], manifest.BackupID, manifest.ActivityID, request); finalizeRestoredBackupErr != nil {return fmt.Errorf("finalize restored system backup: %w", finalizeRestoredBackupErr)}- if upgradeContainerErr := upgrade.UpgradeContainer(ctx, dockerClient, inspect.Container, request.ContainerImage, manifest.Environment); upgradeContainerErr != nil {+ if upgradeContainerErr := upgrade.UpgradeContainer(ctx, dockerClient, inspect.Container, request.ContainerImage, "", manifest.Environment); upgradeContainerErr != nil {return fmt.Errorf("recreate Arcane container with recovered configuration: %w", upgradeContainerErr)}return nildiff --git a/backend/cli/upgrade/upgrade.go b/backend/cli/upgrade/upgrade.goindex 853be1b46..85c3cc343 100644--- a/backend/cli/upgrade/upgrade.go+++ b/backend/cli/upgrade/upgrade.go@@ -20,6 +20,7 @@ import (kit "go.getarcane.app/kit/pkg""go.getarcane.app/sys/cgroup""go.getarcane.app/updater/labels"+ "go.getarcane.app/updater/refs""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane""github.com/getarcaneapp/arcane/backend/v2/pkg/projects"@@ -28,6 +29,7 @@ import (var (containerName stringtargetImage string+ pullImageRef stringautoDetect bool)@@ -54,6 +56,7 @@ This command should be run from outside the container (e.g., from the host or anfunc init() {UpgradeCmd.Flags().StringVarP(&containerName, "container", "c", "", "Name of the container to upgrade")UpgradeCmd.Flags().StringVarP(&targetImage, "image", "i", "", "Target image to upgrade to (defaults to current tag)")+ UpgradeCmd.Flags().StringVar(&pullImageRef, "pull-image", "", "Immutable reference to pull and tag as --image (defaults to --image)")UpgradeCmd.Flags().BoolVarP(&autoDetect, "auto", "a", false, "Auto-detect Arcane container")}@@ -94,35 +97,81 @@ func runUpgrade(cmd *cobra.Command, args []string) error {targetContainer = inspectResult.Container}- // Determine image to pull- imageToPull := targetImage- if imageToPull == "" {- imageToPull = determineImageName(ctx, dockerClient, targetContainer)- slog.InfoContext(ctx, "Determined image to pull", "image", imageToPull)+ // Determine the reference the container should run as, and what to pull.+ newImage := targetImage+ if newImage == "" {+ newImage = determineImageName(ctx, dockerClient, targetContainer)+ slog.InfoContext(ctx, "Determined image to pull", "image", newImage)}+ imageToPull := cmp.Or(strings.TrimSpace(pullImageRef), newImage)// Pull the new imageslog.InfoContext(ctx, "Pulling new image", "image", imageToPull)if pullImageErr := pullImage(ctx, dockerClient, imageToPull); pullImageErr != nil {return fmt.Errorf("failed to pull image: %w", pullImageErr)}+ // A frozen pull is tagged back as the selected reference so the recreated+ // container keeps its tag instead of an immutable digest.+ if imageToPull != newImage {+ if tagErr := tagPulledImage(ctx, dockerClient, imageToPull, newImage); tagErr != nil {+ return fmt.Errorf("failed to tag pulled image: %w", tagErr)+ }+ }// The pull always runs so a mutable tag gets re-resolved, but when it lands on// the image the container already runs there is nothing to swap in. Skipping the- // recreate avoids needless downtime and, for agents, a dropped connection.- if same, pulledID := pulledImageAlreadyRunning(ctx, dockerClient, imageToPull, targetContainer.Image); same {+ // recreate avoids needless downtime and, for agents, a dropped connection. A+ // container running the right image under a different reference is still+ // recreated so its reference is corrected.+ same, pulledID := pulledImageAlreadyRunning(ctx, dockerClient, imageToPull, targetContainer.Image)+ if pulledID == "" {+ return fmt.Errorf("could not resolve pulled image %s; refusing to recreate", imageToPull)+ }+ if same && targetContainer.Config != nil && strings.TrimSpace(targetContainer.Config.Image) == newImage {slog.InfoContext(ctx, "Image unchanged after pull; already up to date, skipping recreate",- "container", containerName, "image", imageToPull, "imageId", pulledID)+ "container", containerName, "image", newImage, "imageId", pulledID)return nil}// Perform the upgradeslog.InfoContext(ctx, "Starting container upgrade", "container", containerName)- if upgradeContainerErr := UpgradeContainer(ctx, dockerClient, targetContainer, imageToPull, nil); upgradeContainerErr != nil {+ if upgradeContainerErr := UpgradeContainer(ctx, dockerClient, targetContainer, newImage, pulledID, nil); upgradeContainerErr != nil {return fmt.Errorf("failed to upgrade container: %w", upgradeContainerErr)}- slog.InfoContext(ctx, "Upgrade completed successfully", "container", containerName, "image", imageToPull)+ slog.InfoContext(ctx, "Upgrade completed successfully", "container", containerName, "image", newImage)+ return nil+}++// tagPulledImage tags the pulled immutable reference as the selected one and+// verifies the tag now resolves to the pulled image. Both must name the same+// repository.+func tagPulledImage(ctx context.Context, dockerClient *client.Client, pulled, selected string) error {+ pulledRef, err := refs.NormalizeReference(pulled)+ if err != nil {+ return err+ }+ selectedRef, err := refs.NormalizeReference(selected)+ if err != nil {+ return err+ }+ if pulledRef.RegistryHost != selectedRef.RegistryHost || pulledRef.Repository != selectedRef.Repository {+ return fmt.Errorf("pulled image %s does not belong to repository of %s", pulled, selected)+ }+ if _, tagErr := dockerClient.ImageTag(ctx, client.ImageTagOptions{Source: pulled, Target: selected}); tagErr != nil {+ return tagErr+ }+ pulledInspect, err := dockerClient.ImageInspect(ctx, pulled)+ if err != nil {+ return fmt.Errorf("inspect pulled image: %w", err)+ }+ selectedInspect, err := dockerClient.ImageInspect(ctx, selected)+ if err != nil {+ return fmt.Errorf("inspect tagged image: %w", err)+ }+ if pulledInspect.ID != selectedInspect.ID {+ return fmt.Errorf("%s resolves to %s after tagging, expected %s", selected, selectedInspect.ID, pulledInspect.ID)+ }return nil}@@ -421,15 +470,15 @@ func inferImageNameFromDocker(ctx context.Context, dockerClient *client.Client,// pulledImageAlreadyRunning reports whether the freshly pulled reference resolves to// the image the target container is already running, along with the resolved image ID.-// An inspect failure reports false: recreating unnecessarily is safer than skipping a-// real update.+// An inspect failure reports false and an empty ID; callers must resolve the+// expected image before recreating the container.func pulledImageAlreadyRunning(ctx context.Context, dockerClient *client.Client, imageRef, runningImageID string) (bool, string) {if runningImageID == "" {return false, ""}inspect, err := dockerClient.ImageInspect(ctx, imageRef)if err != nil {- slog.WarnContext(ctx, "Could not inspect pulled image; continuing with recreate", "image", imageRef, "error", err)+ slog.WarnContext(ctx, "Could not inspect pulled image", "image", imageRef, "error", err)return false, ""}return inspect.ID == runningImageID, inspect.ID@@ -446,9 +495,9 @@ func pullImage(ctx context.Context, dockerClient *client.Client, imageName strin}// UpgradeContainer recreates an Arcane container with the supplied image and-// optional environment replacements. It is invoked from detached maintenance-// containers so stopping the target cannot interrupt the operation.-func UpgradeContainer(ctx context.Context, dockerClient *client.Client, oldContainer container.InspectResponse, newImage string, environment map[string]string) error {+// optional expected image ID and environment replacements. It runs from detached+// maintenance containers so stopping the target cannot interrupt the operation.+func UpgradeContainer(ctx context.Context, dockerClient *client.Client, oldContainer container.InspectResponse, newImage, expectedImageID string, environment map[string]string) error {originalName := strings.TrimPrefix(oldContainer.Name, "/")oldName := fmt.Sprintf("%s-old-%d", originalName, time.Now().UnixNano())@@ -464,7 +513,7 @@ func UpgradeContainer(ctx context.Context, dockerClient *client.Client, oldContaconfig.Env = applyRecoveredEnvironmentInternal(config.Env, environment)}- config.Labels = refreshRecreatedContainerLabelsInternal(ctx, dockerClient, config.Labels, oldContainer.Image, newImage)+ config.Labels = refreshRecreatedContainerLabelsInternal(ctx, dockerClient, config.Labels, oldContainer.Image, cmp.Or(expectedImageID, newImage))hostConfig, sanitizedMemorySwappiness, engineInfo, err := compat.PrepareRecreateHostConfigForEngine(ctx, dockerClient, oldContainer.HostConfig)if err != nil {@@ -570,14 +619,35 @@ func UpgradeContainer(ctx context.Context, dockerClient *client.Client, oldContareturn fmt.Errorf("create new container: %w", err)}- fmt.Println("PROGRESS:80:Starting new container")- slog.InfoContext(ctx, "Starting new container", "id", resp.ID[:12])- if _, containerStartErr := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); containerStartErr != nil {- // Cleanup new container and restart old one- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, client.ContainerRemoveOptions{Force: true})- _, _ = dockerClient.ContainerStart(ctx, oldContainer.ID, client.ContainerStartOptions{})- _, _ = dockerClient.ContainerRename(ctx, oldContainer.ID, client.ContainerRenameOptions{NewName: originalName})- return fmt.Errorf("start new container: %w", containerStartErr)+ // Docker resolves the tag at creation. Inspect the created container so a+ // concurrent pull cannot cause an unselected image to start.+ if expectedImageID != "" {+ created, inspectErr := compat.ContainerInspectWithCompatibility(ctx, dockerClient, resp.ID, client.ContainerInspectOptions{})+ if inspectErr != nil {+ err = fmt.Errorf("inspect new container image: %w", inspectErr)+ } else if created.Container.Image != expectedImageID {+ err = fmt.Errorf("new container uses image %s, expected %s", created.Container.Image, expectedImageID)+ }+ }+ if err == nil {+ fmt.Println("PROGRESS:80:Starting new container")+ slog.InfoContext(ctx, "Starting new container", "id", resp.ID[:12])+ if _, startErr := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); startErr != nil {+ err = fmt.Errorf("start new container: %w", startErr)+ }+ }+ if err != nil {+ // Cleanup the rejected replacement and restore the original container.+ if _, removeErr := dockerClient.ContainerRemove(ctx, resp.ID, client.ContainerRemoveOptions{Force: true}); removeErr != nil {+ err = errors.Join(err, fmt.Errorf("remove new container: %w", removeErr))+ }+ if _, startErr := dockerClient.ContainerStart(ctx, oldContainer.ID, client.ContainerStartOptions{}); startErr != nil {+ err = errors.Join(err, fmt.Errorf("restart old container: %w", startErr))+ }+ if _, renameErr := dockerClient.ContainerRename(ctx, oldContainer.ID, client.ContainerRenameOptions{NewName: originalName}); renameErr != nil {+ err = errors.Join(err, fmt.Errorf("restore old container name: %w", renameErr))+ }+ return err}// Wait a moment for the new container to initializediff --git a/backend/cli/upgrade/upgrade_test.go b/backend/cli/upgrade/upgrade_test.goindex abdfccfa2..89eb6589e 100644--- a/backend/cli/upgrade/upgrade_test.go+++ b/backend/cli/upgrade/upgrade_test.go@@ -207,3 +207,56 @@ func TestRefreshRecreatedContainerLabelsInternalPreservesOverridesWhenPreviousIn"com.docker.compose.image": "sha256:new-image",}, got)}++func TestTagPulledImage(t *testing.T) {+ const pulled = "ghcr.io/getarcaneapp/arcane@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"+ const selected = "ghcr.io/getarcaneapp/arcane:next"++ t.Run("rejects a pull from another repository", func(t *testing.T) {+ err := tagPulledImage(t.Context(), nil, "ghcr.io/getarcaneapp/arcane-agent@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", selected)+ require.ErrorContains(t, err, "does not belong to repository")+ })++ newClient := func(t *testing.T, selectedID string, tagStatus int) *client.Client {+ t.Helper()+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/tag"):+ assert.Equal(t, "next", r.URL.Query().Get("tag"))+ w.WriteHeader(tagStatus)+ case strings.Contains(r.URL.Path, "@sha256:") && strings.HasSuffix(r.URL.Path, "/json"):+ w.Header().Set("Content-Type", "application/json")+ _, err := w.Write([]byte(`{"Id":"sha256:pulled"}`))+ assert.NoError(t, err)+ case strings.Contains(r.URL.Path, "arcane:next/json"):+ w.Header().Set("Content-Type", "application/json")+ _, err := w.Write([]byte(`{"Id":"` + selectedID + `"}`))+ assert.NoError(t, err)+ default:+ assert.Failf(t, "unexpected failure", "unexpected Docker API request: %s %s", r.Method, r.URL.Path)+ http.NotFound(w, r)+ }+ }))+ t.Cleanup(server.Close)+ dockerClient, err := client.New(+ client.WithHost("tcp://"+strings.TrimPrefix(server.URL, "http://")),+ client.WithAPIVersion("1.41"),+ )+ require.NoError(t, err)+ t.Cleanup(func() { _ = dockerClient.Close() })+ return dockerClient+ }++ t.Run("tags and verifies the selected reference", func(t *testing.T) {+ require.NoError(t, tagPulledImage(t.Context(), newClient(t, "sha256:pulled", http.StatusCreated), pulled, selected))+ })++ t.Run("fails when tagging fails", func(t *testing.T) {+ require.Error(t, tagPulledImage(t.Context(), newClient(t, "sha256:pulled", http.StatusInternalServerError), pulled, selected))+ })++ t.Run("fails when the tag resolves elsewhere", func(t *testing.T) {+ err := tagPulledImage(t.Context(), newClient(t, "sha256:other", http.StatusCreated), pulled, selected)+ require.ErrorContains(t, err, "resolves to sha256:other")+ })+}diff --git a/backend/go.mod b/backend/go.modindex 4d4b9c6c2..496b4a52b 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -71,7 +71,7 @@ require (go.getarcane.app/streams v0.4.5go.getarcane.app/sys/cgroup v0.2.4go.getarcane.app/sys/crypto v0.3.0- go.getarcane.app/updater v0.11.3+ go.getarcane.app/updater v0.11.4go.uber.org/fx v1.24.0go.yaml.in/yaml/v4 v4.0.0-rc.6golang.org/x/crypto v0.57.0diff --git a/backend/go.sum b/backend/go.sumindex e9b3b9d56..b6a03c4cc 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -761,8 +761,8 @@ go.getarcane.app/sys/cgroup v0.2.4 h1:8gwVZENjddDZmWU2LxTFEZnxHYC9pY0YZhk8f3Woupgo.getarcane.app/sys/cgroup v0.2.4/go.mod h1:hJyCjpx04VcaaSvkRsMvZl5OLUlAQ60K5gEy1ctuU4U=go.getarcane.app/sys/crypto v0.3.0 h1:vuPTlS7yIkXsfEfJcQ6jzoWoMEQ97DP/fmCZ3Pom73U=go.getarcane.app/sys/crypto v0.3.0/go.mod h1:Rxnq1pb5HVSoJ4VKmL6LZGCrztMONaypXKc8Zg0BMhE=-go.getarcane.app/updater v0.11.3 h1:diLzw5yEQdOvTbRUFvFzZMW0zsjcNffOBmX/4TMHtsg=-go.getarcane.app/updater v0.11.3/go.mod h1:JqnOb7WwtgUTyTJLq4zEUdaKpTSqb1CRvZ45XfgYq2M=+go.getarcane.app/updater v0.11.4 h1:ek9F2uw6g0SurEK5kOVvO5v72mMJeVmly5xRnJx/JTY=+go.getarcane.app/updater v0.11.4/go.mod h1:E5yUibklGWuqXeF0ZzS7QWWnRBnPMU48TgXEuWaSbiw=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/imageupdate/service.go b/backend/internal/imageupdate/service.goindex db7fe6853..044bf709c 100644--- a/backend/internal/imageupdate/service.go+++ b/backend/internal/imageupdate/service.go@@ -67,12 +67,13 @@ type ImageParts struct {}type localImageSnapshot struct {- ImageID string- Repository string- Tag string- PrimaryDigest string- AllDigests []string- IsLocalBuild bool+ ImageID string+ Repository string+ Tag string+ PrimaryDigest string+ AllDigests []string+ RepositoryDigests []string+ IsLocalBuild bool}func NewImageUpdateService(@@ -866,9 +867,10 @@ func (s *ImageUpdateService) inspectLocalImageSnapshotInternal(ctx context.Contereturn nil, fmt.Errorf("failed to inspect image: %w", err)}- var allDigests []string+ var allDigests, repositoryDigests []stringvar primaryDigest stringisLocalBuild := false+ requested, referenceErr := refs.NormalizeReference(imageRef)// Extract all digests from RepoDigestsif len(inspectResponse.RepoDigests) > 0 {@@ -879,12 +881,20 @@ func (s *ImageUpdateService) inspectLocalImageSnapshotInternal(ctx context.Conte}allDigests = append(allDigests, digestValue)+ repositoryRef, parseErr := refs.NormalizeReference(repoDigest)+ if referenceErr == nil && parseErr == nil && repositoryRef.RegistryHost == requested.RegistryHost && repositoryRef.Repository == requested.Repository {+ repositoryDigests = append(repositoryDigests, digestValue)+ }// Use first digest as primary if not yet setprimaryDigest = cmp.Or(primaryDigest, digestValue)}}+ if len(repositoryDigests) > 0 {+ primaryDigest = repositoryDigests[0]+ }+// Fallback to image ID if no repo digests availableif primaryDigest == "" {isLocalBuild = true@@ -897,12 +907,13 @@ func (s *ImageUpdateService) inspectLocalImageSnapshotInternal(ctx context.Contetag = tagWithFallbackInternal(tag, s.parseImageReference(imageRef))return &localImageSnapshot{- ImageID: inspectResponse.ID,- Repository: repo,- Tag: tag,- PrimaryDigest: primaryDigest,- AllDigests: allDigests,- IsLocalBuild: isLocalBuild,+ ImageID: inspectResponse.ID,+ Repository: repo,+ Tag: tag,+ PrimaryDigest: primaryDigest,+ AllDigests: allDigests,+ RepositoryDigests: repositoryDigests,+ IsLocalBuild: isLocalBuild,}, nil}@@ -1197,6 +1208,10 @@ func (s *ImageUpdateService) MarkImageRefUpToDateAfterPull(ctx context.Context,}_, tag, repositoryCandidates, hasLookup := imageref.ParseUpdateLookup(imageRef)+ projectChecks, confirmedDigest, err := s.projectChecksAfterPull(ctx, imageRef, tag, repositoryCandidatesSliceInternal(repositoryCandidates), snapshot.RepositoryDigests)+ if err != nil {+ return err+ }return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {if hasLookup {repositories := repositoryCandidatesSliceInternal(repositoryCandidates)@@ -1211,6 +1226,31 @@ func (s *ImageUpdateService) MarkImageRefUpToDateAfterPull(ctx context.Context,}}}+ for _, record := range projectChecks {+ // Record the local digest the preview targeted when the pull carries it.+ pulledDigest := cmp.Or(confirmedDigest, snapshot.RepositoryDigests[0])+ if previewDigest := mo.PointerToOption(record.LatestDigest).OrEmpty(); confirmedDigest == "" && slices.Contains(snapshot.RepositoryDigests, previewDigest) {+ pulledDigest = previewDigest+ }+ // Preserve any preview replaced while the registry lookup was in flight.+ if refreshProjectChecksErr := tx.Model(&ImageUpdateRecord{}).+ Where(map[string]any{+ "id": record.ID, "check_time": record.CheckTime, "policy_key": record.PolicyKey,+ "latest_digest": record.LatestDigest, "latest_version": record.LatestVersion,+ "current_digest": record.CurrentDigest, "last_error": record.LastError, "has_update": record.HasUpdate,+ }).+ Updates(map[string]any{+ "has_update": false,+ "update_type": UpdateTypeDigest,+ "current_version": tag,+ "latest_version": tag,+ "current_digest": pulledDigest,+ "latest_digest": pulledDigest,+ "check_time": checkTime,+ }).Error; refreshProjectChecksErr != nil {+ return fmt.Errorf("refresh project update checks: %w", refreshProjectChecksErr)+ }+ }if savePreparedUpdateResultWithTxErr := savePreparedUpdateResultWithTxInternal(tx, snapshot.ImageID, snapshot.Repository, snapshot.Tag, result); savePreparedUpdateResultWithTxErr != nil {return fmt.Errorf("save pulled image update state: %w", savePreparedUpdateResultWithTxErr)@@ -1220,6 +1260,44 @@ func (s *ImageUpdateService) MarkImageRefUpToDateAfterPull(ctx context.Context,})}+// projectChecksAfterPull returns the digest previews a pull of imageRef+// satisfies. Previews that were disabled, local, or not pulled carry no digest+// result and are left for the next project check.+func (s *ImageUpdateService) projectChecksAfterPull(ctx context.Context, imageRef, tag string, repositories, localDigests []string) ([]ImageUpdateRecord, string, error) {+ if len(repositories) == 0 || len(localDigests) == 0 {+ return nil, "", nil+ }+ var records []ImageUpdateRecord+ if err := s.db.WithContext(ctx).+ Where("project_id <> '' AND update_type = ? AND tag = ? AND repository IN ?", UpdateTypeDigest, tag, repositories).+ Where("latest_version IS NULL OR latest_version = '' OR latest_version = tag").+ Where("last_error IS NULL OR last_error = ''").Find(&records).Error; err != nil {+ return nil, "", fmt.Errorf("load project update checks after pull: %w", err)+ }+ digestMismatch := func(record ImageUpdateRecord) bool {+ latestDigest := mo.PointerToOption(record.LatestDigest).OrEmpty()+ return latestDigest != "" && !slices.Contains(localDigests, latestDigest)+ }+ if !slices.ContainsFunc(records, digestMismatch) {+ return records, "", nil+ }++ // Digests have no ordering. Confirm a moved tag without using the digest cache.+ // A registry failure leaves the differing previews untouched rather than+ // blocking the reconciliation of the pulled image state.+ if s.registryService != nil {+ registryCtx, cancel := s.registryContextInternal(ctx)+ defer cancel()+ latest, err := s.registryService.InspectImageDigest(registryCtx, imageRef, nil)+ if err != nil {+ slog.WarnContext(ctx, "Failed to verify pulled image against project previews", "imageRef", imageRef, "error", err.Error())+ } else if latest != nil && slices.Contains(localDigests, latest.Digest) {+ return records, latest.Digest, nil+ }+ }+ return slices.DeleteFunc(records, digestMismatch), "", nil+}+func (s *ImageUpdateService) StoredUpdateByImageID(ctx context.Context, imageID string) (*ImageUpdateRecord, bool, error) {imageID = strings.TrimSpace(imageID)if s == nil || s.db == nil || imageID == "" {diff --git a/backend/internal/imageupdate/service_test.go b/backend/internal/imageupdate/service_test.goindex 152b67c74..4cafb6bef 100644--- a/backend/internal/imageupdate/service_test.go+++ b/backend/internal/imageupdate/service_test.go@@ -1324,10 +1324,84 @@ func TestImageUpdateService_MarkImageRefUpToDateAfterPull_ClearsMatchingRecordsACheckTime: now,}).Error)+ // Project preview rows for the same source reference: a digest preview is+ // satisfied by the pull, a pending tag move is not.+ oldDigest := "sha256:old-project"+ require.NoError(t, db.Create(&ImageUpdateRecord{+ ID: "project::proj::web",+ ProjectID: "proj",+ ServiceName: "web",+ Repository: repository,+ Tag: "1.2.3",+ HasUpdate: true,+ UpdateType: UpdateTypeDigest,+ CurrentVersion: "1.2.3",+ LatestVersion: new("1.2.3"),+ CurrentDigest: &oldDigest,+ LatestDigest: &localDigest,+ CheckTime: now,+ }).Error)+ require.NoError(t, db.Create(&ImageUpdateRecord{+ ID: "project::proj::api",+ ProjectID: "proj",+ ServiceName: "api",+ Repository: repository,+ Tag: "1.2.3",+ HasUpdate: true,+ UpdateType: "tag",+ CurrentVersion: "1.2.3",+ LatestVersion: new("1.3.0"),+ CheckTime: now,+ }).Error)+ newerDigest := digest.FromString("mark-up-to-date-newer").String()+ require.NoError(t, db.Create(&ImageUpdateRecord{+ ID: "project::proj::worker",+ ProjectID: "proj",+ ServiceName: "worker",+ Repository: repository,+ Tag: "1.2.3",+ HasUpdate: true,+ UpdateType: UpdateTypeDigest,+ CurrentVersion: "1.2.3",+ CurrentDigest: &oldDigest,+ LatestDigest: &newerDigest,+ CheckTime: now,+ }).Error)+ require.NoError(t, db.Create(&ImageUpdateRecord{+ ID: "project::proj::broken",+ ProjectID: "proj",+ ServiceName: "broken",+ Repository: repository,+ Tag: "1.2.3",+ LastError: new("registry unreachable"),+ CheckTime: now,+ }).Error)+svc := NewImageUpdateService(db, nil, nil, &docker.DockerClientService{Client: newImageUpdateTestDockerClientInternal(t, server)}, nil, nil, nil)require.NoError(t, svc.MarkImageRefUpToDateAfterPull(t.Context(), imageRef))+ var projectDigestRecord ImageUpdateRecord+ require.NoError(t, db.WithContext(t.Context()).Where("id = ?", "project::proj::web").First(&projectDigestRecord).Error)+ assert.False(t, projectDigestRecord.HasUpdate, "project digest preview must be refreshed after pull")+ assert.Equal(t, localDigest, mo.PointerToOption(projectDigestRecord.CurrentDigest).OrEmpty())+ assert.Equal(t, localDigest, mo.PointerToOption(projectDigestRecord.LatestDigest).OrEmpty())+ assert.True(t, projectDigestRecord.CheckTime.After(now))++ var projectTagRecord ImageUpdateRecord+ require.NoError(t, db.WithContext(t.Context()).Where("id = ?", "project::proj::api").First(&projectTagRecord).Error)+ assert.True(t, projectTagRecord.HasUpdate, "project tag preview is not satisfied by pulling the same tag")+ assert.Equal(t, "1.3.0", mo.PointerToOption(projectTagRecord.LatestVersion).OrEmpty())++ var projectNewerRecord ImageUpdateRecord+ require.NoError(t, db.WithContext(t.Context()).Where("id = ?", "project::proj::worker").First(&projectNewerRecord).Error)+ assert.True(t, projectNewerRecord.HasUpdate, "a preview targeting a digest other than the pulled one is kept")+ assert.Equal(t, newerDigest, mo.PointerToOption(projectNewerRecord.LatestDigest).OrEmpty())++ var projectFailedRecord ImageUpdateRecord+ require.NoError(t, db.WithContext(t.Context()).Where("id = ?", "project::proj::broken").First(&projectFailedRecord).Error)+ assert.Equal(t, "registry unreachable", mo.PointerToOption(projectFailedRecord.LastError).OrEmpty(), "a failed preview check is not cleared by a pull")+// Sha256 records for old images that other containers are still running must stay HasUpdate=true.var fullRecord ImageUpdateRecordrequire.NoError(t, db.WithContext(t.Context()).Where("id = ?", "sha256:old-full").First(&fullRecord).Error)diff --git a/backend/internal/project/service.go b/backend/internal/project/service.goindex fdfafb22f..9bd820684 100644--- a/backend/internal/project/service.go+++ b/backend/internal/project/service.go@@ -2090,6 +2090,19 @@ func BuildConfiguredUpdateInfo(}if len(runtimeUpdates) > 0 && runtimeUpdates[0][service.Name] != nil {+ // A runtime check at least as recent as the stored preview that+ // found nothing supersedes a preview still advertising an update;+ // the preview is only rewritten by a manual project check (#4306).+ // Digest checks share image IDs across references. Require a matching+ // check for the configured reference before clearing its preview.+ runtime := runtimeUpdates[0][service.Name]+ attributed := policyErr == nil && policy.Strategy != "digest"+ if stored := byRef[imageRef]; policyErr == nil && !attributed && stored != nil && !stored.HasUpdate && stored.Error == "" && stored.CheckTime.Equal(runtime.CheckTime) {+ attributed = stored.CurrentDigest == runtime.CurrentDigest && stored.LatestDigest == runtime.LatestDigest+ }+ if attributed && info != nil && info.HasUpdate && !runtime.HasUpdate && runtime.Error == "" && !runtime.CheckTime.Before(info.CheckTime) {+ info = nil+ }info = projectdetails.MergeProjectContainerUpdateInfo(nil,[]projecttypes.RuntimeService{diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.goindex 79ddc02f3..78a1e003b 100644--- a/backend/internal/project/service_test.go+++ b/backend/internal/project/service_test.go@@ -7863,6 +7863,24 @@ func TestConfiguredProjectAggregatesReplicaAndPreviewChecks(t *testing.T) {require.True(t, summary.HasUpdate)require.True(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)require.Equal(t, "3.2.0", scoped["two"].LatestVersion)++ // A stale preview still advertising an update is superseded by a runtime+ // check at least as recent that found nothing; a newer preview still wins.+ previewTime := time.Now().Add(-time.Hour)+ records[0].HasUpdate = true+ records[0].LatestVersion = &previewTarget+ records[0].CheckTime = previewTime+ current := map[string]*imagetypes.UpdateInfo{"web": {HasUpdate: false, UpdateType: "digest", CheckTime: previewTime.Add(time.Minute)}}+ byRef := map[string]*imagetypes.UpdateInfo{"example:3.1.0": current["web"]}+ summary = BuildConfiguredUpdateInfo("project", configs, byRef, records, current)+ require.False(t, summary.HasUpdate)+ require.False(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)+ require.Equal(t, "up_to_date", summary.Status)++ current["web"].CheckTime = previewTime.Add(-time.Minute)+ summary = BuildConfiguredUpdateInfo("project", configs, byRef, records, current)+ require.True(t, summary.HasUpdate)+ require.True(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)}func TestPrepareProjectBindDirectoriesInternal(t *testing.T) {diff --git a/backend/internal/system/children/upgrade/service.go b/backend/internal/system/children/upgrade/service.goindex 8bcca59ea..93c3ea68b 100644--- a/backend/internal/system/children/upgrade/service.go+++ b/backend/internal/system/children/upgrade/service.go@@ -1,6 +1,7 @@package upgradeimport (+ "cmp""context""encoding/json/v2""errors"@@ -161,7 +162,10 @@ type preparedUpgradeInternal struct {current container.InspectResponsecontainerName stringbinaryPath string- targetImage string+ // targetImage is the reference the recreated container runs as; pullImage+ // is the immutable reference actually pulled (the same unless frozen).+ targetImage string+ pullImage string}// prepareUpgradeInternal takes the upgrading guard, released by runPreparedUpgradeInternal (or here on error).@@ -201,6 +205,7 @@ func (s *Service) prepareUpgradeInternal(ctx context.Context, user usertypes.Actif err != nil {return nil, err}+ pullImage := cmp.Or(strings.TrimSpace(target.PullImageRef), targetImage)// Log upgrade eventmetadata := database.JSON{@@ -209,6 +214,7 @@ func (s *Service) prepareUpgradeInternal(ctx context.Context, user usertypes.Act"containerName": containerName,"method": "cli","targetImage": targetImage,+ "pullImage": pullImage,}if logUserEventErr := s.eventService.LogUserEvent(ctx, event.EventTypeSystemUpgrade, user.ID, user.Username, metadata); logUserEventErr != nil {slog.WarnContext(ctx, "Failed to log upgrade event", "error", logUserEventErr)@@ -219,6 +225,7 @@ func (s *Service) prepareUpgradeInternal(ctx context.Context, user usertypes.ActcontainerName: containerName,binaryPath: binaryPath,targetImage: targetImage,+ pullImage: pullImage,}, nil}@@ -227,7 +234,7 @@ func (s *Service) runPreparedUpgradeInternal(ctx context.Context, prepared *prep// Run the upgrader from the image we are upgrading to, so the upgrade CLI// is the new version.- upgraderImage := prepared.targetImage+ upgraderImage := prepared.pullImageslog.DebugContext(ctx, "Using upgrader image", "image", upgraderImage)slog.InfoContext(ctx, "Spawning upgrade CLI command", "containerName", prepared.containerName, "upgraderImage", upgraderImage)@@ -295,6 +302,9 @@ func (s *Service) runPreparedUpgradeInternal(ctx context.Context, prepared *prepif prepared.targetImage != "" {upgradeCmd = append(upgradeCmd, "--image", prepared.targetImage)}+ if prepared.pullImage != prepared.targetImage {+ upgradeCmd = append(upgradeCmd, "--pull-image", prepared.pullImage)+ }config := &container.Config{Image: upgraderImage,diff --git a/backend/internal/updater/service.go b/backend/internal/updater/service.goindex 3f1c4e4d4..c9fb41c06 100644--- a/backend/internal/updater/service.go+++ b/backend/internal/updater/service.go@@ -685,21 +685,28 @@ func (s *UpdaterService) PullImage(ctx context.Context, imageRef string, progrespullCtx, cancelPull := context.WithTimeout(ctx, timeouts.GetDuration(pullTimeoutSeconds, timeouts.DefaultDockerImagePull))defer cancelPull()+ var credentials []containerregistry.Credentialif s.deps.Projects != nil {resolved, resolveRegistryCredentialsErr := s.deps.Projects.ResolveRegistryCredentials(pullCtx)if resolveRegistryCredentialsErr != nil {return fmt.Errorf("resolve registry credentials: %w", resolveRegistryCredentialsErr)}- if pullImageErr := s.deps.ImagePuller.PullImage(pullCtx, pulledRef, writer, s.deps.SystemUser, resolved); pullImageErr != nil {- return pullImageErr- }- return s.tagFrozenPullInternal(pullCtx, pulledRef, imageRef)+ credentials = resolved}-- if pullImageErr2 := s.deps.ImagePuller.PullImage(pullCtx, pulledRef, writer, s.deps.SystemUser, nil); pullImageErr2 != nil {- return pullImageErr2+ if pullImageErr := s.deps.ImagePuller.PullImage(pullCtx, pulledRef, writer, s.deps.SystemUser, credentials); pullImageErr != nil {+ return pullImageErr}- return s.tagFrozenPullInternal(pullCtx, pulledRef, imageRef)+ if tagErr := s.tagFrozenPullInternal(pullCtx, pulledRef, imageRef); tagErr != nil {+ return tagErr+ }+ // Reconcile by tag so the new image's record and any project preview rows+ // for this reference stop reporting the update just installed (#4306).+ // This runs on the run context, not the pull deadline, so a pull that+ // finished late still records its result.+ if reconcileErr := s.deps.ImagePuller.ReconcilePulledImageUpdate(ctx, imageRef); reconcileErr != nil {+ slog.WarnContext(ctx, "failed to reconcile pulled image update state", "image", imageRef, "error", reconcileErr)+ }+ return nil}// PendingImageUpdates returns pending image update records from Arcane's database.@@ -780,12 +787,14 @@ func (s *UpdaterService) UpdateServices(ctx context.Context, projectID string, s// TriggerSelfUpdate runs Arcane's CLI-backed self-update hook.func (s *UpdaterService) TriggerSelfUpdate(ctx context.Context, target updater.SelfUpdateTarget) error {+ // The frozen digest is only what gets pulled; the recreated container keeps+ // the selected tag so later runs do not treat it as an immutable reference.if target.NewImageRef != "" {pinned, err := s.recovery.PreparePull(ctx, target.NewImageRef)if err != nil {return err}- target.NewImageRef = pinned+ target.PullImageRef = pinned}if s == nil || s.deps.SelfUpgrade == nil {instanceType := cmp.Or(strings.TrimSpace(target.InstanceType), "server")@@ -796,7 +805,7 @@ func (s *UpdaterService) TriggerSelfUpdate(ctx context.Context, target updater.S// activity, so annotate the activity first; startup reconciliation uses// the metadata flag to finalize it after the restart.if target.InstanceType != "agent" {- s.markSelfUpdateTriggeredInternal(ctx, target)+ s.markSelfUpdateTriggeredInternal(ctx, target.NewImageRef)}if _, err := s.deps.SelfUpgrade.TriggerUpgradeViaCLI(ctx, s.deps.SystemUser, target); err != nil {@@ -811,13 +820,13 @@ func (s *UpdaterService) TriggerSelfUpdate(ctx context.Context, target updater.Sreturn nil}-func (s *UpdaterService) markSelfUpdateTriggeredInternal(ctx context.Context, target updater.SelfUpdateTarget) {+func (s *UpdaterService) markSelfUpdateTriggeredInternal(ctx context.Context, imageRef string) {activityID := activityIDFromContextInternal(ctx)if s.deps.Activity == nil || activityID == "" {return}message := "Self-update initiated — Arcane will restart"- if ref := strings.TrimSpace(target.NewImageRef); ref != "" {+ if ref := strings.TrimSpace(imageRef); ref != "" {message = "Self-update initiated — Arcane will restart with " + ref}s.appendAutoUpdateActivityMessageInternal(ctx, activityID, message, "Self-update", 90)diff --git a/backend/internal/updater/service_test.go b/backend/internal/updater/service_test.goindex 8602c5c1f..41483489c 100644--- a/backend/internal/updater/service_test.go+++ b/backend/internal/updater/service_test.go@@ -342,6 +342,31 @@ func TestUpdaterService_TriggerSelfUpdateViaCLIInternal(t *testing.T) {require.NotNil(t, mockUpgrade.capturedTarget)assert.Equal(t, "container-1", mockUpgrade.capturedTarget.ContainerID)assert.Equal(t, "arcane", mockUpgrade.capturedTarget.ContainerName)+ assert.Empty(t, mockUpgrade.capturedTarget.NewImageRef)+ assert.Empty(t, mockUpgrade.capturedTarget.PullImageRef)+ })++ t.Run("engine target keeps the selected tag and pulls the frozen digest", func(t *testing.T) {+ mockUpgrade := &mockSystemUpgradeServiceInternal{}+ svc, svcErr := NewUpdaterService(nil, nil, nil, nil, nil, nil, nil, nil, nil, mockUpgrade, nil, nil, nil, nil, nil)+ require.NoError(t, svcErr)++ frozen := svc.recovery.WithSingleTarget(ctx, &arcaneupdater.FrozenUpdateTarget{+ ContainerID: "container-1",+ DesiredImageRef: "ghcr.io/getarcaneapp/arcane:next",+ DesiredDigest: "sha256:frozen",+ }, func() error { return nil })+ err := svc.TriggerSelfUpdate(frozen, updater.SelfUpdateTarget{+ ContainerID: "container-1",+ ContainerName: "arcane",+ InstanceType: "agent",+ NewImageRef: "ghcr.io/getarcaneapp/arcane:next",+ })++ require.NoError(t, err)+ require.NotNil(t, mockUpgrade.capturedTarget)+ assert.Equal(t, "ghcr.io/getarcaneapp/arcane:next", mockUpgrade.capturedTarget.NewImageRef)+ assert.Equal(t, "ghcr.io/getarcaneapp/arcane@sha256:frozen", mockUpgrade.capturedTarget.PullImageRef)})t.Run("agent label triggers upgrade", func(t *testing.T) {diff --git a/frontend/src/routes/(app)/containers/[containerId]/+page.svelte b/frontend/src/routes/(app)/containers/[containerId]/+page.svelteindex 67e2ad541..50161a086 100644--- a/frontend/src/routes/(app)/containers/[containerId]/+page.svelte+++ b/frontend/src/routes/(app)/containers/[containerId]/+page.svelte@@ -213,7 +213,9 @@}await Promise.all([queryClient.invalidateQueries({ queryKey: ['containers', environmentId] }),- queryClient.invalidateQueries({ queryKey: queryKeys.containers.detail(environmentId, containerId) })+ queryClient.invalidateQueries({ queryKey: queryKeys.containers.detail(environmentId, containerId) }),+ queryClient.invalidateQueries({ queryKey: ['projects', environmentId] }),+ queryClient.invalidateQueries({ queryKey: queryKeys.projects.environment(environmentId) })]);if (updateViewMounted && environmentId === currentEnvId && containerId === container.id) await refreshAll();}diff --git a/frontend/src/routes/(app)/containers/components/container-table.svelte b/frontend/src/routes/(app)/containers/components/container-table.svelteindex 88c74d9eb..f8da47eb3 100644--- a/frontend/src/routes/(app)/containers/components/container-table.svelte+++ b/frontend/src/routes/(app)/containers/components/container-table.svelte@@ -114,6 +114,8 @@if (!updateTableMounted || environmentId !== environmentStore.selected?.id) return;void queryClient.invalidateQueries({ queryKey: ['containers', environmentId] });void queryClient.invalidateQueries({ queryKey: ['container', environmentId] });+ void queryClient.invalidateQueries({ queryKey: ['projects', environmentId] });+ void queryClient.invalidateQueries({ queryKey: ['project', environmentId] });void refreshContainers(requestOptions);});diff --git a/frontend/src/routes/(app)/updates/components/container-updates-table.svelte b/frontend/src/routes/(app)/updates/components/container-updates-table.svelteindex 2cb512e2d..2fa9c34f1 100644--- a/frontend/src/routes/(app)/updates/components/container-updates-table.svelte+++ b/frontend/src/routes/(app)/updates/components/container-updates-table.svelte@@ -1,4 +1,5 @@<script lang="ts">+ import { useQueryClient } from '@tanstack/svelte-query';import { onMount } from 'svelte';import { toast } from 'svelte-sonner';@@ -70,11 +71,16 @@let togglingAutoUpdateIds = $state<Record<string, boolean>>({});let bulkUpdating = $state(false);let updateTableMounted = false;+ const queryClient = useQueryClient();const currentEnvironmentId = $derived(environmentStore.selected?.id || '0');const updateActivities = createContainerUpdateActivityTracker(() => currentEnvironmentId,() => {- if (updateTableMounted) void refreshRows();+ if (!updateTableMounted) return;+ void refreshRows();+ // Compose containers also drive the project update badges.+ void queryClient.invalidateQueries({ queryKey: ['projects', currentEnvironmentId] });+ void queryClient.invalidateQueries({ queryKey: ['project', currentEnvironmentId] });});onMount(() => {diff --git a/go.work.sum b/go.work.sumindex ccc2035fb..c41bb2401 100644--- a/go.work.sum+++ b/go.work.sum@@ -2846,6 +2846,8 @@ 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.getarcane.app/updater v0.11.4 h1:ek9F2uw6g0SurEK5kOVvO5v72mMJeVmly5xRnJx/JTY=+go.getarcane.app/updater v0.11.4/go.mod h1:E5yUibklGWuqXeF0ZzS7QWWnRBnPMU48TgXEuWaSbiw=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=