Skip to content

Modern Docker Management, Designed for Everyone

fix: compose update indicator not refreshing when a new image is pulled

Kyle Mendelle367e1f3bb48
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index 2ff77fe0b..095bf606c 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -230,6 +230,14 @@ func (s *ImageService) PullImage(ctx context.Context, imageName string, progress
return nil
}
+func (s *ImageService) ReconcilePulledImageUpdate(ctx context.Context, imageName string) error {
+ if s.imageUpdateService == nil {
+ return nil
+ }
+
+ return s.imageUpdateService.MarkImageRefUpToDateAfterPull(ctx, imageName)
+}
+
func (s *ImageService) LoadImageFromReader(ctx context.Context, reader io.Reader, fileName string, user models.User, maxSizeBytes int64) (*imagetypes.LoadResult, error) {
// Wrap reader with size limit enforcement
limitedReader := io.LimitReader(reader, maxSizeBytes+1)
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 1f04365cf..b7564824c 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -581,6 +581,44 @@ func buildImageUpdateRecord(imageID, repo, tag string, result *imageupdate.Respo
}
}
+func repositoryCandidatesSliceInternal(candidates map[string]struct{}) []string {
+ if len(candidates) == 0 {
+ return nil
+ }
+
+ repositories := make([]string, 0, len(candidates))
+ for repository := range candidates {
+ repositories = append(repositories, repository)
+ }
+ return repositories
+}
+
+func savePreparedUpdateResultWithTxInternal(tx *gorm.DB, imageID, repo, tag string, result *imageupdate.Response) error {
+ updateRecord := buildImageUpdateRecord(imageID, repo, tag, result)
+
+ // Check if there's an existing record to compare state changes
+ var existingRecord models.ImageUpdateRecord
+ if err := tx.Where("id = ?", imageID).First(&existingRecord).Error; err == nil {
+ // Existing record found - check if we need to reset notification_sent
+ stateChanged := existingRecord.HasUpdate != updateRecord.HasUpdate
+ digestChanged := stringPtrToString(existingRecord.LatestDigest) != stringPtrToString(updateRecord.LatestDigest)
+ versionChanged := stringPtrToString(existingRecord.LatestVersion) != stringPtrToString(updateRecord.LatestVersion)
+
+ // Reset notification_sent if the update state changed in any way
+ if stateChanged || (updateRecord.HasUpdate && (digestChanged || versionChanged)) {
+ updateRecord.NotificationSent = false
+ } else {
+ // Keep the existing notification_sent value if nothing changed
+ updateRecord.NotificationSent = existingRecord.NotificationSent
+ }
+ } else {
+ // New record - start with notification_sent = false
+ updateRecord.NotificationSent = false
+ }
+
+ return tx.Save(updateRecord).Error
+}
+
func (s *ImageUpdateService) saveUpdateResultByIDInternal(ctx context.Context, imageID string, result *imageupdate.Response) error {
dockerClient, err := s.dockerService.GetClient(ctx)
if err != nil {
@@ -598,29 +636,7 @@ func (s *ImageUpdateService) saveUpdateResultByIDInternal(ctx context.Context, i
func (s *ImageUpdateService) savePreparedUpdateResultInternal(ctx context.Context, imageID, repo, tag string, result *imageupdate.Response) error {
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- updateRecord := buildImageUpdateRecord(imageID, repo, tag, result)
-
- // Check if there's an existing record to compare state changes
- var existingRecord models.ImageUpdateRecord
- if err := tx.Where("id = ?", imageID).First(&existingRecord).Error; err == nil {
- // Existing record found - check if we need to reset notification_sent
- stateChanged := existingRecord.HasUpdate != updateRecord.HasUpdate
- digestChanged := stringPtrToString(existingRecord.LatestDigest) != stringPtrToString(updateRecord.LatestDigest)
- versionChanged := stringPtrToString(existingRecord.LatestVersion) != stringPtrToString(updateRecord.LatestVersion)
-
- // Reset notification_sent if the update state changed in any way
- if stateChanged || (updateRecord.HasUpdate && (digestChanged || versionChanged)) {
- updateRecord.NotificationSent = false
- } else {
- // Keep the existing notification_sent value if nothing changed
- updateRecord.NotificationSent = existingRecord.NotificationSent
- }
- } else {
- // New record - start with notification_sent = false
- updateRecord.NotificationSent = false
- }
-
- return tx.Save(updateRecord).Error
+ return savePreparedUpdateResultWithTxInternal(tx, imageID, repo, tag, result)
})
}
@@ -637,6 +653,49 @@ func (s *ImageUpdateService) getImageIDByRef(ctx context.Context, imageRef strin
return inspectResponse.ID, nil
}
+func (s *ImageUpdateService) MarkImageRefUpToDateAfterPull(ctx context.Context, imageRef string) error {
+ if s.db == nil {
+ return nil
+ }
+
+ snapshot, err := s.inspectLocalImageSnapshotInternal(ctx, imageRef)
+ if err != nil {
+ return fmt.Errorf("inspect pulled image: %w", err)
+ }
+
+ checkTime := time.Now().UTC()
+ result := &imageupdate.Response{
+ HasUpdate: false,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: snapshot.Tag,
+ LatestVersion: snapshot.Tag,
+ CurrentDigest: snapshot.PrimaryDigest,
+ LatestDigest: snapshot.PrimaryDigest,
+ CheckTime: checkTime,
+ ResponseTimeMs: 0,
+ }
+
+ lookup, hasLookup := parseImageRefUpdateLookupInternal(imageRef)
+ return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if hasLookup {
+ repositories := repositoryCandidatesSliceInternal(lookup.repositoryCandidates)
+ if len(repositories) > 0 {
+ if err := tx.Model(&models.ImageUpdateRecord{}).
+ Where("tag = ? AND repository IN ?", lookup.tag, repositories).
+ Update("has_update", false).Error; err != nil {
+ return fmt.Errorf("clear stale image updates: %w", err)
+ }
+ }
+ }
+
+ if err := savePreparedUpdateResultWithTxInternal(tx, snapshot.ImageID, snapshot.Repository, snapshot.Tag, result); err != nil {
+ return fmt.Errorf("save pulled image update state: %w", err)
+ }
+
+ return nil
+ })
+}
+
// GetUnnotifiedUpdates returns a map of image IDs that have updates but haven't been notified yet
func (s *ImageUpdateService) GetUnnotifiedUpdates(ctx context.Context) (map[string]*models.ImageUpdateRecord, error) {
var records []models.ImageUpdateRecord
diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.go
index 2eb196dee..ec8eaedf5 100644
--- a/backend/internal/services/image_update_service_test.go
+++ b/backend/internal/services/image_update_service_test.go
@@ -660,6 +660,63 @@ func TestBuildSyntheticImageUpdateRecordIDInternal_UsesUnambiguousSeparator(t *t
require.Equal(t, "ref::docker.io/library/nginx@sha256:abcdef", id)
}
+func TestImageUpdateService_MarkImageRefUpToDateAfterPull_ClearsMatchingRecordsAndPersistsCurrentImage(t *testing.T) {
+ db := setupImageUpdateTestDB(t)
+ localDigest := digest.FromString("mark-up-to-date-local").String()
+ remoteDigest := digest.FromString("mark-up-to-date-remote").String()
+
+ server := newImageUpdateFallbackServer(t, "team/app:1.2.3", localDigest, remoteDigest)
+ defer server.Close()
+
+ serverURL, err := url.Parse(server.URL)
+ require.NoError(t, err)
+ imageRef := serverURL.Host + "/team/app:1.2.3"
+ repository := serverURL.Host + "/team/app"
+
+ now := time.Now().UTC().Add(-time.Hour)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:old-full",
+ Repository: repository,
+ Tag: "1.2.3",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "1.2.3",
+ CheckTime: now,
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:old-short",
+ Repository: "team/app",
+ Tag: "1.2.3",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "1.2.3",
+ CheckTime: now.Add(time.Minute),
+ }).Error)
+
+ svc := NewImageUpdateService(db, nil, nil, &DockerClientService{client: newTestDockerClient(t, server)}, nil, nil)
+
+ require.NoError(t, svc.MarkImageRefUpToDateAfterPull(context.Background(), imageRef))
+
+ var fullRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(context.Background()).Where("id = ?", "sha256:old-full").First(&fullRecord).Error)
+ assert.False(t, fullRecord.HasUpdate)
+
+ var shortRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(context.Background()).Where("id = ?", "sha256:old-short").First(&shortRecord).Error)
+ assert.False(t, shortRecord.HasUpdate)
+
+ var currentRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(context.Background()).Where("id = ?", "sha256:local-image-id").First(&currentRecord).Error)
+ assert.False(t, currentRecord.HasUpdate)
+ assert.Equal(t, repository, currentRecord.Repository)
+ assert.Equal(t, "1.2.3", currentRecord.Tag)
+ assert.Equal(t, localDigest, stringPtrToString(currentRecord.CurrentDigest))
+ assert.Equal(t, localDigest, stringPtrToString(currentRecord.LatestDigest))
+ assert.Equal(t, "1.2.3", currentRecord.CurrentVersion)
+ require.NotNil(t, currentRecord.LatestVersion)
+ assert.Equal(t, "1.2.3", *currentRecord.LatestVersion)
+}
+
// TestNotificationSentLogic tests the notification_sent flag behavior
func TestImageUpdateService_NotificationSentLogic(t *testing.T) {
db := setupImageUpdateTestDB(t)
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index fa80d8f3a..e1d564eb8 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -187,6 +187,8 @@ const (
imagePullModeAlways
)
+var composePullProjectServicesInternal = projects.ComposePull
+
func resolveServiceImagePullMode(svc composetypes.ServiceConfig) imagePullMode {
rawPolicy := strings.ToLower(strings.TrimSpace(svc.PullPolicy))
switch {
@@ -454,6 +456,84 @@ func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Contex
return composeProject, composeFileFullPath, nil
}
+func buildSelectedProjectImageRefsInternal(compProj *composetypes.Project, servicesToUpdate []string) []string {
+ if compProj == nil {
+ return nil
+ }
+
+ selected := normalizeBuildSelections(servicesToUpdate)
+ refs := make([]string, 0, len(compProj.Services))
+ seen := make(map[string]struct{}, len(compProj.Services))
+
+ for name, svc := range compProj.Services {
+ if !serviceSelected(selected, name) || svc.Build != nil {
+ continue
+ }
+
+ imageRef := strings.TrimSpace(svc.Image)
+ if imageRef == "" {
+ continue
+ }
+ if _, exists := seen[imageRef]; exists {
+ continue
+ }
+
+ seen[imageRef] = struct{}{}
+ refs = append(refs, imageRef)
+ }
+
+ return refs
+}
+
+func (s *ProjectService) reconcilePulledImageRefsInternal(ctx context.Context, imageRefs []string) {
+ if s.imageService == nil {
+ return
+ }
+
+ for _, imageRef := range imageRefs {
+ if err := s.imageService.ReconcilePulledImageUpdate(ctx, imageRef); err != nil {
+ slog.WarnContext(ctx, "failed to reconcile pulled image update state", "image", imageRef, "error", err)
+ }
+ }
+}
+
+func (s *ProjectService) composePullSelectedServicesInternal(ctx context.Context, compProj *composetypes.Project, servicesToUpdate []string) error {
+ if compProj == nil {
+ return nil
+ }
+
+ imageRefsToReconcile := buildSelectedProjectImageRefsInternal(compProj, servicesToUpdate)
+ if err := composePullProjectServicesInternal(ctx, compProj, servicesToUpdate); err != nil {
+ return err
+ }
+
+ s.reconcilePulledImageRefsInternal(ctx, imageRefsToReconcile)
+ return nil
+}
+
+func (s *ProjectService) pullAndReconcileImageInternal(
+ ctx context.Context,
+ imageRef string,
+ progressWriter io.Writer,
+ user models.User,
+ credentials []containerregistry.Credential,
+) error {
+ settings := s.settingsService.GetSettingsConfig()
+
+ pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
+ defer pullCancel()
+
+ if err := s.imageService.PullImage(pullCtx, imageRef, progressWriter, user, credentials); err != nil {
+ if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {
+ return fmt.Errorf("image pull timed out for %s (increase DOCKER_IMAGE_PULL_TIMEOUT or setting)", imageRef)
+ }
+ return fmt.Errorf("failed to pull image %s: %w", imageRef, err)
+ }
+
+ s.reconcilePulledImageRefsInternal(ctx, []string{imageRef})
+ return nil
+}
+
func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {
projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
if err != nil {
@@ -472,7 +552,7 @@ func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID st
}
// 3. Pull images for specific services
- if err := projects.ComposePull(ctx, compProj, servicesToUpdate); err != nil {
+ if err := s.composePullSelectedServicesInternal(ctx, compProj, servicesToUpdate); err != nil {
slog.WarnContext(ctx, "compose pull failed, continuing", "error", err)
}
@@ -1639,21 +1719,8 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID string
images[img] = struct{}{}
}
- settings := s.settingsService.GetSettingsConfig()
-
for img := range images {
- err := func() error {
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
- defer pullCancel()
- if err := s.imageService.PullImage(pullCtx, img, progressWriter, user, credentials); err != nil {
- if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {
- return fmt.Errorf("image pull timed out for %s (increase DOCKER_IMAGE_PULL_TIMEOUT or setting)", img)
- }
- return fmt.Errorf("failed to pull image %s: %w", img, err)
- }
- return nil
- }()
- if err != nil {
+ if err := s.pullAndReconcileImageInternal(ctx, img, progressWriter, user, credentials); err != nil {
return err
}
}
@@ -1696,8 +1763,6 @@ func (s *ProjectService) EnsureProjectImagesPresent(ctx context.Context, project
}
func (s *ProjectService) ensureImagesPresent(ctx context.Context, pullPlan map[string]imagePullMode, progressWriter io.Writer, credentials []containerregistry.Credential, user models.User) error {
- settings := s.settingsService.GetSettingsConfig()
-
for img, mode := range pullPlan {
exists, ierr := s.imageService.ImageExistsLocally(ctx, img)
if ierr != nil && mode != imagePullModeAlways {
@@ -1722,18 +1787,7 @@ func (s *ProjectService) ensureImagesPresent(ctx context.Context, pullPlan map[s
continue
}
- err := func() error {
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
- defer pullCancel()
- if err := s.imageService.PullImage(pullCtx, img, progressWriter, user, credentials); err != nil {
- if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {
- return fmt.Errorf("image pull timed out for %s (increase DOCKER_IMAGE_PULL_TIMEOUT or setting)", img)
- }
- return fmt.Errorf("failed to pull image %s: %w", img, err)
- }
- return nil
- }()
- if err != nil {
+ if err := s.pullAndReconcileImageInternal(ctx, img, progressWriter, user, credentials); err != nil {
return err
}
}
@@ -1741,18 +1795,7 @@ func (s *ProjectService) ensureImagesPresent(ctx context.Context, pullPlan map[s
}
func (s *ProjectService) pullImageForService(ctx context.Context, imageRef string, progressWriter io.Writer, credentials []containerregistry.Credential) error {
- settings := s.settingsService.GetSettingsConfig()
- pullCtx, pullCancel := timeouts.WithTimeout(ctx, settings.DockerImagePullTimeout.AsInt(), timeouts.DefaultDockerImagePull)
- defer pullCancel()
-
- if err := s.imageService.PullImage(pullCtx, imageRef, progressWriter, systemUser, credentials); err != nil {
- if errors.Is(pullCtx.Err(), context.DeadlineExceeded) {
- return fmt.Errorf("image pull timed out for %s (increase DOCKER_IMAGE_PULL_TIMEOUT or setting)", imageRef)
- }
- return err
- }
-
- return nil
+ return s.pullAndReconcileImageInternal(ctx, imageRef, progressWriter, systemUser, credentials)
}
func (s *ProjectService) prepareProjectImagesForDeploy(
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index 787a2a4ed..6bb18242e 100644
--- a/backend/internal/services/project_service_test.go
+++ b/backend/internal/services/project_service_test.go
@@ -2,11 +2,16 @@ package services
import (
"context"
+ "encoding/json"
"errors"
"fmt"
"io"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
"os"
"path/filepath"
+ "strings"
"testing"
"time"
@@ -18,6 +23,8 @@ import (
imagetypes "github.com/getarcaneapp/arcane/types/image"
glsqlite "github.com/glebarez/sqlite"
"github.com/moby/moby/api/types/container"
+ dockertypesimage "github.com/moby/moby/api/types/image"
+ digest "github.com/opencontainers/go-digest"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
@@ -43,10 +50,56 @@ func setupProjectTestDB(t *testing.T) *database.DB {
t.Helper()
db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
- require.NoError(t, db.AutoMigrate(&models.Project{}, &models.SettingVariable{}, &models.ImageUpdateRecord{}))
+ require.NoError(t, db.AutoMigrate(&models.Project{}, &models.SettingVariable{}, &models.ImageUpdateRecord{}, &models.Event{}))
return &database.DB{DB: db}
}
+func newProjectImagePullServer(t *testing.T, inspectByRef map[string]dockertypesimage.InspectResponse) *httptest.Server {
+ t.Helper()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/images/create"):
+ fullRef := strings.TrimSpace(r.URL.Query().Get("fromImage"))
+ tag := strings.TrimSpace(r.URL.Query().Get("tag"))
+ if fullRef != "" && tag != "" {
+ lastSlash := strings.LastIndex(fullRef, "/")
+ lastColon := strings.LastIndex(fullRef, ":")
+ if lastColon <= lastSlash {
+ fullRef += ":" + tag
+ }
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = io.WriteString(w, `{"status":"Pulled"}`+"\n")
+ return
+ case strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
+ path := r.URL.Path
+ imagePathIndex := strings.Index(path, "/images/")
+ require.NotEqual(t, -1, imagePathIndex)
+ encodedRef := strings.TrimSuffix(path[imagePathIndex+len("/images/"):], "/json")
+ imageRef, err := url.PathUnescape(encodedRef)
+ require.NoError(t, err)
+
+ inspect, ok := inspectByRef[imageRef]
+ if !ok {
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(inspect))
+ return
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+
+ t.Cleanup(server.Close)
+
+ return server
+}
+
func TestProjectService_GetProjectFromDatabaseByID(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -478,6 +531,344 @@ func TestBuildProjectImagePullPlan(t *testing.T) {
assert.Equal(t, imagePullModeAlways, plan["redis:latest"])
assert.Equal(t, imagePullModeNever, plan["nginx:latest"])
}
+
+func TestProjectService_PullProjectImages_ClearsUpdateRecordsForPulledNonBuildRefs(t *testing.T) {
+ ctx := context.Background()
+ db := setupProjectTestDB(t)
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ imageRef := "registry.example.com/team/app:1.2.3"
+ repository := "registry.example.com/team/app"
+ imageID := "sha256:team-app"
+ imageDigest := digest.FromString("team-app-digest").String()
+ buildRepository := "arcane.local/demo-builder/service"
+
+ server := newProjectImagePullServer(t, map[string]dockertypesimage.InspectResponse{
+ imageRef: {
+ ID: imageID,
+ RepoTags: []string{imageRef},
+ RepoDigests: []string{repository + "@" + imageDigest},
+ },
+ })
+
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ eventService := NewEventService(db, nil, nil)
+ imageUpdateService := NewImageUpdateService(db, nil, nil, dockerService, nil, nil)
+ imageService := NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService)
+ svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, config.Load())
+
+ projectPath := createComposeProjectDir(t, projectsDir, "compose-pull")
+ composeContent := fmt.Sprintf("services:\n app:\n image: %s\n builder:\n build: .\n", imageRef)
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(composeContent), 0o644))
+
+ projectRecord := &models.Project{
+ BaseModel: models.BaseModel{ID: "project-pull"},
+ Name: "compose-pull",
+ DirName: ptr("compose-pull"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(projectRecord).Error)
+
+ now := time.Now().UTC().Add(-time.Hour)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:old-full",
+ Repository: repository,
+ Tag: "1.2.3",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "1.2.3",
+ CheckTime: now,
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:old-short",
+ Repository: "team/app",
+ Tag: "1.2.3",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "1.2.3",
+ CheckTime: now.Add(time.Minute),
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:build-only",
+ Repository: buildRepository,
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "latest",
+ CheckTime: now.Add(2 * time.Minute),
+ }).Error)
+
+ require.NoError(t, svc.PullProjectImages(ctx, projectRecord.ID, io.Discard, systemUser, nil))
+
+ var fullRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-full").First(&fullRecord).Error)
+ assert.False(t, fullRecord.HasUpdate)
+
+ var shortRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-short").First(&shortRecord).Error)
+ assert.False(t, shortRecord.HasUpdate)
+
+ var buildRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:build-only").First(&buildRecord).Error)
+ assert.True(t, buildRecord.HasUpdate)
+
+ var currentRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
+ assert.False(t, currentRecord.HasUpdate)
+ assert.Equal(t, repository, currentRecord.Repository)
+ assert.Equal(t, "1.2.3", currentRecord.Tag)
+ assert.Equal(t, imageDigest, stringPtrToString(currentRecord.CurrentDigest))
+ assert.Equal(t, imageDigest, stringPtrToString(currentRecord.LatestDigest))
+}
+
+func TestProjectService_EnsureImagesPresent_ClearsUpdateRecordsAfterPull(t *testing.T) {
+ ctx := context.Background()
+ db := setupProjectTestDB(t)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ imageRef := "registry.example.com/team/api:2.0.0"
+ repository := "registry.example.com/team/api"
+ imageID := "sha256:team-api"
+ imageDigest := digest.FromString("team-api-digest").String()
+
+ server := newProjectImagePullServer(t, map[string]dockertypesimage.InspectResponse{
+ imageRef: {
+ ID: imageID,
+ RepoTags: []string{imageRef},
+ RepoDigests: []string{repository + "@" + imageDigest},
+ },
+ })
+
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ eventService := NewEventService(db, nil, nil)
+ imageUpdateService := NewImageUpdateService(db, nil, nil, dockerService, nil, nil)
+ imageService := NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService)
+ svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, config.Load())
+
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:old-api",
+ Repository: repository,
+ Tag: "2.0.0",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "2.0.0",
+ CheckTime: time.Now().UTC().Add(-time.Hour),
+ }).Error)
+
+ require.NoError(t, svc.ensureImagesPresent(ctx, map[string]imagePullMode{
+ imageRef: imagePullModeAlways,
+ }, io.Discard, nil, systemUser))
+
+ var oldRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-api").First(&oldRecord).Error)
+ assert.False(t, oldRecord.HasUpdate)
+
+ var currentRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
+ assert.False(t, currentRecord.HasUpdate)
+ assert.Equal(t, imageDigest, stringPtrToString(currentRecord.LatestDigest))
+}
+
+func TestProjectService_PullImageForService_ClearsUpdateRecordsAfterPull(t *testing.T) {
+ ctx := context.Background()
+ db := setupProjectTestDB(t)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ imageRef := "registry.example.com/team/worker:3.1.4"
+ repository := "registry.example.com/team/worker"
+ imageID := "sha256:team-worker"
+ imageDigest := digest.FromString("team-worker-digest").String()
+
+ server := newProjectImagePullServer(t, map[string]dockertypesimage.InspectResponse{
+ imageRef: {
+ ID: imageID,
+ RepoTags: []string{imageRef},
+ RepoDigests: []string{repository + "@" + imageDigest},
+ },
+ })
+
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ eventService := NewEventService(db, nil, nil)
+ imageUpdateService := NewImageUpdateService(db, nil, nil, dockerService, nil, nil)
+ imageService := NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService)
+ svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, config.Load())
+
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:old-worker",
+ Repository: repository,
+ Tag: "3.1.4",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "3.1.4",
+ CheckTime: time.Now().UTC().Add(-time.Hour),
+ }).Error)
+
+ require.NoError(t, svc.pullImageForService(ctx, imageRef, io.Discard, nil))
+
+ var oldRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-worker").First(&oldRecord).Error)
+ assert.False(t, oldRecord.HasUpdate)
+
+ var currentRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
+ assert.False(t, currentRecord.HasUpdate)
+ assert.Equal(t, imageDigest, stringPtrToString(currentRecord.LatestDigest))
+}
+
+func TestProjectService_ComposePullSelectedServicesInternal_ReconcilesOnlyOnSuccess(t *testing.T) {
+ ctx := context.Background()
+ db := setupProjectTestDB(t)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ imageRef := "registry.example.com/team/app:9.9.9"
+ repository := "registry.example.com/team/app"
+ imageID := "sha256:team-app-compose"
+ imageDigest := digest.FromString("team-app-compose-digest").String()
+
+ server := newProjectImagePullServer(t, map[string]dockertypesimage.InspectResponse{
+ imageRef: {
+ ID: imageID,
+ RepoTags: []string{imageRef},
+ RepoDigests: []string{repository + "@" + imageDigest},
+ },
+ })
+
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ eventService := NewEventService(db, nil, nil)
+ imageUpdateService := NewImageUpdateService(db, nil, nil, dockerService, nil, nil)
+ imageService := NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService)
+ svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, config.Load())
+
+ projectDef := &composetypes.Project{
+ Name: "compose-selected",
+ Services: composetypes.Services{
+ "app": {
+ Name: "app",
+ Image: imageRef,
+ },
+ "sidecar": {
+ Name: "sidecar",
+ Image: "registry.example.com/team/sidecar:1.0.0",
+ },
+ "builder": {
+ Name: "builder",
+ Build: &composetypes.BuildConfig{Context: "."},
+ },
+ },
+ }
+
+ now := time.Now().UTC().Add(-time.Hour)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:selected-old",
+ Repository: repository,
+ Tag: "9.9.9",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "9.9.9",
+ CheckTime: now,
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:sidecar-old",
+ Repository: "registry.example.com/team/sidecar",
+ Tag: "1.0.0",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "1.0.0",
+ CheckTime: now,
+ }).Error)
+
+ originalComposePull := composePullProjectServicesInternal
+ t.Cleanup(func() { composePullProjectServicesInternal = originalComposePull })
+
+ composePullProjectServicesInternal = func(_ context.Context, _ *composetypes.Project, services []string) error {
+ assert.Equal(t, []string{"app"}, services)
+ return nil
+ }
+
+ require.NoError(t, svc.composePullSelectedServicesInternal(ctx, projectDef, []string{"app"}))
+
+ var selectedRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:selected-old").First(&selectedRecord).Error)
+ assert.False(t, selectedRecord.HasUpdate)
+
+ var sidecarRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:sidecar-old").First(&sidecarRecord).Error)
+ assert.True(t, sidecarRecord.HasUpdate)
+
+ var currentRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
+ assert.False(t, currentRecord.HasUpdate)
+ assert.Equal(t, imageDigest, stringPtrToString(currentRecord.LatestDigest))
+}
+
+func TestProjectService_ComposePullSelectedServicesInternal_LeavesRecordsWhenPullFails(t *testing.T) {
+ ctx := context.Background()
+ db := setupProjectTestDB(t)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ imageRef := "registry.example.com/team/app:9.9.9"
+ repository := "registry.example.com/team/app"
+
+ dockerService := &DockerClientService{}
+ imageUpdateService := NewImageUpdateService(db, nil, nil, dockerService, nil, nil)
+ imageService := NewImageService(db, dockerService, nil, imageUpdateService, nil, NewEventService(db, nil, nil))
+ svc := NewProjectService(db, settingsService, nil, imageService, dockerService, nil, config.Load())
+
+ projectDef := &composetypes.Project{
+ Name: "compose-selected",
+ Services: composetypes.Services{
+ "app": {
+ Name: "app",
+ Image: imageRef,
+ },
+ },
+ }
+
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:selected-old",
+ Repository: repository,
+ Tag: "9.9.9",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "9.9.9",
+ CheckTime: time.Now().UTC().Add(-time.Hour),
+ }).Error)
+
+ originalComposePull := composePullProjectServicesInternal
+ t.Cleanup(func() { composePullProjectServicesInternal = originalComposePull })
+
+ composePullProjectServicesInternal = func(context.Context, *composetypes.Project, []string) error {
+ return errors.New("compose pull failed")
+ }
+
+ err = svc.composePullSelectedServicesInternal(ctx, projectDef, []string{"app"})
+ require.Error(t, err)
+ assert.ErrorContains(t, err, "compose pull failed")
+
+ var selectedRecord models.ImageUpdateRecord
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:selected-old").First(&selectedRecord).Error)
+ assert.True(t, selectedRecord.HasUpdate)
+
+ var count int64
+ require.NoError(t, db.WithContext(ctx).Model(&models.ImageUpdateRecord{}).Where("id = ?", "sha256:team-app-compose").Count(&count).Error)
+ assert.Zero(t, count)
+}
+
func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
diff --git a/frontend/src/lib/components/action-buttons.svelte b/frontend/src/lib/components/action-buttons.svelte
index d66ba2108..a86382fd9 100644
--- a/frontend/src/lib/components/action-buttons.svelte
+++ b/frontend/src/lib/components/action-buttons.svelte
@@ -758,6 +758,7 @@
pullStatusText = m.images_pulled_success();
toast.success(m.images_pulled_success());
await invalidateAll();
+ onActionComplete(itemState);
setTimeout(() => {
pullPopoverOpen = false;