Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
feat(autoupdate/compose): implement docker compose aware update logic (#1875)
Alessandrocea81408118b
diff --git a/backend/internal/huma/handlers/updater.go b/backend/internal/huma/handlers/updater.goindex 072ae073d..2452470aa 100644--- a/backend/internal/huma/handlers/updater.go+++ b/backend/internal/huma/handlers/updater.go@@ -104,7 +104,7 @@ func RegisterUpdater(api huma.API, updaterService *services.UpdaterService) {Method: http.MethodPost,Path: "/environments/{id}/containers/{containerId}/update",Summary: "Update a single container",- Description: "Pull the latest image and recreate a specific container",+ Description: "Pull the latest image and apply the appropriate update strategy for a specific container",Tags: []string{"Updater", "Containers"},Security: []map[string][]string{{"BearerAuth": {}},@@ -177,7 +177,7 @@ func (h *UpdaterHandler) GetUpdaterHistory(ctx context.Context, input *GetUpdate}, nil}-// UpdateContainer updates a single container by pulling the latest image and recreating it.+// UpdateContainer updates a single container by pulling the latest image and applying the appropriate update flow.func (h *UpdaterHandler) UpdateContainer(ctx context.Context, input *UpdateContainerInput) (*UpdateContainerOutput, error) {if h.updaterService == nil {return nil, huma.Error500InternalServerError("service not available")diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.goindex 3df6b9c53..6d522e02d 100644--- a/backend/internal/services/project_service.go+++ b/backend/internal/services/project_service.go@@ -11,6 +11,7 @@ import ("os""path/filepath""strings"+ "sync""time""github.com/compose-spec/compose-go/v2/dotenv"@@ -42,6 +43,9 @@ type ProjectService struct {imageService *ImageServicedockerService *DockerClientServicebuildService *BuildService++ composeNameCacheMu sync.RWMutex+ composeNameToProjID map[string]string}func NewProjectService(db *database.DB, settingsService *SettingsService, eventService *EventService, imageService *ImageService, dockerService *DockerClientService, buildService *BuildService) *ProjectService {@@ -205,6 +209,96 @@ func normalizeComposeProjectName(name string) string {return normalized}+func (s *ProjectService) getCachedComposeProjectIDInternal(normalizedName string) (string, bool) {+ if normalizedName == "" {+ return "", false+ }++ s.composeNameCacheMu.RLock()+ defer s.composeNameCacheMu.RUnlock()++ if s.composeNameToProjID == nil {+ return "", false+ }++ projectID, ok := s.composeNameToProjID[normalizedName]+ return projectID, ok+}++func (s *ProjectService) cacheComposeProjectIDInternal(normalizedName, projectID string) {+ if normalizedName == "" || projectID == "" {+ return+ }++ s.composeNameCacheMu.Lock()+ defer s.composeNameCacheMu.Unlock()++ if s.composeNameToProjID == nil {+ s.composeNameToProjID = make(map[string]string)+ }+ s.composeNameToProjID[normalizedName] = projectID+}++func (s *ProjectService) invalidateCachedComposeProjectIDInternal(normalizedName string) {+ if normalizedName == "" {+ return+ }++ s.composeNameCacheMu.Lock()+ defer s.composeNameCacheMu.Unlock()++ delete(s.composeNameToProjID, normalizedName)+}++func (s *ProjectService) lookupProjectByCachedComposeNameInternal(ctx context.Context, normalizedName string) (*models.Project, bool, error) {+ projectID, ok := s.getCachedComposeProjectIDInternal(normalizedName)+ if !ok {+ return nil, false, nil+ }++ var project models.Project+ if err := s.db.WithContext(ctx).Where("id = ?", projectID).First(&project).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ s.invalidateCachedComposeProjectIDInternal(normalizedName)+ return nil, false, nil+ }+ if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {+ return nil, false, fmt.Errorf("request canceled or timed out: %w", err)+ }+ return nil, false, fmt.Errorf("failed to get project by cached compose name: %w", err)+ }+ if normalizeComposeProjectName(project.Name) != normalizedName {+ s.invalidateCachedComposeProjectIDInternal(normalizedName)+ return nil, false, nil+ }++ return &project, true, nil+}++func (s *ProjectService) rebuildComposeNameCacheInternal(ctx context.Context) error {+ var projects []models.Project+ if err := s.db.WithContext(ctx).Select("id", "name").Find(&projects).Error; err != nil {+ return err+ }++ cache := make(map[string]string, len(projects))+ for i := range projects {+ normalizedName := normalizeComposeProjectName(projects[i].Name)+ if normalizedName == "" {+ continue+ }+ if _, exists := cache[normalizedName]; !exists {+ cache[normalizedName] = projects[i].ID+ }+ }++ s.composeNameCacheMu.Lock()+ s.composeNameToProjID = cache+ s.composeNameCacheMu.Unlock()++ return nil+}+func (s *ProjectService) GetProjectFromDatabaseByID(ctx context.Context, id string) (*models.Project, error) {var project models.Projectif err := s.db.WithContext(ctx).Where("id = ?", id).First(&project).Error; err != nil {@@ -219,6 +313,102 @@ func (s *ProjectService) GetProjectFromDatabaseByID(ctx context.Context, id strireturn &project, nil}+func (s *ProjectService) GetProjectByComposeName(ctx context.Context, name string) (*models.Project, error) {+ if name == "" {+ return nil, fmt.Errorf("project name is empty")+ }+ normalized := normalizeComposeProjectName(name)++ var proj models.Project+ err := s.db.WithContext(ctx).Where("name = ? OR name = ?", name, normalized).First(&proj).Error+ if err == nil {+ s.cacheComposeProjectIDInternal(normalized, proj.ID)+ return &proj, nil+ }+ if !errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, fmt.Errorf("failed to get project by name: %w", err)+ }++ if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeNameInternal(ctx, normalized); cacheErr != nil {+ return nil, cacheErr+ } else if found {+ return cachedProject, nil+ }++ if err := s.rebuildComposeNameCacheInternal(ctx); err != nil {+ return nil, fmt.Errorf("failed to list projects by compose name: %w", err)+ }++ if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeNameInternal(ctx, normalized); cacheErr != nil {+ return nil, cacheErr+ } else if found {+ return cachedProject, nil+ }++ return nil, fmt.Errorf("project not found: %s", name)+}++func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {+ projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)+ if err != nil {+ return err+ }++ // 1. Load project+ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")+ projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))+ if err != nil {+ projectsDirectory = "/app/data/projects"+ }++ pathMapper, _ := s.getPathMapper(ctx)+ autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)+ compProj, _, err := projects.LoadComposeProjectFromDir(ctx, projectFromDb.Path, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)+ if err != nil {+ return fmt.Errorf("failed to load compose project: %w", err)+ }++ // 2. Set status to deploying/restarting+ if err := s.updateProjectStatusInternal(ctx, projectID, models.ProjectStatusDeploying); err != nil {+ return err+ }++ // 3. Pull images for specific services+ if err := projects.ComposePull(ctx, compProj, servicesToUpdate); err != nil {+ slog.WarnContext(ctx, "compose pull failed, continuing", "error", err)+ }++ // 4. Stop specific services+ if err := projects.ComposeStop(ctx, compProj, servicesToUpdate); err != nil {+ slog.WarnContext(ctx, "compose stop failed, continuing", "error", err)+ }++ // 5. Up specific services+ if err := projects.ComposeUp(ctx, compProj, servicesToUpdate, false, false); err != nil {+ if statusErr := s.updateProjectStatusandCountsInternal(ctx, projectID, models.ProjectStatusStopped); statusErr != nil {+ slog.ErrorContext(ctx, "UpdateProjectServices: failed to set stopped status after compose up failure", "projectID", projectID, "error", statusErr)+ }+ return fmt.Errorf("failed to up services: %w", err)+ }++ // 6. Finalize status+ if err := s.updateProjectStatusandCountsInternal(ctx, projectID, models.ProjectStatusRunning); err != nil {+ return err+ }++ metadata := models.JSON{+ "action": "update_services",+ "projectID": projectID,+ "projectName": projectFromDb.Name,+ "services": append([]string(nil), servicesToUpdate...),+ }+ if logErr := s.eventService.LogProjectEvent(ctx, models.EventTypeProjectUpdate, projectID, projectFromDb.Name, user.ID, user.Username, "0", metadata); logErr != nil {+ slog.ErrorContext(ctx, "could not log project service update action", "error", logErr)+ }++ return nil+}+func (s *ProjectService) getServiceCounts(services []ProjectServiceInfo) (total int, running int) {total = len(services)for _, service := range services {@@ -1491,6 +1681,14 @@ func resolveDockerfilePathInternal(svc composetypes.ServiceConfig) (string, erroreturn dockerfilePath, nil}+func translateBuildPathInternal(path string, pathMapper *projects.PathMapper) (string, error) {+ if pathMapper == nil || strings.TrimSpace(path) == "" || !filepath.IsAbs(path) {+ return path, nil+ }++ return pathMapper.ContainerToHost(path)+}+func buildArgsFromCompose(args map[string]*string) map[string]string {buildArgs := map[string]string{}for key, value := range args {@@ -1623,6 +1821,10 @@ func (s *ProjectService) prepareServiceBuildRequest(if err != nil {return imagetypes.BuildRequest{}, updatedSvc, updated, err}+ contextDir, err = translateBuildPathInternal(contextDir, pathMapper)+ if err != nil {+ return imagetypes.BuildRequest{}, updatedSvc, updated, fmt.Errorf("translate build context for service %s: %w", serviceName, err)+ }dockerfileInline := updatedSvc.Build.DockerfileInlineif strings.TrimSpace(updatedSvc.Build.Dockerfile) != "" && strings.TrimSpace(dockerfileInline) != "" {@@ -1635,6 +1837,10 @@ func (s *ProjectService) prepareServiceBuildRequest(if err != nil {return imagetypes.BuildRequest{}, updatedSvc, updated, err}+ dockerfilePath, err = translateBuildPathInternal(dockerfilePath, pathMapper)+ if err != nil {+ return imagetypes.BuildRequest{}, updatedSvc, updated, fmt.Errorf("translate Dockerfile path for service %s: %w", serviceName, err)+ }}buildReq := imagetypes.BuildRequest{diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.goindex fa86cd36e..77062ec10 100644--- a/backend/internal/services/project_service_test.go+++ b/backend/internal/services/project_service_test.go@@ -274,6 +274,127 @@ func TestProjectService_NormalizeComposeProjectName(t *testing.T) {}}+func TestProjectService_GetProjectByComposeName(t *testing.T) {+ ctx := context.Background()++ t.Run("exact match", func(t *testing.T) {+ db := setupProjectTestDB(t)+ svc := NewProjectService(db, nil, nil, nil, nil, nil)++ proj := &models.Project{+ BaseModel: models.BaseModel{ID: "p1"},+ Name: "myproject",+ Path: "/tmp/myproject",+ }+ require.NoError(t, db.Create(proj).Error)++ found, err := svc.GetProjectByComposeName(ctx, "myproject")+ require.NoError(t, err)+ assert.Equal(t, proj.ID, found.ID)+ })++ t.Run("normalized fallback", func(t *testing.T) {+ db := setupProjectTestDB(t)+ svc := NewProjectService(db, nil, nil, nil, nil, nil)++ proj := &models.Project{+ BaseModel: models.BaseModel{ID: "p1"},+ Name: "myproject",+ Path: "/tmp/myproject",+ }+ require.NoError(t, db.Create(proj).Error)++ found, err := svc.GetProjectByComposeName(ctx, "My Project!")+ require.NoError(t, err)+ assert.Equal(t, proj.ID, found.ID)+ })++ t.Run("display name in db, normalized compose label input", func(t *testing.T) {+ db := setupProjectTestDB(t)+ svc := NewProjectService(db, nil, nil, nil, nil, nil)++ display := &models.Project{+ BaseModel: models.BaseModel{ID: "p2"},+ Name: "My Project!",+ Path: "/tmp/my-project",+ }+ require.NoError(t, db.Create(display).Error)++ found, err := svc.GetProjectByComposeName(ctx, "myproject")+ require.NoError(t, err)+ assert.Equal(t, display.ID, found.ID)+ })++ t.Run("invalidates stale normalized cache entries after deletion", func(t *testing.T) {+ db := setupProjectTestDB(t)+ svc := NewProjectService(db, nil, nil, nil, nil, nil)++ original := &models.Project{+ BaseModel: models.BaseModel{ID: "p3"},+ Name: "My Project!",+ Path: "/tmp/my-project",+ }+ require.NoError(t, db.Create(original).Error)++ found, err := svc.GetProjectByComposeName(ctx, "myproject")+ require.NoError(t, err)+ assert.Equal(t, original.ID, found.ID)++ cachedProjectID, cached := svc.getCachedComposeProjectIDInternal("myproject")+ require.True(t, cached)+ assert.Equal(t, original.ID, cachedProjectID)++ require.NoError(t, db.Delete(&models.Project{}, "id = ?", original.ID).Error)++ replacement := &models.Project{+ BaseModel: models.BaseModel{ID: "p4"},+ Name: "My Project!",+ Path: "/tmp/my-project-recreated",+ }+ require.NoError(t, db.Create(replacement).Error)++ found, err = svc.GetProjectByComposeName(ctx, "myproject")+ require.NoError(t, err)+ assert.Equal(t, replacement.ID, found.ID)++ cachedProjectID, cached = svc.getCachedComposeProjectIDInternal("myproject")+ require.True(t, cached)+ assert.Equal(t, replacement.ID, cachedProjectID)+ })++ t.Run("invalidates stale normalized cache entries after rename", func(t *testing.T) {+ db := setupProjectTestDB(t)+ svc := NewProjectService(db, nil, nil, nil, nil, nil)++ original := &models.Project{+ BaseModel: models.BaseModel{ID: "p5"},+ Name: "My App!",+ Path: "/tmp/my-app",+ }+ require.NoError(t, db.Create(original).Error)++ found, err := svc.GetProjectByComposeName(ctx, "myapp")+ require.NoError(t, err)+ assert.Equal(t, original.ID, found.ID)++ cachedProjectID, cached := svc.getCachedComposeProjectIDInternal("myapp")+ require.True(t, cached)+ assert.Equal(t, original.ID, cachedProjectID)++ require.NoError(t, db.Model(&models.Project{}).Where("id = ?", original.ID).Updates(map[string]any{+ "name": "New Service",+ "path": "/tmp/new-service",+ }).Error)++ _, err = svc.GetProjectByComposeName(ctx, "myapp")+ require.Error(t, err)+ assert.Contains(t, err.Error(), "project not found")++ _, cached = svc.getCachedComposeProjectIDInternal("myapp")+ assert.False(t, cached)+ })+}+func TestResolveServiceImagePullMode(t *testing.T) {tests := []struct {name string@@ -1346,8 +1467,8 @@ func TestProjectService_PrepareServiceBuildRequest_UsesExecutorVisiblePaths(t *t)require.NoError(t, err)- assert.Equal(t, "/app/data/projects/demo", req.ContextDir)- assert.Equal(t, "/app/data/projects/demo/Dockerfile.custom", req.Dockerfile)+ assert.Equal(t, "/docker-data/arcane/projects/demo", req.ContextDir)+ assert.Equal(t, "/docker-data/arcane/projects/demo/Dockerfile.custom", req.Dockerfile)}func TestProjectService_PrepareServiceBuildRequest_UsesInlineDockerfile(t *testing.T) {diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.goindex a263c631f..8f3220970 100644--- a/backend/internal/services/updater_service.go+++ b/backend/internal/services/updater_service.go@@ -392,9 +392,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*updatefunc (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID string) (*updater.Result, error) {start := time.Now()out := &updater.Result{Items: []updater.ResourceResult{}}-slog.InfoContext(ctx, "UpdateSingleContainer: starting", "containerID", containerID)-dcli, err := s.dockerService.GetClient(ctx)if err != nil {return nil, fmt.Errorf("docker connect: %w", err)@@ -593,6 +591,50 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID}// Update the container+ projectName := inspect.Config.Labels["com.docker.compose.project"]+ serviceName := inspect.Config.Labels["com.docker.compose.service"]++ if projectName != "" && serviceName != "" {+ slog.InfoContext(ctx, "UpdateSingleContainer: detected compose container, using project-based update", "containerID", containerID, "project", projectName, "service", serviceName)++ proj, err := s.projectService.GetProjectByComposeName(ctx, projectName)+ if err == nil {+ // The direct image pull above is still required to compare digests and+ // skip no-op updates. Compose project updates intentionally pull again+ // inside UpdateProjectServices to keep project redeploy behavior unified.+ if err := s.projectService.UpdateProjectServices(ctx, proj.ID, []string{serviceName}, systemUser); err != nil {+ out.Items = append(out.Items, updater.ResourceResult{+ ResourceID: targetContainer.ID,+ ResourceType: "container",+ ResourceName: containerName,+ Status: "failed",+ Error: fmt.Sprintf("project update failed: %v", err),+ })+ out.Failed+++ out.Duration = time.Since(start).String()+ return out, nil+ }++ out.Items = append(out.Items, updater.ResourceResult{+ ResourceID: targetContainer.ID,+ ResourceType: "container",+ ResourceName: containerName,+ Status: "updated",+ })+ out.Updated+++ out.Checked = 1+ out.Duration = time.Since(start).String()++ // Prune old image if no longer in use+ if inspectBefore.Image != "" {+ _ = s.pruneImageIDsWithInUseSetInternal(ctx, []string{inspectBefore.Image}, nil)+ }++ return out, nil+ }+ slog.WarnContext(ctx, "UpdateSingleContainer: compose labels found but project not found in DB, falling back to standalone update", "project", projectName, "err", err)+ }+if err := s.updateContainer(ctx, *targetContainer, inspect, normalizedRef); err != nil {out.Items = append(out.Items, updater.ResourceResult{ResourceID: targetContainer.ID,@@ -1144,6 +1186,15 @@ func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref strreturn ids, nil}+type restartPlan struct {+ cnt container.Summary+ inspect *container.InspectResponse+ newRef string+ match string+ explicit bool+ implicit bool+}+//nolint:gocognitfunc (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDToNewRef map[string]string, oldRefToNewRef map[string]string) ([]updater.ResourceResult, error) {dcli, err := s.dockerService.GetClient(ctx)@@ -1173,15 +1224,6 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDupdatedNorm[s.normalizeRef(oldRef)] = nr}- type restartPlan struct {- cnt container.Summary- inspect *container.InspectResponse- newRef string- match string- explicit bool- implicit bool- }-plansByName := map[string]*restartPlan{}markedForRestart := map[string]bool{}containersWithDeps := make([]libupdater.ContainerWithDeps, 0, len(list))@@ -1302,6 +1344,45 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDsorted = candidates}+ // Pre-scan sorted containers to group compose project services that need updates.+ // We only group containers that are explicitly marked for restart (p.newRef != "").+ projectToServices := make(map[string][]string) // projectID -> []serviceName+ projectToSeenServices := make(map[string]map[string]struct{}) // projectID -> set(serviceName)+ projectIDToObj := make(map[string]*models.Project)+ projectNameToID := make(map[string]string)++ for _, cd := range sorted {+ p := plansByName[cd.Name]+ if p == nil || p.newRef == "" || p.inspect == nil || p.inspect.Config == nil {+ continue+ }+ projectName := p.inspect.Config.Labels["com.docker.compose.project"]+ serviceName := p.inspect.Config.Labels["com.docker.compose.service"]+ if projectName != "" && serviceName != "" {+ projectID, ok := lookupComposeProjectIDInternal(projectName, projectNameToID)+ if !ok {+ proj, err := s.projectService.GetProjectByComposeName(ctx, projectName)+ if err != nil {+ continue+ }+ projectID = proj.ID+ projectIDToObj[proj.ID] = proj+ projectNameToID[proj.Name] = proj.ID+ projectNameToID[loader.NormalizeProjectName(proj.Name)] = proj.ID+ }+ if _, ok := projectToSeenServices[projectID]; !ok {+ projectToSeenServices[projectID] = make(map[string]struct{})+ }+ if _, seen := projectToSeenServices[projectID][serviceName]; !seen {+ projectToServices[projectID] = append(projectToServices[projectID], serviceName)+ projectToSeenServices[projectID][serviceName] = struct{}{}+ }+ }+ }++ processedProjectServices := make(map[string]map[string]struct{})+ projectResults := make(map[string]error) // stores error from the project-level update run+var results []updater.ResourceResultfor _, cd := range sorted {p := plansByName[cd.Name]@@ -1327,6 +1408,11 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDinspect := inspectResult.ContainerinspectCopy := inspectp.inspect = &inspectCopy++ // If this container belongs to a compose project that was missed during the+ // pre-scan (inspect was nil), register it now so the main loop routes it+ // through the compose-aware update path instead of standalone stop/rm/run.+ s.lazyRegisterComposeProjectInternal(ctx, p, projectNameToID, projectIDToObj, projectToServices, projectToSeenServices)}if p.inspect.Config != nil && p.inspect.Config.Labels != nil {labels = p.inspect.Config.Labels@@ -1348,7 +1434,7 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDcontinue}- slog.DebugContext(ctx, "restartContainersUsingOldIDs: restarting container", "containerId", p.cnt.ID, "container", name, "match", p.match, "newRef", p.newRef, "implicit", p.implicit)+ slog.DebugContext(ctx, "restartContainersUsingOldIDs: processing container", "containerId", p.cnt.ID, "container", name, "match", p.match, "newRef", p.newRef, "implicit", p.implicit)func() {endContainerStatus := s.beginContainerUpdateInternal(p.cnt.ID)@@ -1356,7 +1442,47 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDendProjectStatus := s.beginProjectUpdateInternal(composeProjectNameFromLabelsInternal(labels))defer endProjectStatus()- // Arcane self-updates must go through the detached CLI upgrader.+ projectName := labels["com.docker.compose.project"]+ serviceName := labels["com.docker.compose.service"]+ var proj *models.Project+ if projectName != "" {+ if projectID, ok := lookupComposeProjectIDInternal(projectName, projectNameToID); ok {+ proj = projectIDToObj[projectID]+ }+ }++ if proj != nil && serviceName != "" && !libupdater.IsArcaneContainer(labels) {+ if pErr, failed := projectResults[proj.ID]; failed {+ res.Status = "failed"+ res.Error = fmt.Sprintf("project-level update failed: %v", pErr)+ } else {+ pendingServices := pendingComposeProjectServicesInternal(processedProjectServices, proj.ID, projectToServices[proj.ID])+ if len(pendingServices) > 0 {+ slog.InfoContext(ctx, "restartContainersUsingOldIDs: executing project-level update", "project", proj.Name, "services", pendingServices)+ err := s.projectService.UpdateProjectServices(ctx, proj.ID, pendingServices, systemUser)+ markComposeProjectServicesProcessedInternal(processedProjectServices, proj.ID, pendingServices)+ if err != nil {+ slog.ErrorContext(ctx, "restartContainersUsingOldIDs: project update failed", "project", proj.Name, "err", err)+ projectResults[proj.ID] = err+ }+ }++ if pErr, failed := projectResults[proj.ID]; failed {+ res.Status = "failed"+ res.Error = fmt.Sprintf("project-level update failed: %v", pErr)+ } else {+ res.Status = "updated"+ res.UpdateAvailable = true+ res.UpdateApplied = true+ // Send notification+ if s.notificationService != nil {+ if notifErr := s.notificationService.SendContainerUpdateNotification(ctx, name, p.newRef, p.match, s.normalizeRef(p.newRef)); notifErr != nil {+ slog.WarnContext(ctx, "Failed to send container update notification", "containerId", p.cnt.ID, "containerName", name, "imageRef", p.newRef, "error", notifErr.Error())+ }+ }+ }+ }+ } else // Arcane self-updates must go through the detached CLI upgrader.if libupdater.IsArcaneContainer(labels) {if err := s.triggerSelfUpdateViaCLIInternal(ctx, "restartContainersUsingOldIDs", p.cnt.ID, name, labels); err != nil {res.Status = "failed"@@ -1429,6 +1555,80 @@ func (s *UpdaterService) triggerSelfUpdateViaCLIInternal(ctx context.Context, soreturn nil}+func pendingComposeProjectServicesInternal(processedProjectServices map[string]map[string]struct{}, projectID string, services []string) []string {+ if len(services) == 0 {+ return nil+ }++ processed := processedProjectServices[projectID]+ pending := make([]string, 0, len(services))+ for _, service := range services {+ if processed == nil {+ pending = append(pending, service)+ continue+ }+ if _, alreadyProcessed := processed[service]; !alreadyProcessed {+ pending = append(pending, service)+ }+ }++ return pending+}++func markComposeProjectServicesProcessedInternal(processedProjectServices map[string]map[string]struct{}, projectID string, services []string) {+ if len(services) == 0 {+ return+ }++ if _, exists := processedProjectServices[projectID]; !exists {+ processedProjectServices[projectID] = make(map[string]struct{}, len(services))+ }+ for _, service := range services {+ processedProjectServices[projectID][service] = struct{}{}+ }+}++// lazyRegisterComposeProjectInternal registers a compose project into the pre-scan lookup maps when the+// container's inspect data was unavailable during the pre-scan (inspect was nil at that point).+// Without this, the main loop's lookupComposeProjectIDInternal call would miss the project and+// fall through to the destructive standalone stop/rm/run path.+func (s *UpdaterService) lazyRegisterComposeProjectInternal(+ ctx context.Context,+ p *restartPlan,+ projectNameToID map[string]string,+ projectIDToObj map[string]*models.Project,+ projectToServices map[string][]string,+ projectToSeenServices map[string]map[string]struct{},+) {+ if p.newRef == "" || p.inspect == nil || p.inspect.Config == nil {+ return+ }+ projectName := p.inspect.Config.Labels["com.docker.compose.project"]+ serviceName := p.inspect.Config.Labels["com.docker.compose.service"]+ if projectName == "" || serviceName == "" {+ return+ }++ projectID, registered := lookupComposeProjectIDInternal(projectName, projectNameToID)+ if !registered {+ proj, err := s.projectService.GetProjectByComposeName(ctx, projectName)+ if err != nil {+ return+ }+ projectID = proj.ID+ projectIDToObj[proj.ID] = proj+ projectNameToID[proj.Name] = proj.ID+ projectNameToID[loader.NormalizeProjectName(proj.Name)] = proj.ID+ }+ if _, ok := projectToSeenServices[projectID]; !ok {+ projectToSeenServices[projectID] = make(map[string]struct{})+ }+ if _, seen := projectToSeenServices[projectID][serviceName]; !seen {+ projectToServices[projectID] = append(projectToServices[projectID], serviceName)+ projectToSeenServices[projectID][serviceName] = struct{}{}+ }+}+func (s *UpdaterService) beginContainerUpdateInternal(containerID string) func() {containerID = strings.TrimSpace(containerID)if containerID == "" {@@ -1470,6 +1670,17 @@ func composeProjectNameFromLabelsInternal(labels map[string]string) string {return strings.TrimSpace(labels["com.docker.compose.project"])}+func lookupComposeProjectIDInternal(projectName string, projectNameToID map[string]string) (string, bool) {+ if projectName == "" || len(projectNameToID) == 0 {+ return "", false+ }+ if projectID, ok := projectNameToID[projectName]; ok {+ return projectID, true+ }+ projectID, ok := projectNameToID[loader.NormalizeProjectName(projectName)]+ return projectID, ok+}+func (s *UpdaterService) statusSnapshotInternal() updater.Status {s.statusMu.RLock()defer s.statusMu.RUnlock()diff --git a/backend/internal/services/updater_service_test.go b/backend/internal/services/updater_service_test.goindex c14840594..5d973197b 100644--- a/backend/internal/services/updater_service_test.go+++ b/backend/internal/services/updater_service_test.go@@ -8,6 +8,7 @@ import ("testing""time"+ "github.com/compose-spec/compose-go/v2/loader""github.com/getarcaneapp/arcane/backend/internal/config""github.com/getarcaneapp/arcane/backend/internal/database"glsqlite "github.com/glebarez/sqlite"@@ -284,6 +285,96 @@ func TestUpdaterService_UpgradeServiceNotNilCheck(t *testing.T) {assert.True(t, mockUpgrade.triggerCalled, "Should call CLI upgrade when service is not nil")}+func TestLookupComposeProjectIDInternal(t *testing.T) {+ t.Run("exact match", func(t *testing.T) {+ projectID, ok := lookupComposeProjectIDInternal("myproject", map[string]string{+ "myproject": "p1",+ })+ require.True(t, ok)+ assert.Equal(t, "p1", projectID)+ })++ t.Run("normalized fallback", func(t *testing.T) {+ projectID, ok := lookupComposeProjectIDInternal("My Project", map[string]string{+ loader.NormalizeProjectName("myproject"): "p1",+ })+ require.True(t, ok)+ assert.Equal(t, "p1", projectID)+ })++ t.Run("missing project", func(t *testing.T) {+ projectID, ok := lookupComposeProjectIDInternal("missing", map[string]string{+ "other": "p1",+ })+ require.False(t, ok)+ assert.Empty(t, projectID)+ })+}++func TestUpdaterService_LazyRegisterComposeProjectInternal_AddsServicesForRegisteredProject(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()++ project := &models.Project{+ BaseModel: models.BaseModel{ID: "p1"},+ Name: "My Project!",+ Path: "/tmp/my-project",+ }+ require.NoError(t, db.Create(project).Error)++ projectService := NewProjectService(db, nil, nil, nil, nil, nil)+ svc := &UpdaterService{projectService: projectService}++ projectNameToID := map[string]string{}+ projectIDToObj := map[string]*models.Project{}+ projectToServices := map[string][]string{}+ projectToSeenServices := map[string]map[string]struct{}{}++ firstPlan := &restartPlan{+ newRef: "nginx:latest",+ inspect: &container.InspectResponse{+ Config: &container.Config{+ Labels: map[string]string{+ "com.docker.compose.project": "myproject",+ "com.docker.compose.service": "web",+ },+ },+ },+ }+ secondPlan := &restartPlan{+ newRef: "nginx:latest",+ inspect: &container.InspectResponse{+ Config: &container.Config{+ Labels: map[string]string{+ "com.docker.compose.project": "myproject",+ "com.docker.compose.service": "worker",+ },+ },+ },+ }++ svc.lazyRegisterComposeProjectInternal(ctx, firstPlan, projectNameToID, projectIDToObj, projectToServices, projectToSeenServices)+ svc.lazyRegisterComposeProjectInternal(ctx, secondPlan, projectNameToID, projectIDToObj, projectToServices, projectToSeenServices)++ require.Contains(t, projectToServices, project.ID)+ assert.Equal(t, []string{"web", "worker"}, projectToServices[project.ID])+ assert.Equal(t, project.ID, projectNameToID[project.Name])+ assert.Equal(t, project.ID, projectNameToID[loader.NormalizeProjectName(project.Name)])+}++func TestPendingComposeProjectServicesInternal(t *testing.T) {+ processedProjectServices := map[string]map[string]struct{}{}++ assert.Equal(t, []string{"A"}, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A"}))++ markComposeProjectServicesProcessedInternal(processedProjectServices, "project-1", []string{"A"})+ assert.Empty(t, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A"}))+ assert.Equal(t, []string{"B"}, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A", "B"}))++ markComposeProjectServicesProcessedInternal(processedProjectServices, "project-1", []string{"B"})+ assert.Empty(t, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A", "B"}))+}+func TestAnyImageIDsInUseSet(t *testing.T) {inUseSet := map[string]struct{}{"sha256:one": {},diff --git a/backend/pkg/projects/cmds.go b/backend/pkg/projects/cmds.goindex dc453d247..31dd79cb3 100644--- a/backend/pkg/projects/cmds.go+++ b/backend/pkg/projects/cmds.go@@ -42,6 +42,40 @@ func ComposeRestart(ctx context.Context, proj *types.Project, services []string)return c.svc.Restart(ctx, proj.Name, api.RestartOptions{Services: services})}+func ComposePull(ctx context.Context, proj *types.Project, services []string) error {+ c, err := NewClient(ctx)+ if err != nil {+ return err+ }+ defer func() { _ = c.Close() }()++ filteredProject, err := filterProjectServicesForPullInternal(proj, services)+ if err != nil {+ return err+ }+ return c.svc.Pull(ctx, filteredProject, api.PullOptions{})+}++func filterProjectServicesForPullInternal(proj *types.Project, services []string) (*types.Project, error) {+ if proj == nil || len(services) == 0 {+ return proj, nil+ }++ return proj.WithSelectedServices(services, types.IgnoreDependencies)+}++func ComposeStop(ctx context.Context, proj *types.Project, services []string) error {+ if len(services) == 0 {+ return nil+ }+ c, err := NewClient(ctx)+ if err != nil {+ return err+ }+ defer func() { _ = c.Close() }()+ return c.svc.Stop(ctx, proj.Name, api.StopOptions{Services: services})+}+func ComposeUp(ctx context.Context, proj *types.Project, services []string, removeOrphans bool, forceRecreate bool) error {c, err := NewClient(ctx)if err != nil {diff --git a/backend/pkg/projects/cmds_test.go b/backend/pkg/projects/cmds_test.gonew file mode 100644index 000000000..3b051c30f--- /dev/null+++ b/backend/pkg/projects/cmds_test.go@@ -0,0 +1,56 @@+package projects++import (+ "context"+ "testing"++ composetypes "github.com/compose-spec/compose-go/v2/types"+ "github.com/stretchr/testify/require"+)++func TestComposeStopSkipsWhenNoServicesSpecified(t *testing.T) {+ t.Setenv("DOCKER_HOST", "tcp://127.0.0.1:9")++ err := ComposeStop(context.Background(), &composetypes.Project{Name: "test"}, nil)+ require.NoError(t, err)++ err = ComposeStop(context.Background(), &composetypes.Project{Name: "test"}, []string{})+ require.NoError(t, err)+}++func TestFilterProjectServicesForPullInternalReturnsDeepCopiedProject(t *testing.T) {+ project := &composetypes.Project{+ Name: "demo",+ Services: composetypes.Services{+ "web": {+ Name: "web",+ DependsOn: composetypes.DependsOnConfig{+ "db": {Condition: "service_started"},+ },+ },+ "db": {+ Name: "db",+ },+ },+ Networks: composetypes.Networks{+ "default": composetypes.NetworkConfig{+ Name: "demo_default",+ },+ },+ }++ filtered, err := filterProjectServicesForPullInternal(project, []string{"web"})+ require.NoError(t, err)+ require.NotNil(t, filtered)++ require.Contains(t, filtered.Services, "web")+ require.NotContains(t, filtered.Services, "db")++ web := filtered.Services["web"]+ delete(web.DependsOn, "db")+ filtered.Services["web"] = web+ delete(filtered.Networks, "default")++ require.Contains(t, project.Services["web"].DependsOn, "db")+ require.Contains(t, project.Networks, "default")+}diff --git a/frontend/messages/en.json b/frontend/messages/en.jsonindex 7ebac6742..6b8fad51f 100644--- a/frontend/messages/en.json+++ b/frontend/messages/en.json@@ -418,7 +418,7 @@"containers_update_column": "Updates","containers_update_container": "Update Container","containers_update_confirm_title": "Update Container",- "containers_update_confirm_message": "This will pull the latest image and restart the container \"{name}\". Do you want to continue?",+ "containers_update_confirm_message": "This will pull the latest image and apply the appropriate update for \"{name}\". Do you want to continue?","containers_update_pulling_image": "Pulling latest image...","containers_update_success": "Container \"{name}\" updated successfully","containers_update_failed": "Failed to update container \"{name}\"",diff --git a/frontend/src/lib/components/arcane-button/arcane-button.svelte b/frontend/src/lib/components/arcane-button/arcane-button.svelteindex 41efa6ed2..2faf1adb5 100644--- a/frontend/src/lib/components/arcane-button/arcane-button.svelte+++ b/frontend/src/lib/components/arcane-button/arcane-button.svelte@@ -81,6 +81,7 @@this={href ? 'a' : 'button'}{...rest}data-slot="arcane-button"+ data-action={action}type={href ? undefined : type}href={href && !disabled ? href : undefined}disabled={href ? undefined : disabled || loading}diff --git a/frontend/src/routes/(app)/environments/[id]/+page.svelte b/frontend/src/routes/(app)/environments/[id]/+page.svelteindex 67015fe6f..604b45018 100644--- a/frontend/src/routes/(app)/environments/[id]/+page.svelte+++ b/frontend/src/routes/(app)/environments/[id]/+page.svelte@@ -173,7 +173,7 @@trivyCpuLimit: z.coerce.number().int(m.security_session_timeout_integer()).nonnegative(),trivyMemoryLimitMb: z.coerce.number().int().nonnegative(),trivyConcurrentScanContainers: z.coerce.number().int().min(1, m.security_trivy_concurrent_scan_containers_min()),- autoUpdateExcludedContainers: z.string(),+ autoUpdateExcludedContainers: z.string().optional(),autoHealEnabled: z.boolean(),autoHealExcludedContainers: z.string(),autoHealMaxRestarts: z.coerce.number().int().min(1),diff --git a/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte b/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelteindex bead252be..1ccdf7881 100644--- a/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte+++ b/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte@@ -52,23 +52,17 @@return result.data.data;});- const excludedContainers = new SvelteSet<string>();let searchTerm = $state('');+ let autoHealSearchTerm = $state('');- $effect(() => {+ const excludedContainers = $derived.by(() => {const savedValue = $formInputs.autoUpdateExcludedContainers?.value || '';- const names = savedValue- .split(',')- .map((s: string) => normalizeContainerName(s.trim()))- .filter(Boolean);-- // Synchronize the SvelteSet with the form input value- // Only update if there are actual changes to avoid unnecessary reactivity- const currentNames = Array.from(excludedContainers);- if (names.length !== currentNames.length || names.some((n: string) => !excludedContainers.has(n))) {- excludedContainers.clear();- names.forEach((n: string) => excludedContainers.add(n));- }+ return new SvelteSet(+ savedValue+ .split(',')+ .map((s: string) => normalizeContainerName(s.trim()))+ .filter(Boolean)+ );});function resolveSettingsUrl(job: JobStatus, prereq: JobPrerequisite): string | undefined {@@ -99,46 +93,39 @@function toggleContainerExclusion(containerName: string) {const normalizedName = normalizeContainerName(containerName);- if (excludedContainers.has(normalizedName)) {- excludedContainers.delete(normalizedName);+ const newSet = new SvelteSet(excludedContainers);+ if (newSet.has(normalizedName)) {+ newSet.delete(normalizedName);} else {- excludedContainers.add(normalizedName);+ newSet.add(normalizedName);}- const newValue = Array.from(excludedContainers).join(',');if ($formInputs.autoUpdateExcludedContainers) {- $formInputs.autoUpdateExcludedContainers.value = newValue;+ $formInputs.autoUpdateExcludedContainers.value = Array.from(newSet).join(',');}}- const autoHealExcludedContainers = new SvelteSet<string>();- let autoHealSearchTerm = $state('');-- $effect(() => {+ const autoHealExcludedContainers = $derived.by(() => {const savedValue = $formInputs.autoHealExcludedContainers?.value || '';- const names = savedValue- .split(',')- .map((s: string) => normalizeContainerName(s.trim()))- .filter(Boolean);-- const currentNames = Array.from(autoHealExcludedContainers);- if (names.length !== currentNames.length || names.some((n: string) => !autoHealExcludedContainers.has(n))) {- autoHealExcludedContainers.clear();- names.forEach((n: string) => autoHealExcludedContainers.add(n));- }+ return new SvelteSet(+ savedValue+ .split(',')+ .map((s: string) => normalizeContainerName(s.trim()))+ .filter(Boolean)+ );});function toggleAutoHealContainerExclusion(containerName: string) {const normalizedName = normalizeContainerName(containerName);- if (autoHealExcludedContainers.has(normalizedName)) {- autoHealExcludedContainers.delete(normalizedName);+ const newSet = new SvelteSet(autoHealExcludedContainers);+ if (newSet.has(normalizedName)) {+ newSet.delete(normalizedName);} else {- autoHealExcludedContainers.add(normalizedName);+ newSet.add(normalizedName);}- const newValue = Array.from(autoHealExcludedContainers).join(',');if ($formInputs.autoHealExcludedContainers) {- $formInputs.autoHealExcludedContainers.value = newValue;+ $formInputs.autoHealExcludedContainers.value = Array.from(newSet).join(',');}}diff --git a/tests/setup/global-teardown.ts b/tests/setup/global-teardown.tsindex ded867275..4aaa68b77 100644--- a/tests/setup/global-teardown.ts+++ b/tests/setup/global-teardown.ts@@ -1,4 +1,4 @@-import { execSync } from 'child_process';+import { execFileSync, execSync } from 'child_process';import path from 'node:path';import fs from 'node:fs';import { fileURLToPath } from 'node:url';@@ -36,7 +36,31 @@ async function globalTeardown() {if (item === '.env.global' || item === 'test-project-static') continue;if (fs.lstatSync(itemPath).isDirectory()) {- fs.rmSync(itemPath, { recursive: true, force: true });+ try {+ fs.rmSync(itemPath, { recursive: true, force: true });+ } catch (err: any) {+ if (err.code === 'EACCES' || err.code === 'EPERM') {+ // Arcane container creates files as root, fallback to docker to remove them+ execFileSync(+ 'docker',+ [+ 'run',+ '--rm',+ '-v',+ `${projectsDir}:/projects`,+ 'alpine',+ 'sh',+ '-c',+ 'rm -rf "/projects/$1"',+ '--',+ item+ ],+ { stdio: 'inherit' }+ );+ } else {+ throw err;+ }+ }console.log(` - Removed directory: ${item}`);} else if (item.startsWith('test-project-')) {fs.unlinkSync(itemPath);diff --git a/tests/spec/environment-settings.spec.ts b/tests/spec/environment-settings.spec.tsindex 2209bdb20..ca4621627 100644--- a/tests/spec/environment-settings.spec.ts+++ b/tests/spec/environment-settings.spec.ts@@ -79,6 +79,7 @@ test.describe('Environment Settings UI', () => {test.describe.configure({ mode: 'serial' });test('should update and save environment details', async ({ page }) => {+ test.setTimeout(120_000); // 120 seconds timeout for this lengthy UI workflowconst envName = `settings-ui-${Date.now().toString().slice(-5)}`;const updatedName = `${envName}-updated`;diff --git a/tests/spec/images.spec.ts b/tests/spec/images.spec.tsindex 087e333c9..f5c3c24b1 100644--- a/tests/spec/images.spec.ts+++ b/tests/spec/images.spec.ts@@ -197,6 +197,8 @@ test.describe('Images Page', () => {});test('should pull image via form', async ({ page }) => {+ test.setTimeout(180_000); // Pulling images can take a long time on CI+await navigateToImages(page);await page.getByRole('button', { name: 'Pull Image' }).click();diff --git a/tests/spec/volumes.spec.ts b/tests/spec/volumes.spec.tsindex bab9d82f0..2ff8ce39f 100644--- a/tests/spec/volumes.spec.ts+++ b/tests/spec/volumes.spec.ts@@ -65,7 +65,7 @@ async function removeVolumeViaUI(page: Page, volumeName: string) {await row.locator('a[href*="/volumes/"]').first().click();await expect(page).toHaveURL(/\/volumes\/.+/);- await page.getByRole('button', { name: 'Remove', exact: true }).click();+ await page.locator('button[data-slot="arcane-button"][data-action="remove"]').click();await page.getByRole('button', { name: 'Remove', exact: true }).last().click();await expect(page.locator('li[data-sonner-toast][data-type="success"] div[data-title]')@@ -150,7 +150,7 @@ test.describe('Volumes Page', () => {await expect(row).toBeVisible();await row.locator('a[href*="/volumes/"]').first().click();await expect(page).toHaveURL(new RegExp(`/volumes/.+`));- await page.getByRole('button', { name: 'Remove', exact: true }).click();+ await page.locator('button[data-slot="arcane-button"][data-action="remove"]').click();await page.getByRole('button', { name: 'Remove', exact: true }).last().click();await expect(