Skip to content

Modern Docker Management, Designed for Everyone

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.go
index 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 string
composeFileName string
project *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 *string
serviceCount int
contentsChanged 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, sy
s.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, sync
if 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 []proj
return 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.Con
return 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.Conte
return 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.project
projectPath := 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.Conte
return 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 := false
if 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 error
if 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, nil
diff --git a/backend/internal/gitops/service_test.go b/backend/internal/gitops/service_test.go
index 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_RollsBackProjectOn
assert.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.go
index 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.go
index 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.go
index 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.Conte
for _, 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.go
index b186e0e56..f33578f66 100644
--- a/backend/pkg/projects/fs_backup.go
+++ b/backend/pkg/projects/fs_backup.go
@@ -2,6 +2,7 @@ package projects
import (
"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, bac
backup.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 *ProjectUpd
if 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 *ProjectUpd
return 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 *projectUpdate
return 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 *Project
if !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.go
index 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, syncF
return 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 []string
for _, 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 s
if 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
}
}