Skip to content

Modern Docker Management, Designed for Everyone

fix: reuse unclaimed project directories on create (#4343)

Kyle Mendellb80f1bc5a781
diff --git a/backend/internal/project/children/workspace/service.go b/backend/internal/project/children/workspace/service.go
index 0da0c6e5d..69bc3fc74 100644
--- a/backend/internal/project/children/workspace/service.go
+++ b/backend/internal/project/children/workspace/service.go
@@ -10,6 +10,7 @@ import (
"io"
"net/http"
"os"
+ "path"
"path/filepath"
"strings"
@@ -137,7 +138,7 @@ func (s *Service) Apply(
) error {
scope := projects.ProjectUpdateBackupScope{}
for _, change := range manifest.FileChanges {
- scope.Paths = append(scope.Paths, changeTargetPaths(change)...)
+ scope.Paths = append(scope.Paths, ChangeTargetPaths(change)...)
}
backup, cleanup, err := projects.BackupProjectDirectory(ctx, projectsDirectory, projectPath, ".project-update-backup-*", scope)
if err != nil {
@@ -252,7 +253,7 @@ func ValidateWorkspaceChangesAgainstGitOps(changes []project.WorkspaceFileChange
return false
}
for _, change := range changes {
- for _, target := range changeTargetPaths(change) {
+ for _, target := range ChangeTargetPaths(change) {
if touchesOwned(target) {
return common.Classify(common.ErrProjectWorkspaceForbidden, fmt.Errorf("%q is managed by git sync and can only be changed in the git repository", target))
}
@@ -261,9 +262,9 @@ func ValidateWorkspaceChangesAgainstGitOps(changes []project.WorkspaceFileChange
return nil
}
-// changeTargetPaths lists every normalized path a change can create, overwrite or
+// ChangeTargetPaths lists every normalized path a change can create, overwrite or
// delete; backup scope and GitOps ownership share it so they cannot diverge.
-func changeTargetPaths(change project.WorkspaceFileChange) []string {
+func ChangeTargetPaths(change project.WorkspaceFileChange) []string {
rel, err := kit.NormalizeRelativePath(change.RelativePath)
if err != nil {
return nil
@@ -275,7 +276,9 @@ func changeTargetPaths(change project.WorkspaceFileChange) []string {
paths = append(paths, filepath.ToSlash(filepath.Join(filepath.Dir(rel), newName)))
}
case project.FileOpMove:
- paths = append(paths, filepath.ToSlash(filepath.Join(change.NewParentPath, filepath.Base(rel))))
+ if parent, parentErr := projects.NormalizeProjectParentPath(change.NewParentPath); parentErr == nil {
+ paths = append(paths, path.Join(parent, path.Base(rel)))
+ }
}
return paths
}
diff --git a/backend/internal/project/service.go b/backend/internal/project/service.go
index 7d8ebe66e..da4753576 100644
--- a/backend/internal/project/service.go
+++ b/backend/internal/project/service.go
@@ -1306,10 +1306,22 @@ func (s *ProjectService) CreateProject(
return nil, fmt.Errorf("failed to get projects directory: %w", err)
}
+ // Held through the DB insert so concurrent creates and filesystem syncs
+ // cannot claim the directory while it is half written.
+ s.syncMu.Lock()
+ defer s.syncMu.Unlock()
+
basePath := filepath.Join(projectsDirectory, sanitized)
var projectPath, folderName string
+ var reused bool
if allowNameSuffix {
- projectPath, folderName, err = projects.CreateUniqueDir(ctx, projectsDirectory, basePath, name, utils.DirPerm)
+ // Projects at or nested beneath an existing directory claim it.
+ projectPath, folderName, reused, err = projects.CreateUniqueDir(ctx, projectsDirectory, basePath, name, utils.DirPerm, func(dir string) (bool, error) {
+ nestedPattern := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(dir+string(filepath.Separator)) + "%"
+ var claims int64
+ countErr := s.db.WithContext(ctx).Model(&Project{}).Where("path = ? OR path LIKE ? ESCAPE '\\'", dir, nestedPattern).Count(&claims).Error
+ return claims > 0, countErr
+ })
} else {
projectPath, folderName, err = projects.CreateExactDir(ctx, projectsDirectory, basePath, name, utils.DirPerm)
}
@@ -1321,6 +1333,53 @@ func (s *ProjectService) CreateProject(
return nil, fmt.Errorf("failed to resolve created project directory: %w", err)
}
+ // A new directory is removed on failure. A reused one only gains files:
+ // every path creation can write must be absent (an existing .env file is
+ // kept as is), so the backup records only absent paths and rollback removes just
+ // what was added. Blank env content keeps an existing .env; different
+ // content conflicts with it.
+ cleanupCtx := context.WithoutCancel(ctx)
+ undo := func() error { return acfs.RemoveAll(cleanupCtx, projectsDirectory, projectLogical) }
+ if reused {
+ targets := []string{projects.DefaultComposeFileName, projects.EffectiveEnvFileName}
+ for _, change := range manifest.FileChanges {
+ targets = append(targets, workspace.ChangeTargetPaths(change)...)
+ }
+ scope := projects.ProjectUpdateBackupScope{}
+ for _, target := range targets {
+ entry, statErr := acfs.Stat(ctx, projectPath, "/"+target, false)
+ switch {
+ case errors.Is(statErr, os.ErrNotExist):
+ scope.Paths = append(scope.Paths, target)
+ case statErr != nil:
+ return nil, workspace.WrapProjectWorkspaceError(statErr)
+ case target != projects.EffectiveEnvFileName || entry.IsDirectory:
+ return nil, common.Classify(common.ErrProjectWorkspaceConflict, fmt.Errorf("%s already exists in existing directory %q and cannot be changed", target, folderName))
+ }
+ }
+ envContent = kit.Ternary(strings.TrimSpace(kit.FromPtr(envContent)) == "", nil, envContent)
+ if envContent != nil {
+ currentEnv, readEnvErr := os.ReadFile(filepath.Join(projectPath, projects.EffectiveEnvFileName))
+ if !errors.Is(readEnvErr, os.ErrNotExist) && (readEnvErr != nil || string(currentEnv) != *envContent) {
+ return nil, common.Classify(common.ErrProjectWorkspaceConflict, fmt.Errorf(".env already exists in %q with different content; clear the environment content to keep it", folderName))
+ }
+ }
+ backup, cleanupBackup, backupProjectDirectoryErr := projects.BackupProjectDirectory(ctx, projectsDirectory, projectPath, ".project-update-backup-*", scope)
+ if backupProjectDirectoryErr != nil {
+ return nil, backupProjectDirectoryErr
+ }
+ defer cleanupBackup()
+ undo = func() error {
+ return projects.RestoreProjectDirectoryBackup(cleanupCtx, projectsDirectory, projectPath, backup)
+ }
+ }
+ rollback := func(cause error) error {
+ if undoErr := undo(); undoErr != nil {
+ return errors.Join(cause, fmt.Errorf("roll back project directory: %w", undoErr))
+ }
+ return cause
+ }
+
proj := &Project{
Name: name,
DirName: &folderName,
@@ -1337,8 +1396,7 @@ func (s *ProjectService) CreateProject(
SkipDirectories: s.config.ProjectScanSkipDirs,
ComposeFileName: projects.DefaultComposeFileName,
}); applyProjectWorkspaceChangesErr != nil {
- _ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDirectory, projectLogical)
- return nil, workspace.WrapProjectWorkspaceError(applyProjectWorkspaceChangesErr)
+ return nil, rollback(workspace.WrapProjectWorkspaceError(applyProjectWorkspaceChangesErr))
}
// GitOps-originated creates (allowNameSuffix=false) tolerate not-yet-supplied
@@ -1355,14 +1413,11 @@ func (s *ProjectService) CreateProject(
"",
!allowNameSuffix,
); validateComposeContentForUpdateErr != nil {
- _ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDirectory, projectLogical)
- return nil, fmt.Errorf("invalid compose file: %w", validateComposeContentForUpdateErr)
+ return nil, rollback(fmt.Errorf("invalid compose file: %w", validateComposeContentForUpdateErr))
}
if writeProjectFilesErr := projects.WriteProjectFiles(ctx, projectsDirectory, projectPath, composeContent, envContent); writeProjectFilesErr != nil {
- // Best-effort cleanup to restore pre-transaction behavior.
- _ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDirectory, projectLogical)
- return nil, fmt.Errorf("failed to save project files: %w", writeProjectFilesErr)
+ return nil, rollback(fmt.Errorf("failed to save project files: %w", writeProjectFilesErr))
}
composeMeta, err := projects.ParseArcaneComposeMetadata(
ctx,
@@ -1385,27 +1440,21 @@ func (s *ProjectService) CreateProject(
}
return tags.AttachInitial(tagStore{tx: tx}, proj.ID, normalizedUITags, normalizedTagColors)
}); transactionErr != nil {
- _ = acfs.RemoveAll(context.WithoutCancel(ctx), projectsDirectory, projectLogical)
- return nil, fmt.Errorf("failed to create project: %w", transactionErr)
+ return nil, rollback(fmt.Errorf("failed to create project: %w", transactionErr))
}
s.refreshComposeProjectName(ctx, proj)
s.refreshProjectImageRefs(ctx, proj)
if reconcileComposeProjectTagsErr := s.reconcileComposeProjectTags(ctx, proj.ID, composeMeta.ProjectTags); reconcileComposeProjectTagsErr != nil {
- cleanupCtx := context.WithoutCancel(ctx)
- databaseCleanupErr := s.db.WithContext(cleanupCtx).Transaction(func(tx *gorm.DB) error {
+ databaseCleanupErr := s.db.WithContext(context.WithoutCancel(ctx)).Transaction(func(tx *gorm.DB) error {
return deleteProjectWithTags(tx, proj.ID)
})
- fileCleanupErr := acfs.RemoveAll(cleanupCtx, projectsDirectory, projectLogical)
if databaseCleanupErr != nil {
databaseCleanupErr = fmt.Errorf("rollback project database state after tag reconciliation failure: %w", databaseCleanupErr)
}
- if fileCleanupErr != nil {
- fileCleanupErr = fmt.Errorf("rollback project files after tag reconciliation failure: %w", fileCleanupErr)
- }
- return nil, errors.Join(fmt.Errorf("reconcile Compose project tags: %w", reconcileComposeProjectTagsErr), databaseCleanupErr, fileCleanupErr)
+ return nil, rollback(errors.Join(fmt.Errorf("reconcile Compose project tags: %w", reconcileComposeProjectTagsErr), databaseCleanupErr))
}
- metadata := database.JSON{"action": "create", "projectID": proj.ID, "projectName": proj.Name, "path": projectPath}
+ metadata := database.JSON{"action": "create", "projectID": proj.ID, "projectName": proj.Name, "path": projectPath, "reusedDirectory": reused}
s.logProjectEvent(ctx, event.EventTypeProjectCreate, proj.ID, proj.Name, user, metadata, "could not log project creation")
return proj, nil
diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.go
index 9d73ffdef..77022c718 100644
--- a/backend/pkg/projects/fs_util.go
+++ b/backend/pkg/projects/fs_util.go
@@ -321,13 +321,16 @@ func RemoveStaleComposeFiles(ctx context.Context, projectPath, composeFileName s
}
// CreateUniqueDir creates a unique directory within the allowed projectsRoot,
-// suffixing "-N" until an unused name is found.
-func CreateUniqueDir(ctx context.Context, projectsRoot, basePath, name string, perm os.FileMode) (path, folderName string, err error) {
+// suffixing "-N" until an unused name is found. An existing basePath is reused
+// instead when it is a real directory that claimed reports as unowned and in
+// which Compose detection finds no file (an ambiguous result counts as one);
+// reused reports that case.
+func CreateUniqueDir(ctx context.Context, projectsRoot, basePath, name string, perm os.FileMode, claimed func(dir string) (bool, error)) (path, folderName string, reused bool, err error) {
sanitized := SanitizeProjectName(name)
// Reject empty or invalid sanitized names
if sanitized == "" || strings.Trim(sanitized, "_") == "" {
- return "", "", errors.New("invalid project name: results in empty directory name")
+ return "", "", false, errors.New("invalid project name: results in empty directory name")
}
candidate := basePath
@@ -336,15 +339,31 @@ func CreateUniqueDir(ctx context.Context, projectsRoot, basePath, name string, p
for counter := 1; ; counter++ {
logicalPath, logicalErr := acfs.LogicalPath(projectsRoot, candidate)
if logicalErr != nil {
- return "", "", fmt.Errorf("project directory would be outside allowed projects root: %w", logicalErr)
+ return "", "", false, fmt.Errorf("project directory would be outside allowed projects root: %w", logicalErr)
}
mkErr := acfs.Mkdir(ctx, projectsRoot, logicalPath, perm)
if mkErr == nil {
- return candidate, folderName, nil
+ return candidate, folderName, false, nil
}
if !errors.Is(mkErr, os.ErrExist) {
- return "", "", mkErr
+ return "", "", false, mkErr
+ }
+
+ if candidate == basePath {
+ info, statErr := os.Lstat(basePath)
+ if statErr != nil {
+ return "", "", false, fmt.Errorf("inspect existing project directory: %w", statErr)
+ }
+ isClaimed, claimedErr := claimed(basePath)
+ if claimedErr != nil {
+ return "", "", false, fmt.Errorf("check existing project directory claims: %w", claimedErr)
+ }
+ if info.IsDir() && !isClaimed {
+ if composePath, detectErr := DetectComposeFile(ctx, projectsRoot, basePath); composePath == "" && errors.Is(detectErr, common.ErrComposeFileNotFound) {
+ return basePath, folderName, true, nil
+ }
+ }
}
candidate = fmt.Sprintf("%s-%d", basePath, counter)
diff --git a/backend/pkg/projects/workspace.go b/backend/pkg/projects/workspace.go
index 59ae010cc..9373dbe82 100644
--- a/backend/pkg/projects/workspace.go
+++ b/backend/pkg/projects/workspace.go
@@ -19,6 +19,7 @@ import (
"github.com/getarcaneapp/arcane/types/v2/project"
workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"
+ "go.getarcane.app/acfs"
kit "go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
@@ -240,7 +241,7 @@ func classifyProjectWorkspaceFileInternal(filePath string, size, maxFileSizeByte
// rollback: on any error, earlier changes remain on disk. Callers own
// atomicity — ProjectService.UpdateProjectWorkspace wraps every save in
// BackupProjectUpdateScope / RestoreProjectUpdateBackup, and project creation
-// removes the whole directory on failure.
+// removes a new directory or restores the scoped backup of a reused one.
func ApplyProjectWorkspaceChanges(ctx context.Context, projectPath string, changes []project.WorkspaceFileChange, uploads map[int][]byte, opts ProjectWorkspaceApplyOptions) error {
if opts.MaxFileSizeBytes <= 0 {
opts.MaxFileSizeBytes = workspacepkg.MaxFileSizeBytes(workspacepkg.DefaultMaxFileSizeMB)
@@ -367,7 +368,7 @@ func createProjectWorkspaceFileInternal(root *os.Root, protected map[string]bool
f, err := root.OpenFile(rel, os.O_WRONLY|os.O_CREATE|os.O_EXCL, utils.FilePerm)
if err != nil {
if errors.Is(err, os.ErrExist) {
- return fmt.Errorf("project workspace file already exists: %s", rel)
+ return fmt.Errorf("project workspace file already exists: %s: %w", rel, acfs.ErrAlreadyExists)
}
return fmt.Errorf("create project workspace file: %w", err)
}
@@ -390,7 +391,7 @@ func createProjectWorkspaceFolderInternal(root *os.Root, protected map[string]bo
}
if _, err := root.Lstat(rel); err == nil {
- return fmt.Errorf("project workspace folder already exists: %s", rel)
+ return fmt.Errorf("project workspace folder already exists: %s: %w", rel, acfs.ErrAlreadyExists)
} else if !errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("inspect project workspace folder: %w", err)
}
@@ -495,7 +496,9 @@ func renameProjectWorkspacePathInternal(root *os.Root, protected map[string]bool
return nil
}
-func normalizeOptionalProjectParentPathInternal(input string) (string, error) {
+// NormalizeProjectParentPath normalizes a move destination folder; a blank
+// one is the project root.
+func NormalizeProjectParentPath(input string) (string, error) {
if strings.TrimSpace(input) == "" {
return "", nil
}
@@ -510,7 +513,7 @@ func moveProjectWorkspacePathInternal(root *os.Root, protected map[string]bool,
return err
}
- parentRel, err := normalizeOptionalProjectParentPathInternal(newParentPath)
+ parentRel, err := NormalizeProjectParentPath(newParentPath)
if err != nil {
return fmt.Errorf("invalid project workspace parent path: %w", err)
}
diff --git a/backend/pkg/scheduler/image_update_watcher_test.go b/backend/pkg/scheduler/image_update_watcher_test.go
index 16e7f23d7..afd665389 100644
--- a/backend/pkg/scheduler/image_update_watcher_test.go
+++ b/backend/pkg/scheduler/image_update_watcher_test.go
@@ -390,9 +390,10 @@ func TestImageUpdateWatcher_RunNowReturnsContainedScanPanicInternal(t *testing.T
settings := &pollingSettingReaderFakeInternal{enabled: true}
watcher := newImageUpdateWatcherForTestInternal(t, scanner, settings, bus.NewDockerEventBus(), nil)
startImageUpdateWatcherForTestInternal(t, watcher)
- // Wait for durable startup admission to finish, not just for the scanner to start.
+ // Wait for durable startup admission and the startup scan itself to finish,
+ // not just for the scanner to start; RunNow rejects a scan still running.
require.Eventually(t, func() bool {
- return scanner.countInternal() == 1 && watcher.triggerGeneration.Load() == watcher.acknowledgedGeneration.Load()
+ return scanner.countInternal() == 1 && watcher.triggerGeneration.Load() == watcher.acknowledgedGeneration.Load() && !watcher.scanRunning.Load()
}, time.Second, time.Millisecond)
ctx, cancel := context.WithTimeout(t.Context(), time.Second)