Skip to content

Modern Docker Management, Designed for Everyone

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.go
index 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 nil
diff --git a/backend/cli/upgrade/upgrade.go b/backend/cli/upgrade/upgrade.go
index 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 string
targetImage string
+ pullImageRef string
autoDetect bool
)
@@ -54,6 +56,7 @@ This command should be run from outside the container (e.g., from the host or an
func 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 image
slog.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 upgrade
slog.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, oldConta
config.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, oldConta
return 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 initialize
diff --git a/backend/cli/upgrade/upgrade_test.go b/backend/cli/upgrade/upgrade_test.go
index 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.mod
index 4d4b9c6c2..496b4a52b 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -71,7 +71,7 @@ require (
go.getarcane.app/streams v0.4.5
go.getarcane.app/sys/cgroup v0.2.4
go.getarcane.app/sys/crypto v0.3.0
- go.getarcane.app/updater v0.11.3
+ go.getarcane.app/updater v0.11.4
go.uber.org/fx v1.24.0
go.yaml.in/yaml/v4 v4.0.0-rc.6
golang.org/x/crypto v0.57.0
diff --git a/backend/go.sum b/backend/go.sum
index e9b3b9d56..b6a03c4cc 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -761,8 +761,8 @@ go.getarcane.app/sys/cgroup v0.2.4 h1:8gwVZENjddDZmWU2LxTFEZnxHYC9pY0YZhk8f3Woup
go.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.go
index 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.Conte
return nil, fmt.Errorf("failed to inspect image: %w", err)
}
- var allDigests []string
+ var allDigests, repositoryDigests []string
var primaryDigest string
isLocalBuild := false
+ requested, referenceErr := refs.NormalizeReference(imageRef)
// Extract all digests from RepoDigests
if 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 set
primaryDigest = cmp.Or(primaryDigest, digestValue)
}
}
+ if len(repositoryDigests) > 0 {
+ primaryDigest = repositoryDigests[0]
+ }
+
// Fallback to image ID if no repo digests available
if primaryDigest == "" {
isLocalBuild = true
@@ -897,12 +907,13 @@ func (s *ImageUpdateService) inspectLocalImageSnapshotInternal(ctx context.Conte
tag = 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.go
index 152b67c74..4cafb6bef 100644
--- a/backend/internal/imageupdate/service_test.go
+++ b/backend/internal/imageupdate/service_test.go
@@ -1324,10 +1324,84 @@ func TestImageUpdateService_MarkImageRefUpToDateAfterPull_ClearsMatchingRecordsA
CheckTime: 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 ImageUpdateRecord
require.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.go
index 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.go
index 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.go
index 8bcca59ea..93c3ea68b 100644
--- a/backend/internal/system/children/upgrade/service.go
+++ b/backend/internal/system/children/upgrade/service.go
@@ -1,6 +1,7 @@
package upgrade
import (
+ "cmp"
"context"
"encoding/json/v2"
"errors"
@@ -161,7 +162,10 @@ type preparedUpgradeInternal struct {
current container.InspectResponse
containerName string
binaryPath 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.Act
if err != nil {
return nil, err
}
+ pullImage := cmp.Or(strings.TrimSpace(target.PullImageRef), targetImage)
// Log upgrade event
metadata := 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.Act
containerName: 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.pullImage
slog.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 *prep
if 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.go
index 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, progres
pullCtx, cancelPull := context.WithTimeout(ctx, timeouts.GetDuration(pullTimeoutSeconds, timeouts.DefaultDockerImagePull))
defer cancelPull()
+ var credentials []containerregistry.Credential
if 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.S
return 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.go
index 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.svelte
index 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.svelte
index 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.svelte
index 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.sum
index 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=