Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix(gitops): stop directory sync from copying unrelated project data (#4222)
Kyle Mendell2d59b51f4ac8
diff --git a/backend/internal/gitops/gitops_sync.go b/backend/internal/gitops/gitops_sync.goindex 26ed0c257..f81f4efa2 100644--- a/backend/internal/gitops/gitops_sync.go+++ b/backend/internal/gitops/gitops_sync.go@@ -35,7 +35,6 @@ import (schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler"swarmtypes "github.com/getarcaneapp/arcane/types/v2/swarm""go.getarcane.app/acfs"- acfstypes "go.getarcane.app/acfs/types""gorm.io/gorm")@@ -85,14 +84,17 @@ type stagedDirectorySync struct {projectsDir stringcomposeFileName stringproject *projectpkg.Project- syncedFiles []string+ // syncFiles are the repo files written raw; syncedFiles are their paths.+ syncFiles []projects.SyncFile+ syncedFiles []string+ // oldSyncedFiles are the paths the previous sync tracked.+ oldSyncedFiles []string+ // gitEnvContent is the repo's project-root .env, routed through the env merge.+ gitEnvContent *stringserviceCount intcontentsChanged bool- // copySkipped holds project-relative paths that could not be read when the- // live project directory was copied into the stage (e.g. foreign-owned- // bind-mount data). They are absent from the stage, so promotion must- // preserve rather than prune them.- copySkipped []string+ // backupScope names every live path promotion may create, rewrite or delete.+ backupScope projects.ProjectUpdateBackupScope}func validateSyncLimits(maxFiles *int, maxTotalSize, maxBinarySize *int64) error {@@ -1905,9 +1907,11 @@ func (s *GitOpsSyncService) syncProjectDirectoryInternal(ctx context.Context, sys.recordBrokenProjectBindingInternal(ctx, sync, actor, err)return nil, nil, false, false, err}+ // The stage must go even after ctx was cancelled: acfs refuses work on a+ // cancelled context.defer func() {- if stage != nil && stage.stagePath != "" {- _ = acfs.RemoveAll(ctx, stage.projectsDir, stage.stageLogical)+ if stage.stagePath != "" {+ _ = acfs.RemoveAll(context.WithoutCancel(ctx), stage.projectsDir, stage.stageLogical)}}()@@ -1930,8 +1934,10 @@ func (s *GitOpsSyncService) syncProjectDirectoryInternal(ctx context.Context, sy}// stageDirectorySyncInternal builds a temporary project tree that reflects the exact-// repo layout after sync, including cleanup of files removed from the repo.-func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync *projectpkg.GitOpsSync, syncFiles []projects.SyncFile) (*stagedDirectorySync, error) {+// repo layout after sync, including cleanup of files removed from the repo. For an+// existing project the tree is sparse: only paths the sync touches are materialized+// and the rest is linked to the live project, so validation never copies it.+func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync *projectpkg.GitOpsSync, syncFiles []projects.SyncFile) (stage *stagedDirectorySync, err error) {projectsDir, err := s.projectService.GetProjectsDirectory(ctx)if err != nil {return nil, errors.WrapIf(err, "failed to get projects directory")@@ -1947,104 +1953,150 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, syncif err != nil {return nil, errors.WrapIf(err, "failed to create staging directory")}- stagePath := filepath.Join(projectsDir, filepath.FromSlash(strings.TrimPrefix(stageLogical, "/")))+ defer func() {+ if err != nil {+ _ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDir, stageLogical)+ }+ }()++ stage = &stagedDirectorySync{+ stagePath: filepath.Join(projectsDir, filepath.FromSlash(strings.TrimPrefix(stageLogical, "/"))),+ stageLogical: stageLogical,+ projectsDir: projectsDir,+ composeFileName: filepath.Base(sync.ComposePath),+ syncFiles: filteredSyncFiles,+ syncedFiles: make([]string, len(filteredSyncFiles)),+ gitEnvContent: gitEnvContent,+ contentsChanged: true,+ }+ for i, file := range filteredSyncFiles {+ stage.syncedFiles[i] = file.RelativePath+ }++ // Syncs created before this fix may still have .env recorded as a tracked+ // file. Drop reserved root env files here too, or CleanupRemovedFiles would+ // treat .env as removed-by-git and delete the stage .env before+ // ApplyGitSyncEnvToDirectory gets a chance to read it for the merge.+ stage.oldSyncedFiles = filterReservedRootEnvFilesInternal(parseSyncedFiles(sync.SyncedFiles))- project, err := s.getDirectorySyncProjectInternal(ctx, sync)+ stage.project, err = s.getDirectorySyncProjectInternal(ctx, sync)if err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)return nil, err}- var copySkipped []string- if project != nil {- // Tolerate files Arcane cannot read (e.g. foreign-owned files a container- // wrote into the project directory through a relative bind mount). Skipping- // them keeps an unrelated unreadable file from aborting the whole sync; the- // skipped paths are preserved (not pruned) when the staged tree is mirrored- // back over the live project during promotion.- staged, stageErr := acfs.CopyDir(ctx, project.Path, stagePath, acfstypes.CopyOptions{TolerateUnreadable: true})- copySkipped = staged.Skipped- if err = stageErr; err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)+ if stage.project != nil {+ staleFiles, staleErr := projects.StaleComposeFiles(ctx, stage.project.Path, stage.composeFileName, stage.syncedFiles)+ if staleErr != nil {+ return nil, errors.WrapIf(staleErr, "failed to detect stale compose files")+ }+ stage.backupScope.Paths = slices.Concat(stage.syncedFiles, stage.oldSyncedFiles, staleFiles,+ []string{projects.EffectiveEnvFileName, projects.GitSourceEnvFileName, projects.OverrideEnvFileName})+ if err := linkProjectIntoStageInternal(stage.project.Path, stage.stagePath, stage.backupScope.Paths); err != nil {return nil, errors.WrapIf(err, "failed to stage current project files")}- if len(copySkipped) > 0 {- slog.WarnContext(ctx, "skipped unreadable files while staging project sync; they will be left untouched on promotion", "projectPath", project.Path, "skipped", copySkipped)+ if _, err := seedStageEnvFromDirInternal(ctx, stage.project.Path, projectsDir, stage.stagePath); err != nil {+ return nil, err+ }+ stage.contentsChanged, err = projects.DirectorySyncContentsChanged(ctx, stage.project.Path, filteredSyncFiles, stage.oldSyncedFiles, stage.composeFileName)+ if err != nil {+ return nil, errors.WrapIf(err, "failed to compare staged directory changes")}- } else if err := s.seedStageEnvFromCandidateDirInternal(ctx, sync, projectsDir, stagePath); err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)+ } else if err := s.seedStageEnvFromCandidateDirInternal(ctx, sync, projectsDir, stage.stagePath); err != nil {return nil, err}- syncedFiles := make([]string, len(filteredSyncFiles))- for i, file := range filteredSyncFiles {- syncedFiles[i] = file.RelativePath+ preEnvContent, postEnvContent, err := s.applyDirectorySyncInternal(ctx, stage.stagePath, stage)+ if err != nil {+ return nil, err}-- // Syncs created before this fix may still have .env recorded as a tracked- // file. Drop reserved root env files here too, or CleanupRemovedFiles would- // treat .env as removed-by-git and delete the live-copied stage .env before- // ApplyGitSyncEnvToDirectory gets a chance to read it for the merge.- oldSyncedFiles := filterReservedRootEnvFilesInternal(parseSyncedFiles(sync.SyncedFiles))- if len(oldSyncedFiles) > 0 {- if err := projects.CleanupRemovedFiles(ctx, projectsDir, stagePath, oldSyncedFiles, syncedFiles); err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)- return nil, errors.WrapIf(err, "failed to clean removed synced files")- }+ if stage.project != nil && projects.EnvContentChanged(preEnvContent, postEnvContent) {+ stage.contentsChanged = true}- composeFileName := filepath.Base(sync.ComposePath)- if err := projects.RemoveStaleComposeFiles(ctx, stagePath, composeFileName, syncedFiles); err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)- return nil, errors.WrapIf(err, "failed to remove stale compose files")+ stage.serviceCount, err = s.projectService.ValidateComposeDirectory(ctx, sync.ProjectName, stage.stagePath, stage.composeFileName)+ if err != nil {+ return nil, errors.WrapIf(err, "invalid compose file")}- contentsChanged := true- if project != nil {- contentsChanged, err = projects.DirectorySyncContentsChanged(ctx, project.Path, filteredSyncFiles, oldSyncedFiles, composeFileName)- if err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)- return nil, errors.WrapIf(err, "failed to compare staged directory changes")+ return stage, nil+}++// applyDirectorySyncInternal applies the sync to targetPath in the order+// validation saw it: drop files git no longer tracks and stale compose files,+// write the repo files, then run the project-root env merge. It returns the+// effective .env content before and after the merge.+func (s *GitOpsSyncService) applyDirectorySyncInternal(ctx context.Context, targetPath string, stage *stagedDirectorySync) (string, string, error) {+ if len(stage.oldSyncedFiles) > 0 {+ if err := projects.CleanupRemovedFiles(ctx, stage.projectsDir, targetPath, stage.oldSyncedFiles, stage.syncedFiles); err != nil {+ return "", "", errors.WrapIf(err, "failed to clean removed synced files")}}+ if err := projects.RemoveStaleComposeFiles(ctx, targetPath, stage.composeFileName, stage.syncedFiles); err != nil {+ return "", "", errors.WrapIf(err, "failed to remove stale compose files")+ }+// Write the repo files (excluding reserved root env files, handled below)// after cleanup so validation sees the final on-disk tree exactly as it// will exist in the managed project.- if _, err := projects.WriteSyncedDirectory(ctx, projectsDir, stagePath, filteredSyncFiles); err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)- return nil, errors.WrapIf(err, "failed to write staged sync files")+ if _, err := projects.WriteSyncedDirectory(ctx, stage.projectsDir, targetPath, stage.syncFiles); err != nil {+ return "", "", errors.WrapIf(err, "failed to write staged sync files")}// Route the project-root .env through the same three-file override merge// single-file git sync uses: git is source-of-truth, edits made in Arcane// become an override that wins, and new git-introduced keys still flow in.- preEnvContent, postEnvContent, err := s.projectService.ApplyGitSyncEnvToDirectory(ctx, stagePath, projectsDir, gitEnvContent)- if err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)- return nil, err- }- if project != nil && projects.EnvContentChanged(preEnvContent, postEnvContent) {- contentsChanged = true- }+ return s.projectService.ApplyGitSyncEnvToDirectory(ctx, targetPath, stage.projectsDir, stage.gitEnvContent)+}- serviceCount, err := s.projectService.ValidateComposeDirectory(ctx, sync.ProjectName, stagePath, composeFileName)- if err != nil {- _ = acfs.RemoveAll(ctx, projectsDir, stageLogical)- return nil, errors.WrapIf(err, "invalid compose file")+// linkProjectIntoStageInternal builds the sparse stage view of an existing+// project: paths in scope are left for the apply step, directories on the way+// to them are recreated, and everything else is exposed through a symlink to+// its live location so validation sees the whole tree without copying it.+// The links are validation-only and never promoted. acfs refuses to create+// symlinks by design, so this is the one place the stage is built with os.+func linkProjectIntoStageInternal(livePath, stagePath string, scopePaths []string) error {+ scope := make(map[string]struct{}, len(scopePaths))+ ancestors := make(map[string]struct{})+ for _, scopePath := range scopePaths {+ cleaned := path.Clean(filepath.ToSlash(scopePath))+ scope[cleaned] = struct{}{}+ for dir := path.Dir(cleaned); dir != "." && dir != "/"; dir = path.Dir(dir) {+ ancestors[dir] = struct{}{}+ }}- return &stagedDirectorySync{- stagePath: stagePath,- stageLogical: stageLogical,- projectsDir: projectsDir,- composeFileName: composeFileName,- project: project,- syncedFiles: syncedFiles,- serviceCount: serviceCount,- contentsChanged: contentsChanged,- copySkipped: copySkipped,- }, nil+ var link func(rel string) error+ link = func(rel string) error {+ entries, err := os.ReadDir(filepath.Join(livePath, filepath.FromSlash(rel)))+ if err != nil {+ if rel == "" && errors.Is(err, fs.ErrNotExist) {+ return nil+ }+ return err+ }+ for _, entry := range entries {+ entryRel := path.Join(rel, entry.Name())+ if _, touched := scope[entryRel]; touched {+ continue+ }+ stageEntry := filepath.Join(stagePath, filepath.FromSlash(entryRel))+ if _, isAncestor := ancestors[entryRel]; isAncestor && entry.IsDir() {+ if err := os.Mkdir(stageEntry, utils.DirPerm); err != nil {+ return err+ }+ if err := link(entryRel); err != nil {+ return err+ }+ continue+ }+ if err := os.Symlink(filepath.Join(livePath, filepath.FromSlash(entryRel)), stageEntry); err != nil {+ return err+ }+ }+ return nil+ }+ return link("")}// isReservedRootEnvFileInternal reports whether relPath is one of the@@ -2109,6 +2161,33 @@ func partitionReservedRootEnvFilesInternal(ctx context.Context, syncFiles []projreturn filtered, gitEnvContent}+// seedStageEnvFromDirInternal copies the readable project-root env files from+// sourceDir into the stage verbatim and returns the env state it read. A+// permission-locked file is skipped rather than aborting the whole staging+// attempt, matching how the env merge leaves such files untouched.+func seedStageEnvFromDirInternal(ctx context.Context, sourceDir, projectsDir, stagePath string) (projects.ProjectEnvState, error) {+ state, err := projects.ReadProjectEnvState(sourceDir)+ if err != nil {+ return state, errors.WrapIff(err, "read env files from %s", sourceDir)+ }+ if state.HasGitSource {+ if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, projects.GitSourceEnvFileName, state.GitContent); err != nil {+ return state, errors.WrapIf(err, "seed stage .env.git")+ }+ }+ if state.HasOverride {+ if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, projects.OverrideEnvFileName, state.OverrideContent); err != nil {+ return state, errors.WrapIf(err, "seed stage project.env")+ }+ }+ if state.HasEffective {+ if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, projects.EffectiveEnvFileName, state.DirectContent); err != nil {+ return state, errors.WrapIf(err, "seed stage .env")+ }+ }+ return state, nil+}+// seedStageEnvFromCandidateDirInternal copies env files from a pre-existing project// directory at the conventional path (projectsDir/<sanitized-sync-name>/) into the// staging directory before initial-sync validation. This lets users pre-seed@@ -2117,8 +2196,6 @@ func partitionReservedRootEnvFilesInternal(ctx context.Context, syncFiles []proj// files are touched — other files would conflict with what WriteSyncedDirectory// is about to lay down from git.func (s *GitOpsSyncService) seedStageEnvFromCandidateDirInternal(ctx context.Context, sync *projectpkg.GitOpsSync, projectsDir, stagePath string) error {- // The candidate may itself be a symlinked project directory, so it is probed- // with os.Stat and then used as the confinement root for the reads below.candidatePath := filepath.Join(projectsDir, projects.SanitizeProjectName(sync.ProjectName))info, err := os.Stat(candidatePath)if err != nil {@@ -2131,71 +2208,30 @@ func (s *GitOpsSyncService) seedStageEnvFromCandidateDirInternal(ctx context.Conreturn nil}- // A permission error (e.g. a chmod 000 or foreign-owned file) is treated- // like the file being absent: it's skipped rather than aborting the whole- // staging attempt, since seeding is a best-effort convenience.- readOptional := func(name string) (string, bool, error) {- content, readErr := acfs.ReadFile(ctx, candidatePath, "/"+name)- if readErr == nil {- return string(content), true, nil- }- if errors.Is(readErr, fs.ErrNotExist) {- return "", false, nil- }- if errors.Is(readErr, os.ErrPermission) {- slog.WarnContext(ctx, "skipping permission-locked project env file while seeding GitOps stage", "path", filepath.Join(candidatePath, name))- return "", false, nil- }- return "", false, errors.WrapIff(readErr, "read %s from %s", name, candidatePath)- }-- effective, hasEffective, err := readOptional(projects.EffectiveEnvFileName)- if err != nil {- return err- }- gitSource, hasGit, err := readOptional(projects.GitSourceEnvFileName)- if err != nil {- return err- }- override, hasOverride, err := readOptional(projects.OverrideEnvFileName)+ state, err := seedStageEnvFromDirInternal(ctx, candidatePath, projectsDir, stagePath)if err != nil {return err}- if !hasEffective && !hasGit && !hasOverride {+ if !state.HasEffective && !state.HasGitSource && !state.HasOverride {return nil}- if hasGit {- if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, projects.GitSourceEnvFileName, gitSource); err != nil {- return errors.WrapIf(err, "seed stage .env.git")- }- }- if hasOverride {- if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, projects.OverrideEnvFileName, override); err != nil {- return errors.WrapIf(err, "seed stage project.env")- }- }-- if hasEffective {- if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, ".env", effective); err != nil {- return errors.WrapIf(err, "seed stage .env")- }- } else {+ if !state.HasEffective {// Only .env.git and/or project.env exist, so derive .env from them.- merged, mergeErr := projects.BuildEffectiveEnvContent(gitSource, override)+ merged, mergeErr := projects.BuildEffectiveEnvContent(state.GitContent, state.OverrideContent)if mergeErr != nil {return errors.WrapIf(mergeErr, "build effective env from pre-existing project")}- if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, ".env", merged); err != nil {+ if err := projects.WriteProjectFile(ctx, projectsDir, stagePath, projects.EffectiveEnvFileName, merged); err != nil {return errors.WrapIf(err, "seed stage .env")}}slog.DebugContext(ctx, "Seeded GitOps stage with pre-existing project env files","candidatePath", candidatePath,- "hasEffective", hasEffective,- "hasGit", hasGit,- "hasOverride", hasOverride,+ "hasEffective", state.HasEffective,+ "hasGit", state.HasGitSource,+ "hasOverride", state.HasOverride,)return nil}@@ -2472,16 +2508,15 @@ func (s *GitOpsSyncService) createDirectorySyncProjectInternal(ctx context.Contereturn project, nil}-// updateDirectorySyncProjectInternal mirrors a validated staged tree into the-// existing project path in place so running containers keep their bind-mount-// inodes; a temporary backup copy allows rollback if promotion fails.+// updateDirectorySyncProjectInternal applies a validated stage to the existing+// project path in place so running containers keep their bind-mount inodes; a+// backup scoped to the touched paths allows rollback if promotion fails.func (s *GitOpsSyncService) updateDirectorySyncProjectInternal(ctx context.Context, sync *projectpkg.GitOpsSync, stage *stagedDirectorySync) (*projectpkg.Project, error) {project := stage.projectprojectPath := filepath.Clean(project.Path)- backupPath := ""existed := true- // The project directory is the confinement root for the mirror below and may+ // The project directory is the confinement root for the writes below and may// itself be a symlink, so it is probed and bootstrapped through os.if info, err := os.Stat(projectPath); err == nil {if !info.IsDir() {@@ -2499,48 +2534,45 @@ func (s *GitOpsSyncService) updateDirectorySyncProjectInternal(ctx context.Contereturn nil, errors.WrapIf(err, "failed to inspect current project directory")}- var backupSkipped []string+ // Rollback must run even after ctx was cancelled: acfs refuses work on a+ // cancelled context.+ cleanupCtx := context.WithoutCancel(ctx)+ var backup *projects.ProjectUpdateBackup+ keepBackup := falseif existed {- projectsDir, err := s.projectService.GetProjectsDirectory(ctx)+ var removeBackup func()+ var err error+ backup, removeBackup, err = projects.BackupProjectDirectory(ctx, stage.projectsDir, projectPath, ".gitops-backup-*", stage.backupScope)if err != nil {- return nil, errors.WrapIf(err, "failed to get projects directory")- }- backupLogical, tempErr := acfs.MkdirTemp(ctx, projectsDir, "/", ".gitops-backup-*")- if tempErr != nil {- return nil, errors.WrapIf(tempErr, "failed to create backup directory")- }- backupPath = filepath.Join(projectsDir, filepath.FromSlash(strings.TrimPrefix(backupLogical, "/")))- defer func() { _ = acfs.RemoveAll(ctx, projectsDir, backupLogical) }()- // Tolerate unreadable files (e.g. foreign-owned bind-mount data) so an- // unrelated file can't block the backup; the skipped paths are absent from- // the backup and must be preserved, not pruned, when restoring.- backedUp, backupErr := acfs.CopyDir(ctx, projectPath, backupPath, acfstypes.CopyOptions{TolerateUnreadable: true})- backupSkipped = backedUp.Skipped- if err = backupErr; err != nil {return nil, errors.WrapIf(err, "failed to back up current project directory")}- if len(backupSkipped) > 0 {- slog.WarnContext(ctx, "skipped unreadable files while backing up project for sync; they will be left untouched on rollback", "projectPath", projectPath, "skipped", backupSkipped)- }+ defer func() {+ if !keepBackup {+ removeBackup()+ }+ }()}- restore := func() {+ restore := func(cause error) error {var restoreErr errorif existed {- restoreErr = acfs.MirrorDir(ctx, backupPath, projectPath, acfstypes.MirrorOptions{Preserve: backupSkipped})+ restoreErr = projects.RestoreProjectDirectoryBackup(cleanupCtx, stage.projectsDir, projectPath, backup)} else {- restoreErr = acfs.RemoveAll(ctx, filepath.Dir(projectPath), "/"+filepath.Base(projectPath))+ restoreErr = acfs.RemoveAll(cleanupCtx, filepath.Dir(projectPath), "/"+filepath.Base(projectPath))}- if restoreErr != nil {- slog.ErrorContext(ctx, "Failed to restore project directory after sync promotion failure; directory may be in a mixed state", "projectPath", projectPath, "backupPath", backupPath, "error", restoreErr)+ if restoreErr == nil {+ return cause}+ if backup != nil {+ // Kept so the previous configuration can be recovered by hand.+ keepBackup = true+ slog.ErrorContext(ctx, "Failed to restore project directory after sync promotion failure; backup kept", "projectPath", projectPath, "backupPath", backup.BackupDir, "error", restoreErr)+ }+ return errors.Combine(cause, errors.WrapIf(restoreErr, "rollback project directory"))}- // Preserve files skipped while staging: they remain in the live project but are- // absent from the stage, so a plain mirror would prune them.- if err := acfs.MirrorDir(ctx, stage.stagePath, projectPath, acfstypes.MirrorOptions{Preserve: stage.copySkipped}); err != nil {- restore()- return nil, errors.WrapIf(err, "failed to promote staged project directory")+ if _, _, err := s.applyDirectorySyncInternal(ctx, projectPath, stage); err != nil {+ return nil, restore(errors.WrapIf(err, "failed to promote staged project directory"))}if err := s.db.WithContext(ctx).Model(&projectpkg.Project{}).Where("id = ?", project.ID).Updates(map[string]any{@@ -2548,8 +2580,7 @@ func (s *GitOpsSyncService) updateDirectorySyncProjectInternal(ctx context.Conte"gitops_managed_by": sync.ID,"updated_at": time.Now(),}).Error; err != nil {- restore()- return nil, errors.WrapIf(err, "failed to update project metadata after directory sync")+ return nil, restore(errors.WrapIf(err, "failed to update project metadata after directory sync"))}return project, nildiff --git a/backend/internal/gitops/service_test.go b/backend/internal/gitops/service_test.goindex 61c690a8a..a2d5b45f1 100644--- a/backend/internal/gitops/service_test.go+++ b/backend/internal/gitops/service_test.go@@ -9,6 +9,7 @@ import ("encoding/json""os""path/filepath"+ "strings""testing""time"@@ -645,6 +646,9 @@ services:},}+ keepBefore, err := os.Stat(filepath.Join(projectPath, "keep.txt"))+ require.NoError(t, err)+updatedProject, syncedFiles, created, changed, err := svc.syncProjectDirectoryInternal(ctx, sync, syncFiles, common.User{})require.NoError(t, err)require.NotNil(t, updatedProject)@@ -662,6 +666,11 @@ services:_, statErr = os.Stat(filepath.Join(updatedProject.Path, "compose.yaml"))require.ErrorIs(t, statErr, os.ErrNotExist)+ // An untracked sibling is outside the sync's scope: never copied, rewritten or pruned.+ keepAfter, err := os.Stat(filepath.Join(updatedProject.Path, "keep.txt"))+ require.NoError(t, err)+ assert.True(t, os.SameFile(keepBefore, keepAfter))+ assert.Equal(t, keepBefore.ModTime(), keepAfter.ModTime())keepBytes, err := os.ReadFile(filepath.Join(updatedProject.Path, "keep.txt"))require.NoError(t, err)assert.Equal(t, "keep me\n", string(keepBytes))@@ -1098,6 +1107,148 @@ func TestGitOpsSyncService_CreateDirectorySyncProjectInternal_RollsBackProjectOnassert.ErrorIs(t, statErr, os.ErrNotExist)}+// TestGitOpsSyncService_UpdateDirectorySyncProjectInternal_RollsBackScopedChangesOnUpdateFailure+// forces the project metadata update to fail after the synced files were written+// to the live project, and verifies the scoped rollback restores exactly what the+// sync touched (in place, keeping inodes) while unrelated files are never copied,+// rewritten or pruned.+func TestGitOpsSyncService_UpdateDirectorySyncProjectInternal_RollsBackScopedChangesOnUpdateFailure(t *testing.T) {+ ctx := context.Background()+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)++ projectPath := filepath.Join(projectsDir, "demo-project")+ writeFileInternal(t, projectPath, "docker-compose.yaml", []byte("services:\n app:\n image: nginx:1.26-alpine\n"))+ writeFileInternal(t, projectPath, "old.txt", []byte("remove me\n"))+ writeFileInternal(t, projectPath, "keep.txt", []byte("keep me\n"))+ writeFileInternal(t, projectPath, ".env", []byte("A=1\n"))+ writeFileInternal(t, projectPath, "data/blob.bin", []byte("bind-mount data\n"))+ // A directory sits where git now ships a file.+ require.NoError(t, os.MkdirAll(filepath.Join(projectPath, "config", "dynamic.yml"), 0o755))++ // Pre-linked, so the only projects-table update during the sync is the+ // metadata write that follows promotion.+ const syncID = "sync-directory-update-rollback"+ project := &projectpkg.Project{+ ID: "proj-directory-update-rollback",+ Name: "demo-project",+ DirName: new("demo-project"),+ Path: projectPath,+ Status: projectpkg.ProjectStatusStopped,+ GitOpsManagedBy: new(syncID),+ }+ require.NoError(t, db.Create(project).Error)++ oldSyncedFilesJSON, err := json.Marshal([]string{"docker-compose.yaml", "old.txt"})+ require.NoError(t, err)+ sync := &projectpkg.GitOpsSync{+ ID: syncID,+ Name: "demo-sync",+ EnvironmentID: "0",+ RepositoryID: "repo-1",+ ComposePath: "apps/demo/docker-compose.yaml",+ ProjectName: "demo-project",+ ProjectID: &project.ID,+ SyncDirectory: true,+ SyncedFiles: new(string(oldSyncedFilesJSON)),+ }+ require.NoError(t, db.Create(sync).Error)++ syncFiles := []projects.SyncFile{+ {RelativePath: "docker-compose.yaml", Content: []byte("services:\n app:\n image: nginx:1.27-alpine\n")},+ {RelativePath: "config/dynamic.yml", Content: []byte("http: {}\n")},+ {RelativePath: ".env", Content: []byte("A=1\nB=2\n")},+ }++ composeBefore, err := os.Stat(filepath.Join(projectPath, "docker-compose.yaml"))+ require.NoError(t, err)+ keepBefore, err := os.Stat(filepath.Join(projectPath, "keep.txt"))+ require.NoError(t, err)+ blobBefore, err := os.Stat(filepath.Join(projectPath, "data", "blob.bin"))+ require.NoError(t, err)++ // Fail after promotion wrote the live files. While the failure fires, the+ // scoped backup still exists: record the live compose content and what the+ // backup captured.+ var composeAtFailure string+ var backupContents []string+ callbackName := "test:fail_project_gitops_directory_update"+ require.NoError(t, db.Callback().Update().Before("gorm:update").Register(callbackName, func(tx *gorm.DB) {+ if tx.Statement == nil || tx.Statement.Table != "projects" {+ return+ }+ liveCompose, readErr := os.ReadFile(filepath.Join(projectPath, "docker-compose.yaml"))+ require.NoError(t, readErr)+ composeAtFailure = string(liveCompose)+ entries, readErr := os.ReadDir(projectsDir)+ require.NoError(t, readErr)+ for _, entry := range entries {+ if !strings.HasPrefix(entry.Name(), ".gitops-backup-") {+ continue+ }+ backupDir := filepath.Join(projectsDir, entry.Name())+ _ = filepath.WalkDir(backupDir, func(p string, _ os.DirEntry, _ error) error {+ rel, _ := filepath.Rel(backupDir, p)+ backupContents = append(backupContents, filepath.ToSlash(rel))+ return nil+ })+ }+ _ = tx.AddError(errors.New("forced project update failure"))+ }))+ defer func() {+ _ = db.Callback().Update().Remove(callbackName)+ }()++ updatedProject, _, _, _, err := svc.syncProjectDirectoryInternal(ctx, sync, syncFiles, common.User{})+ require.Error(t, err)+ require.Nil(t, updatedProject)+ assert.Contains(t, err.Error(), "forced project update failure")+ assert.NotContains(t, err.Error(), "rollback project directory")++ // Promotion had already applied the new files when the failure fired, and+ // the backup held only the paths the sync touches, never unrelated data.+ assert.Contains(t, composeAtFailure, "nginx:1.27-alpine")+ assert.ElementsMatch(t, []string{".", ".env", "config", "config/dynamic.yml", "docker-compose.yaml", "old.txt"}, backupContents)++ // Changed paths are back exactly as they were, in place.+ composeAfter, err := os.Stat(filepath.Join(projectPath, "docker-compose.yaml"))+ require.NoError(t, err)+ assert.True(t, os.SameFile(composeBefore, composeAfter))+ composeBytes, err := os.ReadFile(filepath.Join(projectPath, "docker-compose.yaml"))+ require.NoError(t, err)+ assert.Contains(t, string(composeBytes), "nginx:1.26-alpine")++ oldBytes, err := os.ReadFile(filepath.Join(projectPath, "old.txt"))+ require.NoError(t, err)+ assert.Equal(t, "remove me\n", string(oldBytes))++ configInfo, err := os.Stat(filepath.Join(projectPath, "config", "dynamic.yml"))+ require.NoError(t, err)+ assert.True(t, configInfo.IsDir())++ envBytes, err := os.ReadFile(filepath.Join(projectPath, ".env"))+ require.NoError(t, err)+ assert.Equal(t, "A=1\n", string(envBytes))+ _, statErr := os.Lstat(filepath.Join(projectPath, projects.GitSourceEnvFileName))+ assert.ErrorIs(t, statErr, os.ErrNotExist)++ // Unrelated files were left alone.+ keepAfter, err := os.Stat(filepath.Join(projectPath, "keep.txt"))+ require.NoError(t, err)+ assert.True(t, os.SameFile(keepBefore, keepAfter))+ assert.Equal(t, keepBefore.ModTime(), keepAfter.ModTime())+ blobAfter, err := os.Stat(filepath.Join(projectPath, "data", "blob.bin"))+ require.NoError(t, err)+ assert.True(t, os.SameFile(blobBefore, blobAfter))+ assert.Equal(t, blobBefore.ModTime(), blobAfter.ModTime())++ // Both scratch directories were removed.+ entries, err := os.ReadDir(projectsDir)+ require.NoError(t, err)+ for _, entry := range entries {+ assert.False(t, projects.IsGitOpsScratchDirName(entry.Name()), "leaked scratch directory %s", entry.Name())+ }+}+func TestProjectsRemoveStaleComposeFiles_RemovesStaleCustomComposeFiles(t *testing.T) {t.Parallel()diff --git a/backend/internal/gitops/service_unix_test.go b/backend/internal/gitops/service_unix_test.goindex 6f0552d71..e0f547eaa 100644--- a/backend/internal/gitops/service_unix_test.go+++ b/backend/internal/gitops/service_unix_test.go@@ -20,9 +20,8 @@ import (// TestGitOpsSyncService_SyncProjectDirectory_PreservesUnreadableBindMountData verifies// that re-syncing an existing GitOps project tolerates a foreign-owned unreadable file// inside the project directory (e.g. data a container wrote through a relative bind-// mount, owned by another UID with restrictive perms). The sync must succeed instead-// of aborting on the permission error while staging/backing up, and the unreadable-// file must be left untouched rather than pruned when the staged tree is promoted.+// mount, owned by another UID with restrictive perms). The file is outside the sync's+// scope, so staging, backup and promotion must never read, copy or prune it.func TestGitOpsSyncService_SyncProjectDirectory_PreservesUnreadableBindMountData(t *testing.T) {if os.Geteuid() == 0 {t.Skip("permission bits are ignored when running as root")diff --git a/backend/internal/project/project_update.go b/backend/internal/project/project_update.goindex d58a946dd..fcdb3ea85 100644--- a/backend/internal/project/project_update.go+++ b/backend/internal/project/project_update.go@@ -23,7 +23,6 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/event""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper""github.com/getarcaneapp/arcane/backend/v2/pkg/projects"- "github.com/getarcaneapp/arcane/backend/v2/pkg/utils"projecttypes "github.com/getarcaneapp/arcane/types/v2/project"volumetypes "github.com/getarcaneapp/arcane/types/v2/volume""github.com/moby/moby/client"@@ -145,19 +144,7 @@ func (s *ProjectService) prepareProjectUpdateBackupInternal(ctx context.Context,return nil, func() {}, nil}- backup, err := backupProjectDirectoryInternal(ctx, projectsDirectory, projectPath, scope)- if err != nil {- return nil, nil, err- }-- backupLogical, err := acfs.LogicalPath(projectsDirectory, backup.BackupDir)- if err != nil {- return nil, nil, errors.WrapIf(err, "failed to resolve project backup directory")- }- // The cleanup must run even when the update was cancelled, or the backup- // directory leaks: acfs refuses operations on an already-cancelled context.- cleanupCtx := context.WithoutCancel(ctx)- return backup, func() { _ = acfs.RemoveAll(cleanupCtx, projectsDirectory, backupLogical) }, nil+ return projects.BackupProjectDirectory(ctx, projectsDirectory, projectPath, ".project-update-backup-*", scope)}func (s *ProjectService) applyProjectUpdateWithRenameJournalInternal(ctx context.Context, proj *Project, name *string, projectsDirectory string, composeContent, envContent, overrideContent *string, volumeMigration volumetypes.Migration, renameJournal *projecttypes.RenameJournal, journalActive *bool, projectStateCommitted *bool) (err error) {@@ -219,7 +206,7 @@ func (s *ProjectService) handleProjectUpdateFailureInternal(ctx context.Context,}if backup != nil {- if restoreErr := restoreProjectDirectoryBackupInternal(ctx, projectsDirectory, proj.Path, backup); restoreErr != nil {+ if restoreErr := projects.RestoreProjectDirectoryBackup(ctx, projectsDirectory, proj.Path, backup); restoreErr != nil {err = stderrors.Join(err, errors.WrapIf(restoreErr, "failed to restore project files after update failure"))}}@@ -497,77 +484,6 @@ func isProjectRenameRequestedInternal(proj *Project, name *string) bool {return newName != "" && proj.Name != newName}-func backupProjectDirectoryInternal(ctx context.Context, projectsDirectory, projectPath string, scope projects.ProjectUpdateBackupScope) (*projects.ProjectUpdateBackup, error) {- projectAbs, err := filepath.Abs(projectPath)- if err != nil {- return nil, errors.WrapIf(err, "failed to resolve project path")- }- projectAbs = filepath.Clean(projectAbs)-- rootAbs, err := filepath.Abs(projectsDirectory)- if err != nil {- return nil, errors.WrapIf(err, "failed to resolve projects directory")- }- rootAbs = filepath.Clean(rootAbs)- if !projects.IsSafeSubdirectory(rootAbs, projectAbs) || projectAbs == rootAbs {- return nil, errors.New("project path is outside projects directory")- }-- backupLogical, err := acfs.MkdirTemp(ctx, projectsDirectory, "/", ".project-update-backup-*")- if err != nil {- return nil, errors.WrapIf(err, "failed to create project backup directory")- }- backupPath := filepath.Join(projectsDirectory, filepath.FromSlash(strings.TrimPrefix(backupLogical, "/")))- // Tolerate files Arcane cannot read (e.g. foreign-owned secrets): skip them- // in the backup so an unrelated unreadable file can't block the whole save.- // The skipped paths are recorded so the rollback restore can preserve them.- backup, err := projects.BackupProjectUpdateScope(ctx, projectAbs, backupPath, scope)- if err != nil {- // The unwind must run even when the backup failed because ctx was- // cancelled, or the fresh backup directory leaks.- _ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDirectory, backupLogical)- return nil, errors.WrapIf(err, "failed to backup project files")- }- if len(backup.Skipped) > 0 {- slog.WarnContext(ctx, "skipped unreadable files while backing up project; they will be left untouched on rollback", "projectPath", projectAbs, "skipped", backup.Skipped)- }- return backup, nil-}--func restoreProjectDirectoryBackupInternal(ctx context.Context, projectsDirectory, projectPath string, backup *projects.ProjectUpdateBackup) error {- projectAbs, err := filepath.Abs(projectPath)- if err != nil {- return errors.WrapIf(err, "failed to resolve project path")- }- projectAbs = filepath.Clean(projectAbs)-- rootAbs, err := filepath.Abs(projectsDirectory)- if err != nil {- return errors.WrapIf(err, "failed to resolve projects directory")- }- rootAbs = filepath.Clean(rootAbs)- if !projects.IsSafeSubdirectory(rootAbs, projectAbs) || projectAbs == rootAbs {- return errors.New("project path is outside projects directory")- }-- projectLogical, err := acfs.LogicalPath(rootAbs, projectAbs)- if err != nil {- return errors.WrapIf(err, "failed to resolve project directory")- }-- slog.DebugContext(ctx, "restoring project directory backup", "path", projectAbs, "backup", backup.BackupDir)- if err := acfs.MkdirAll(ctx, rootAbs, projectLogical, utils.DirPerm); err != nil {- return errors.WrapIf(err, "failed to recreate project directory")- }- // Restore only the paths the update could have mutated, in place: files- // that were skipped during backup (unreadable, e.g. foreign-owned secrets)- // are preserved, and out-of-scope files are never touched.- if err := projects.RestoreProjectUpdateBackup(ctx, projectAbs, backup); err != nil {- return errors.WrapIf(err, "failed to restore project backup")- }- return nil-}-func (s *ProjectService) persistUpdatedProjectFiles(ctx context.Context, proj *Project, projectsDirectory string, composeContent, envContent, overrideContent *string) error {switch {case composeContent != nil:diff --git a/backend/internal/project/workspace.go b/backend/internal/project/workspace.goindex 54d8f7837..cd1f56c22 100644--- a/backend/internal/project/workspace.go+++ b/backend/internal/project/workspace.go@@ -251,15 +251,7 @@ func (s *ProjectService) prepareProjectWorkspaceBackupInternal(ctx context.Contefor _, change := range changes {scope.Paths = append(scope.Paths, workspaceChangeTargetPathsInternal(change)...)}- backup, err := backupProjectDirectoryInternal(ctx, projectsDirectory, projectPath, scope)- if err != nil {- return nil, nil, err- }- backupLogical, err := acfs.LogicalPath(projectsDirectory, backup.BackupDir)- if err != nil {- return nil, nil, errors.WrapIf(err, "failed to resolve project backup directory")- }- return backup, func() { _ = acfs.RemoveAll(ctx, projectsDirectory, backupLogical) }, nil+ return projects.BackupProjectDirectory(ctx, projectsDirectory, projectPath, ".project-update-backup-*", scope)}func isGitOpsManagedProjectInternal(proj *Project) bool {diff --git a/backend/pkg/projects/fs_backup.go b/backend/pkg/projects/fs_backup.goindex b186e0e56..f33578f66 100644--- a/backend/pkg/projects/fs_backup.go+++ b/backend/pkg/projects/fs_backup.go@@ -2,6 +2,7 @@ package projectsimport ("context"+ "log/slog""os""path""path/filepath"@@ -9,6 +10,7 @@ import ("strings""emperror.dev/errors"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils""go.getarcane.app/acfs""go.getarcane.app/acfs/atomic"acfstypes "go.getarcane.app/acfs/types"@@ -166,8 +168,12 @@ func backupScopePathInternal(ctx context.Context, projRoot, backupRoot *os.Root,if err := copyBackupFileInternal(projRoot, backupRoot, rel, backup); err != nil {return err}+ case rel == EffectiveEnvFileName && info.Mode()&os.ModeSymlink != 0:+ if err := copyBackupEnvSymlinkInternal(projRoot, backupRoot, rel, backup); err != nil {+ return err+ }default:- // Symlinks and other special files: the apply operations reject them+ // Other symlinks and special files: the apply operations reject them// before mutating anything, so there is nothing to back up.}return nil@@ -229,6 +235,10 @@ func copyBackupEnvSymlinkInternal(projRoot, backupRoot *os.Root, rel string, bacbackup.Skipped = append(backup.Skipped, rel)return nil}+ if errors.Is(err, os.ErrNotExist) {+ // Dangling link: env writes leave it untouched, so there is nothing to restore.+ return nil+ }return errors.WrapIff(err, "resolve project env symlink %s", rel)}if !isSymlink {@@ -290,8 +300,14 @@ func RestoreProjectUpdateBackup(ctx context.Context, projectDir string, backup *return err}- // 3. Mirror backed-up directories back in place.+ // 3. Mirror backed-up directories back in place, clearing a file the+ // failed update may have put where the directory was.for _, rel := range backup.DirEntries {+ if live, err := projRoot.Lstat(rel); err == nil && !live.IsDir() {+ if err := projRoot.Remove(rel); err != nil {+ return errors.WrapIff(err, "remove conflicting file %s", rel)+ }+ }if err := projRoot.MkdirAll(rel, 0o755); err != nil {return errors.WrapIff(err, "recreate project directory %s", rel)}@@ -311,7 +327,7 @@ func RestoreProjectUpdateBackup(ctx context.Context, projectDir string, backup *// 4. Restore individual files in place.for _, rel := range backup.FileEntries {- if err := restoreBackupFileInternal(backupRoot, projRoot, backup, rel); err != nil {+ if err := restoreBackupFileInternal(ctx, backupRoot, projRoot, backup, rel); err != nil {return err}}@@ -321,7 +337,7 @@ func RestoreProjectUpdateBackup(ctx context.Context, projectDir string, backup *// then copy every top-level backup file back. Top-level directories and// symlinks are never touched.if backup.TopLevelFiles {- if err := restoreTopLevelFilesInternal(backupRoot, projRoot, backup); err != nil {+ if err := restoreTopLevelFilesInternal(ctx, backupRoot, projRoot, backup); err != nil {return err}}@@ -382,7 +398,7 @@ func skippedUnderInternal(skipped []string, rel string) []string {return under}-func restoreBackupFileInternal(backupRoot, projRoot *os.Root, backup *ProjectUpdateBackup, rel string) error {+func restoreBackupFileInternal(ctx context.Context, backupRoot, projRoot *os.Root, backup *ProjectUpdateBackup, rel string) error {info, err := backupRoot.Lstat(rel)if err != nil {return errors.WrapIff(err, "inspect backup file %s", rel)@@ -394,7 +410,15 @@ func restoreBackupFileInternal(backupRoot, projRoot *os.Root, backup *ProjectUpdif backup.envSymlink != nil && backup.envSymlink.relativePath == rel {return restoreBackupEnvSymlinkInternal(projRoot, backup.envSymlink, content, info.Mode().Perm())}- if live, err := projRoot.Lstat(rel); err == nil && live.IsDir() {+ live, liveErr := projRoot.Lstat(rel)+ if liveErr == nil && live.Mode().IsRegular() {+ // In place: the inode survives so container bind mounts of the file stay valid.+ if err := acfs.Write(ctx, projRoot.Name(), "/"+rel, content, acfs.WriteOptions{Mode: info.Mode().Perm(), InPlace: true}); err != nil {+ return errors.WrapIff(err, "restore project file %s", rel)+ }+ return nil+ }+ if liveErr == nil && live.IsDir() {if err := projRoot.RemoveAll(rel); err != nil {return errors.WrapIff(err, "remove conflicting directory %s", rel)}@@ -404,8 +428,8 @@ func restoreBackupFileInternal(backupRoot, projRoot *os.Root, backup *ProjectUpdreturn errors.WrapIff(err, "recreate parent directory of %s", rel)}}- // Atomic write: a crash mid-restore leaves either the failed-update- // content or the fully restored file, never a torn write.+ // Atomic create: a crash mid-restore leaves either nothing or the fully+ // restored file, never a torn write.if err := atomic.WriteFile(filepath.Join(projRoot.Name(), filepath.FromSlash(rel)), content, info.Mode().Perm()); err != nil {return errors.WrapIff(err, "restore project file %s", rel)}@@ -444,7 +468,7 @@ func restoreBackupEnvSymlinkInternal(projRoot *os.Root, envBackup *projectUpdatereturn nil}-func restoreTopLevelFilesInternal(backupRoot, projRoot *os.Root, backup *ProjectUpdateBackup) error {+func restoreTopLevelFilesInternal(ctx context.Context, backupRoot, projRoot *os.Root, backup *ProjectUpdateBackup) error {backupEntries, err := os.ReadDir(backupRoot.Name())if err != nil {return errors.WrapIf(err, "read backup directory")@@ -482,9 +506,82 @@ func restoreTopLevelFilesInternal(backupRoot, projRoot *os.Root, backup *Projectif !entry.Type().IsRegular() {continue}- if err := restoreBackupFileInternal(backupRoot, projRoot, backup, entry.Name()); err != nil {+ if err := restoreBackupFileInternal(ctx, backupRoot, projRoot, backup, entry.Name()); err != nil {return err}}return nil}++// BackupProjectDirectory creates a scratch backup directory named by pattern+// beside projectPath and backs up scope into it. The returned cleanup removes+// the backup directory and runs even after ctx was cancelled, since acfs+// refuses work on a cancelled context.+func BackupProjectDirectory(ctx context.Context, projectsDirectory, projectPath, pattern string, scope ProjectUpdateBackupScope) (*ProjectUpdateBackup, func(), error) {+ projectAbs, rootAbs, err := resolveProjectUnderRootInternal(projectsDirectory, projectPath)+ if err != nil {+ return nil, nil, err+ }++ backupLogical, err := acfs.MkdirTemp(ctx, rootAbs, "/", pattern)+ if err != nil {+ return nil, nil, errors.WrapIf(err, "failed to create project backup directory")+ }+ backupPath := filepath.Join(rootAbs, filepath.FromSlash(strings.TrimPrefix(backupLogical, "/")))+ cleanupCtx := context.WithoutCancel(ctx)+ cleanup := func() { _ = acfs.RemoveAll(cleanupCtx, rootAbs, backupLogical) }++ // Tolerate files Arcane cannot read (e.g. foreign-owned secrets): skip them+ // in the backup so an unrelated unreadable file can't block the whole save.+ // The skipped paths are recorded so the rollback restore can preserve them.+ backup, err := BackupProjectUpdateScope(ctx, projectAbs, backupPath, scope)+ if err != nil {+ cleanup()+ return nil, nil, errors.WrapIf(err, "failed to backup project files")+ }+ if len(backup.Skipped) > 0 {+ slog.WarnContext(ctx, "skipped unreadable files while backing up project; they will be left untouched on rollback", "projectPath", projectAbs, "skipped", backup.Skipped)+ }+ return backup, cleanup, nil+}++// RestoreProjectDirectoryBackup recreates projectPath if needed and restores+// the scoped backup into it in place.+func RestoreProjectDirectoryBackup(ctx context.Context, projectsDirectory, projectPath string, backup *ProjectUpdateBackup) error {+ projectAbs, rootAbs, err := resolveProjectUnderRootInternal(projectsDirectory, projectPath)+ if err != nil {+ return err+ }++ projectLogical, err := acfs.LogicalPath(rootAbs, projectAbs)+ if err != nil {+ return errors.WrapIf(err, "failed to resolve project directory")+ }++ slog.DebugContext(ctx, "restoring project directory backup", "path", projectAbs, "backup", backup.BackupDir)+ if err := acfs.MkdirAll(ctx, rootAbs, projectLogical, utils.DirPerm); err != nil {+ return errors.WrapIf(err, "failed to recreate project directory")+ }+ if err := RestoreProjectUpdateBackup(ctx, projectAbs, backup); err != nil {+ return errors.WrapIf(err, "failed to restore project backup")+ }+ return nil+}++func resolveProjectUnderRootInternal(projectsDirectory, projectPath string) (projectAbs, rootAbs string, err error) {+ projectAbs, err = filepath.Abs(projectPath)+ if err != nil {+ return "", "", errors.WrapIf(err, "failed to resolve project path")+ }+ projectAbs = filepath.Clean(projectAbs)++ rootAbs, err = filepath.Abs(projectsDirectory)+ if err != nil {+ return "", "", errors.WrapIf(err, "failed to resolve projects directory")+ }+ rootAbs = filepath.Clean(rootAbs)+ if !IsSafeSubdirectory(rootAbs, projectAbs) || projectAbs == rootAbs {+ return "", "", errors.New("project path is outside projects directory")+ }+ return projectAbs, rootAbs, nil+}diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.goindex 387c370af..9a426a970 100644--- a/backend/pkg/projects/fs_util.go+++ b/backend/pkg/projects/fs_util.go@@ -273,42 +273,38 @@ func DirectorySyncContentsChanged(ctx context.Context, projectPath string, syncFreturn false, nil}-func RemoveStaleComposeFiles(ctx context.Context, projectPath, composeFileName string, syncedFiles []string) error {+// StaleComposeFiles lists project-root compose files a directory sync no longer+// manages: other standard compose names, plus custom YAML files with compose+// root keys that are not part of the synced set. A missing project directory+// has nothing stale.+func StaleComposeFiles(ctx context.Context, projectPath, composeFileName string, syncedFiles []string) ([]string, error) {syncedFileSet := make(map[string]struct{}, len(syncedFiles))for _, file := range syncedFiles {syncedFileSet[file] = struct{}{}}- for _, candidate := range ComposeFileCandidates() {- if candidate == composeFileName {- continue- }- if _, exists := syncedFileSet[candidate]; exists {- continue- }- if err := acfs.Remove(ctx, projectPath, "/"+candidate); err != nil && !errors.Is(err, fs.ErrNotExist) {- return err- }- }-entries, err := acfs.List(ctx, projectPath, "/")if err != nil {- return err+ if errors.Is(err, fs.ErrNotExist) {+ return nil, nil+ }+ return nil, err}+ var stale []stringfor _, entry := range entries {- if entry.IsDirectory {- continue- }-name := entry.Name- if name == composeFileName {+ if entry.IsDirectory || name == composeFileName {continue}if _, exists := syncedFileSet[name]; exists {continue}- if slices.Contains(ComposeFileCandidates(), name) || !IsProjectFile(name) {+ if slices.Contains(ComposeFileCandidates(), name) {+ stale = append(stale, name)+ continue+ }+ if !IsProjectFile(name) {continue}@@ -316,8 +312,20 @@ func RemoveStaleComposeFiles(ctx context.Context, projectPath, composeFileName sif rootKeysErr != nil || !hasComposeRootKeys {continue}+ stale = append(stale, name)+ }++ return stale, nil+}++func RemoveStaleComposeFiles(ctx context.Context, projectPath, composeFileName string, syncedFiles []string) error {+ stale, err := StaleComposeFiles(ctx, projectPath, composeFileName, syncedFiles)+ if err != nil {+ return err+ }- if err := acfs.Remove(ctx, projectPath, entry.Path); err != nil && !errors.Is(err, fs.ErrNotExist) {+ for _, name := range stale {+ if err := acfs.Remove(ctx, projectPath, "/"+name); err != nil && !errors.Is(err, fs.ErrNotExist) {return err}}