Skip to content

Modern Docker Management, Designed for Everyone

feat(projects): preserve managed volumes on project rename (#2919)

Neureka57a992cd3539
diff --git a/backend/api/handlers/projects.go b/backend/api/handlers/projects.go
index 7850fa78e..0c8ac2269 100644
--- a/backend/api/handlers/projects.go
+++ b/backend/api/handlers/projects.go
@@ -16,6 +16,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/services"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
activitylib "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/activity"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumes"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
@@ -667,6 +668,19 @@ func (h *ProjectHandler) DownProject(ctx context.Context, input *DownProjectInpu
}, nil
}
+func projectUpdateHTTPErrorInternal(err error) error {
+ if conflictErr, ok := errors.AsType[*volumes.ProjectVolumeRenameConflictError](err); ok {
+ return huma.Error409Conflict(conflictErr.Error())
+ }
+ if inUseErr, ok := errors.AsType[*volumes.ProjectVolumeRenameInUseError](err); ok {
+ return huma.Error409Conflict(inUseErr.Error())
+ }
+ if spaceErr, ok := errors.AsType[*volumes.ProjectVolumeRenameInsufficientSpaceError](err); ok {
+ return huma.NewError(http.StatusInsufficientStorage, spaceErr.Error())
+ }
+ return projectFileHTTPError(err)
+}
+
// projectFileHTTPError maps project file management errors to HTTP errors.
// It returns nil when err is not a project file error.
func projectFileHTTPError(err error) error {
@@ -945,7 +959,7 @@ func (h *ProjectHandler) UpdateProject(ctx context.Context, input *UpdateProject
return updateErr
})
if err != nil {
- if httpErr := projectFileHTTPError(err); httpErr != nil {
+ if httpErr := projectUpdateHTTPErrorInternal(err); httpErr != nil {
return nil, httpErr
}
return nil, huma.Error400BadRequest((&common.ProjectUpdateError{Err: err}).Error())
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index 3c329346c..699cad517 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -161,6 +161,9 @@ func initializeStartupState(appCtx context.Context, cfg *config.Config, appServi
slog.WarnContext(appCtx, "Failed to ensure local environment", "error", err)
}
if appServices.Project != nil {
+ if err := appServices.Project.RecoverProjectRenameJournals(appCtx); err != nil {
+ slog.WarnContext(appCtx, "Failed to recover interrupted project rename operations on startup", "error", err)
+ }
go appServices.Project.BackfillProjectImageRefs(appCtx)
}
diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go
index ea7003844..cb5b7d5a4 100644
--- a/backend/internal/config/config.go
+++ b/backend/internal/config/config.go
@@ -127,6 +127,23 @@ func Load() *Config {
return cfg
}
+type ProjectFilesConfig struct {
+ ProjectScanMaxDepth int
+ ProjectFileTreeMaxDepth int
+ ProjectScanSkipDirs string
+}
+
+func LoadProjectFilesConfig() ProjectFilesConfig {
+ cfg := &Config{}
+ loadFromEnv(cfg)
+
+ return ProjectFilesConfig{
+ ProjectScanMaxDepth: cfg.ProjectScanMaxDepth,
+ ProjectFileTreeMaxDepth: cfg.ProjectFileTreeMaxDepth,
+ ProjectScanSkipDirs: cfg.ProjectScanSkipDirs,
+ }
+}
+
func applyAgentModeDefaults(cfg *Config) {
if cfg.EdgeAgent {
cfg.AgentMode = true
diff --git a/backend/internal/di/providers.go b/backend/internal/di/providers.go
index df932e557..b075aeda6 100644
--- a/backend/internal/di/providers.go
+++ b/backend/internal/di/providers.go
@@ -114,8 +114,9 @@ func provideContainerRegistryServiceInternal(db *database.DB, docker *services.D
}, kv)
}
-func provideProjectServiceInternal(db *database.DB, settings *services.SettingsService, event *services.EventService, image *services.ImageService, docker *services.DockerClientService, build *services.BuildService, environment *services.EnvironmentService, cfg *config.Config) *services.ProjectService {
+func provideProjectServiceInternal(db *database.DB, settings *services.SettingsService, event *services.EventService, image *services.ImageService, docker *services.DockerClientService, build *services.BuildService, kv *services.KVService, environment *services.EnvironmentService, cfg *config.Config) *services.ProjectService {
return services.NewProjectService(db, settings, event, image, docker, build, cfg).
+ WithKVService(kv).
WithRegistryCredentialsProvider(environment.GetEnabledRegistryCredentials)
}
diff --git a/backend/internal/di/wire_gen.go b/backend/internal/di/wire_gen.go
index 3cff01377..a8f966e20 100644
--- a/backend/internal/di/wire_gen.go
+++ b/backend/internal/di/wire_gen.go
@@ -43,7 +43,7 @@ func InitializeServices(ctx context.Context, db *database.DB, cfg *config.Config
imageService := services.NewImageService(db, dockerClientService, containerRegistryService, imageUpdateService, vulnerabilityService, eventService)
gitRepositoryService := provideGitRepositoryServiceInternal(db, cfg, eventService, settingsService)
buildService := services.NewBuildService(db, settingsService, dockerClientService, containerRegistryService, gitRepositoryService, eventService)
- projectService := provideProjectServiceInternal(db, settingsService, eventService, imageService, dockerClientService, buildService, environmentService, cfg)
+ projectService := provideProjectServiceInternal(db, settingsService, eventService, imageService, dockerClientService, buildService, kvService, environmentService, cfg)
jobService := services.NewJobService(db, settingsService, cfg)
settingsSearchService := services.NewSettingsSearchService()
customizeSearchService := services.NewCustomizeSearchService()
diff --git a/backend/internal/services/kv_service.go b/backend/internal/services/kv_service.go
index 23b213e0d..424a7adfc 100644
--- a/backend/internal/services/kv_service.go
+++ b/backend/internal/services/kv_service.go
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"strconv"
+ "strings"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/models"
@@ -49,6 +50,22 @@ func (s *KVService) Set(ctx context.Context, key, value string) error {
return nil
}
+func (s *KVService) Delete(ctx context.Context, key string) error {
+ if err := s.db.WithContext(ctx).Delete(&models.KVEntry{}, "key = ?", key).Error; err != nil {
+ return fmt.Errorf("failed to delete kv entry %q: %w", key, err)
+ }
+ return nil
+}
+
+func (s *KVService) ListByPrefix(ctx context.Context, prefix string) ([]models.KVEntry, error) {
+ var entries []models.KVEntry
+ escapedPrefix := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(prefix)
+ if err := s.db.WithContext(ctx).Where("key LIKE ? ESCAPE '\\'", escapedPrefix+"%").Find(&entries).Error; err != nil {
+ return nil, fmt.Errorf("failed to list kv entries with prefix %q: %w", prefix, err)
+ }
+ return entries, nil
+}
+
func (s *KVService) GetBool(ctx context.Context, key string, defaultValue bool) (bool, error) {
rawValue, ok, err := s.Get(ctx, key)
if err != nil {
diff --git a/backend/internal/services/kv_service_prefix_test.go b/backend/internal/services/kv_service_prefix_test.go
new file mode 100644
index 000000000..700247097
--- /dev/null
+++ b/backend/internal/services/kv_service_prefix_test.go
@@ -0,0 +1,50 @@
+package services
+
+import (
+ "context"
+ "testing"
+
+ "github.com/getarcaneapp/arcane/backend/v2/internal/models"
+ "github.com/stretchr/testify/require"
+)
+
+func TestKVService_ListByPrefix_EscapesLikeWildcards(t *testing.T) {
+ ctx := context.Background()
+ svc := setupKVServiceInternal(t)
+
+ entries := map[string]string{
+ `project_rename_journal:real`: "journal",
+ `projectXrenameYjournalZ:false`: "false-positive",
+ `registry%pulls:real`: "registry",
+ `registryXpulls:false`: "registry-false-positive",
+ `path\prefix:real`: "path",
+ `pathXprefix:false`: "path-false-positive",
+ `project_rename_journal:real:other`: "journal-other",
+ }
+ for key, value := range entries {
+ require.NoError(t, svc.Set(ctx, key, value))
+ }
+
+ journalEntries, err := svc.ListByPrefix(ctx, "project_rename_journal:")
+ require.NoError(t, err)
+ require.ElementsMatch(t, []string{
+ `project_rename_journal:real`,
+ `project_rename_journal:real:other`,
+ }, kvEntryKeysForPrefixTestInternal(journalEntries))
+
+ registryEntries, err := svc.ListByPrefix(ctx, "registry%pulls:")
+ require.NoError(t, err)
+ require.ElementsMatch(t, []string{`registry%pulls:real`}, kvEntryKeysForPrefixTestInternal(registryEntries))
+
+ pathEntries, err := svc.ListByPrefix(ctx, `path\prefix:`)
+ require.NoError(t, err)
+ require.ElementsMatch(t, []string{`path\prefix:real`}, kvEntryKeysForPrefixTestInternal(pathEntries))
+}
+
+func kvEntryKeysForPrefixTestInternal(entries []models.KVEntry) []string {
+ keys := make([]string, 0, len(entries))
+ for _, entry := range entries {
+ keys = append(keys, entry.Key)
+ }
+ return keys
+}
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 0b033104f..d948daf6c 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -26,6 +26,7 @@ import (
dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/libbuild"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumes"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
@@ -37,6 +38,7 @@ import (
imagetypes "github.com/getarcaneapp/arcane/types/v2/image"
"github.com/getarcaneapp/arcane/types/v2/project"
"github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/client"
libupdater "go.getarcane.app/updater/pkg/labels"
"gorm.io/gorm"
)
@@ -48,6 +50,7 @@ type ProjectService struct {
imageService *ImageService
dockerService *DockerClientService
buildService *BuildService
+ kvService *KVService
config *config.Config
registryCredentialsProvider registryCredentialsProviderInternal
@@ -86,6 +89,14 @@ func (s *ProjectService) WithRegistryCredentialsProvider(provider func(context.C
return s
}
+func (s *ProjectService) WithKVService(kvService *KVService) *ProjectService {
+ if s == nil {
+ return nil
+ }
+ s.kvService = kvService
+ return s
+}
+
func (s *ProjectService) resolveRegistryCredentialsInternal(ctx context.Context) ([]containerregistry.Credential, error) {
if s == nil || s.registryCredentialsProvider == nil {
return nil, nil
@@ -139,7 +150,7 @@ func (s *ProjectService) getPathMapperInternal(ctx context.Context) *projects.Pa
// directories map to their own host path instead of a single projects-root prefix.
if s.dockerService != nil {
if dockerCli, derr := s.dockerService.GetClient(ctx); derr == nil {
- if mounts, merr := dockerutil.GetCurrentContainerMounts(ctx, dockerCli); merr == nil && len(mounts) > 0 {
+ if mounts, merr := projects.GetCurrentContainerMounts(ctx, dockerCli); merr == nil && len(mounts) > 0 {
pm := projects.NewPathMapperFromMounts(mounts)
if !pm.IsNonMatchingMount() {
return nil
@@ -1549,14 +1560,19 @@ func (s *ProjectService) SyncProjectsFromFileSystem(ctx context.Context) error {
return &common.ProjectDiscoveryError{Dir: projectsDir, Err: discoveryErr}
}
+ renameSyncState := s.activeProjectRenameSyncStateInternal(ctx)
seen := map[string]struct{}{}
for _, discoveredProject := range discoveredProjects {
+ if renameSyncState.skipDiscoveredPathInternal(discoveredProject.Path) {
+ continue
+ }
if uerr := s.upsertProjectForDir(ctx, discoveredProject.DirName, discoveredProject.Path); uerr != nil {
slog.WarnContext(ctx, "failed to sync project from folder", "dir", discoveredProject.Path, "error", uerr)
continue
}
seen[discoveredProject.Path] = struct{}{}
}
+ renameSyncState.markProtectedPathsSeenInternal(seen)
if cerr := s.cleanupDBProjectsInternal(ctx, seen, followProjectSymlinks, projectsDir, s.config.ProjectScanMaxDepth); cerr != nil {
slog.WarnContext(ctx, "error during DB cleanup of projects", "error", cerr)
@@ -1638,6 +1654,57 @@ type projectCleanupDecision struct {
reason string
}
+type activeProjectRenameSyncStateInternal struct {
+ skipDiscoveredPaths map[string]struct{}
+ protectSeenPaths map[string]struct{}
+}
+
+func (s *ProjectService) activeProjectRenameSyncStateInternal(ctx context.Context) activeProjectRenameSyncStateInternal {
+ state := activeProjectRenameSyncStateInternal{
+ skipDiscoveredPaths: make(map[string]struct{}),
+ protectSeenPaths: make(map[string]struct{}),
+ }
+ if s == nil || s.kvService == nil {
+ return state
+ }
+
+ entries, err := s.kvService.ListByPrefix(ctx, projectRenameJournalKeyPrefixInternal)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to list project rename journals during filesystem sync", "error", err)
+ return state
+ }
+
+ for _, entry := range entries {
+ var journal projectRenameJournalInternal
+ if err := json.Unmarshal([]byte(entry.Value), &journal); err != nil {
+ slog.WarnContext(ctx, "failed to decode project rename journal during filesystem sync", "key", entry.Key, "error", err)
+ continue
+ }
+ if !projectRenameJournalFilesystemSyncPendingInternal(journal.Phase) {
+ continue
+ }
+ if oldPath := strings.TrimSpace(journal.OldPath); oldPath != "" {
+ state.protectSeenPaths[filepath.Clean(oldPath)] = struct{}{}
+ }
+ if newPath := strings.TrimSpace(journal.NewPath); newPath != "" {
+ state.skipDiscoveredPaths[filepath.Clean(newPath)] = struct{}{}
+ }
+ }
+
+ return state
+}
+
+func (s activeProjectRenameSyncStateInternal) skipDiscoveredPathInternal(path string) bool {
+ _, ok := s.skipDiscoveredPaths[filepath.Clean(path)]
+ return ok
+}
+
+func (s activeProjectRenameSyncStateInternal) markProtectedPathsSeenInternal(seen map[string]struct{}) {
+ for path := range s.protectSeenPaths {
+ seen[path] = struct{}{}
+ }
+}
+
func (s *ProjectService) cleanupDBProjectsInternal(ctx context.Context, seen map[string]struct{}, followProjectSymlinks bool, projectsDir string, maxDepth int) error {
var all []models.Project
if err := s.db.WithContext(ctx).Find(&all).Error; err != nil {
@@ -1649,16 +1716,25 @@ func (s *ProjectService) cleanupDBProjectsInternal(ctx context.Context, seen map
// is unmounted, so every path is missing at once) before any rows are removed.
candidates := 0
pendingDeletions := make([]projectCleanupDecision, 0)
+ tempDeletions := make([]projectCleanupDecision, 0)
for _, p := range all {
if skipProjectCleanupInternal(p, seen) {
continue
}
+ if isProjectUpdateTempProjectInternal(p) {
+ tempDeletions = append(tempDeletions, projectCleanupDecision{project: p, reason: "removed internal project update temp record"})
+ continue
+ }
candidates++
if decision, remove := s.evaluateProjectCleanupInternal(ctx, p, followProjectSymlinks, projectsDir, maxDepth); remove {
pendingDeletions = append(pendingDeletions, decision)
}
}
+ for _, decision := range tempDeletions {
+ s.deleteProjectDuringCleanupInternal(ctx, decision.project, decision.reason)
+ }
+
if s.cleanupWouldMassWipeInternal(ctx, candidates, len(pendingDeletions), projectsDir) {
return nil
}
@@ -1704,6 +1780,18 @@ func skipProjectCleanupInternal(p models.Project, seen map[string]struct{}) bool
return p.GitOpsManagedBy != nil && strings.TrimSpace(*p.GitOpsManagedBy) != ""
}
+func isProjectUpdateTempProjectInternal(p models.Project) bool {
+ if isProjectUpdateTempNameInternal(p.Name) || isProjectUpdateTempNameInternal(filepath.Base(p.Path)) {
+ return true
+ }
+ return p.DirName != nil && isProjectUpdateTempNameInternal(*p.DirName)
+}
+
+func isProjectUpdateTempNameInternal(name string) bool {
+ name = strings.TrimSpace(name)
+ return strings.HasPrefix(name, ".project-update-preview-") || strings.HasPrefix(name, ".project-update-backup-")
+}
+
// evaluateProjectCleanupInternal decides whether a project that was not seen in
// the current filesystem pass should be pruned. It performs only read-only checks
// (warning in place for the "keep" cases); the actual deletion is deferred to the
@@ -2865,6 +2953,22 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
if err != nil {
return nil, err
}
+
+ name = resolveAuthoritativeProjectNameInternal(&proj, name, composeContent)
+ renameRequested := isProjectRenameRequestedInternal(&proj, name)
+ if err := s.recoverProjectRenameJournalForProjectInternal(ctx, projectID); err != nil {
+ if renameRequested {
+ return nil, err
+ }
+ slog.WarnContext(ctx, "project rename journal recovery failed before non-rename update; continuing", "projectID", projectID, "error", err)
+ } else {
+ proj, projectsDirectory, err = s.getProjectForUpdate(ctx, projectID)
+ if err != nil {
+ return nil, err
+ }
+ name = resolveAuthoritativeProjectNameInternal(&proj, name, composeContent)
+ }
+
if err := ensureProjectMutableInternal(&proj); err != nil {
return nil, err
}
@@ -2872,47 +2976,37 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
return nil, &common.ProjectFileForbiddenError{Err: errors.New("git-managed project files are read-only")}
}
- backupPath := ""
- var backupSkipped []string
- if len(fileChanges) > 0 {
- backupPath, backupSkipped, err = s.backupProjectDirectoryInternal(ctx, projectsDirectory, proj.Path)
- if err != nil {
- return nil, err
- }
- defer func() {
- if backupPath != "" {
- _ = os.RemoveAll(backupPath)
- }
- }()
+ if err := s.ensureProjectStoppedForRenameInternal(ctx, &proj, name); err != nil {
+ return nil, err
}
- name = resolveAuthoritativeProjectNameInternal(&proj, name, composeContent)
+ volumeMigration, err := s.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, &proj, name, projectsDirectory, composeContent, envContent, fileTreeRevision, fileChanges)
+ if err != nil {
+ return nil, err
+ }
- if err := s.withProjectRenameRollback(ctx, &proj, func() error {
- if err := s.applyProjectRenameIfNeeded(&proj, name, projectsDirectory); err != nil {
- return err
- }
- if err := s.persistProjectFileChanges(ctx, &proj, fileTreeRevision, fileChanges); err != nil {
- return err
- }
- if err := s.persistUpdatedProjectFiles(ctx, &proj, projectsDirectory, composeContent, envContent); err != nil {
- return err
- }
- if err := s.db.WithContext(ctx).Save(&proj).Error; err != nil {
- return fmt.Errorf("failed to update project: %w", err)
- }
- return nil
+ renameJournal := s.prepareProjectRenameJournalInternal(&proj, name, projectsDirectory, volumeMigration)
+
+ backupPath, backupSkipped, cleanupBackup, err := s.prepareProjectUpdateBackupInternal(ctx, projectsDirectory, proj.Path, composeContent, envContent, fileChanges)
+ if err != nil {
+ return nil, err
+ }
+ defer cleanupBackup()
+
+ journalActive, err := s.startProjectRenameJournalInternal(ctx, renameJournal)
+ if err != nil {
+ return nil, err
+ }
+
+ projectStateCommitted := false
+ if err := s.withProjectRenameRollback(ctx, &proj, &projectStateCommitted, func() error {
+ return s.applyProjectUpdateWithRenameJournalInternal(ctx, &proj, name, projectsDirectory, composeContent, envContent, fileTreeRevision, fileChanges, volumeMigration, renameJournal, &journalActive, &projectStateCommitted)
}); err != nil {
- if backupPath != "" {
- if restoreErr := s.restoreProjectDirectoryBackupInternal(ctx, projectsDirectory, proj.Path, backupPath, backupSkipped); restoreErr != nil {
- slog.WarnContext(ctx, "failed to restore project files after update failure", "projectID", projectID, "error", restoreErr)
- }
- }
+ err = s.handleProjectUpdateFailureInternal(ctx, projectID, projectsDirectory, &proj, backupPath, backupSkipped, &journalActive, projectStateCommitted, err)
return nil, err
}
s.refreshProjectAfterContentUpdateInternal(ctx, &proj, composeContent, fileChanges)
-
s.logProjectUpdateEventInternal(ctx, &proj, composeContent, envContent, fileChanges, user)
slog.InfoContext(ctx, "project updated", "projectID", proj.ID, "name", proj.Name)
@@ -2940,6 +3034,152 @@ func resolveAuthoritativeProjectNameInternal(proj *models.Project, name *string,
return name
}
+func (s *ProjectService) prepareProjectUpdateBackupInternal(ctx context.Context, projectsDirectory, projectPath string, composeContent, envContent *string, fileChanges []project.ProjectFileChange) (string, []string, func(), error) {
+ if composeContent == nil && envContent == nil && len(fileChanges) == 0 {
+ return "", nil, func() {}, nil
+ }
+
+ backupPath, skipped, err := s.backupProjectDirectoryInternal(ctx, projectsDirectory, projectPath)
+ if err != nil {
+ return "", nil, nil, err
+ }
+
+ return backupPath, skipped, func() { _ = os.RemoveAll(backupPath) }, nil
+}
+
+func (s *ProjectService) startProjectRenameJournalInternal(ctx context.Context, journal *projectRenameJournalInternal) (bool, error) {
+ if journal == nil {
+ return false, nil
+ }
+ if err := s.writeProjectRenameJournalInternal(ctx, journal, projectRenameJournalPhaseStartedInternal); err != nil {
+ return false, err
+ }
+ return true, nil
+}
+
+func (s *ProjectService) applyProjectUpdateWithRenameJournalInternal(ctx context.Context, proj *models.Project, name *string, projectsDirectory string, composeContent, envContent *string, fileTreeRevision *string, fileChanges []project.ProjectFileChange, volumeMigration volumes.Migration, renameJournal *projectRenameJournalInternal, journalActive *bool, projectStateCommitted *bool) (err error) {
+ volumeMigrationApplied := false
+ defer func() {
+ stateCommitted := projectStateCommitted != nil && *projectStateCommitted
+ if err != nil && volumeMigrationApplied && !stateCommitted {
+ if rollbackErr := volumeMigration.Rollback(ctx); rollbackErr != nil {
+ err = errors.Join(err, fmt.Errorf("failed to rollback project volume rename: %w", rollbackErr))
+ }
+ }
+ }()
+
+ if err = s.applyProjectRenameIfNeeded(proj, name, projectsDirectory); err != nil {
+ return err
+ }
+ if err = s.persistProjectFileChanges(ctx, proj, fileTreeRevision, fileChanges); err != nil {
+ return err
+ }
+ if err = s.persistUpdatedProjectFiles(ctx, proj, projectsDirectory, composeContent, envContent); err != nil {
+ return err
+ }
+ if err = s.applyProjectVolumeMigrationForUpdateInternal(ctx, volumeMigration, renameJournal, &volumeMigrationApplied); err != nil {
+ return err
+ }
+ if err = s.saveProjectUpdateInternal(ctx, proj); err != nil {
+ return err
+ }
+ if projectStateCommitted != nil {
+ *projectStateCommitted = true
+ }
+ s.finalizeProjectRenameAfterCommitInternal(ctx, proj.ID, volumeMigration, renameJournal, journalActive)
+ return nil
+}
+
+func (s *ProjectService) applyProjectVolumeMigrationForUpdateInternal(ctx context.Context, volumeMigration volumes.Migration, renameJournal *projectRenameJournalInternal, applied *bool) error {
+ if volumeMigration == nil {
+ return nil
+ }
+ if err := volumeMigration.Apply(ctx); err != nil {
+ return fmt.Errorf("failed to rename project volumes: %w", err)
+ }
+ *applied = true
+ return s.writeProjectRenameJournalInternal(ctx, renameJournal, projectRenameJournalPhaseTargetsCopiedInternal)
+}
+
+func (s *ProjectService) saveProjectUpdateInternal(ctx context.Context, proj *models.Project) error {
+ tx := s.db.WithContext(ctx).Begin()
+ if tx.Error != nil {
+ return fmt.Errorf("failed to start project update transaction: %w", tx.Error)
+ }
+
+ txCommitted := false
+ defer func() {
+ if !txCommitted {
+ _ = tx.Rollback().Error
+ }
+ }()
+
+ if err := tx.Save(proj).Error; err != nil {
+ return fmt.Errorf("failed to update project: %w", err)
+ }
+ if err := tx.Commit().Error; err != nil {
+ return fmt.Errorf("failed to commit project update: %w", err)
+ }
+ txCommitted = true
+ return nil
+}
+
+func (s *ProjectService) finalizeProjectRenameAfterCommitInternal(ctx context.Context, projectID string, volumeMigration volumes.Migration, renameJournal *projectRenameJournalInternal, journalActive *bool) {
+ if renameJournal != nil {
+ if err := s.writeProjectRenameJournalInternal(ctx, renameJournal, projectRenameJournalPhaseProjectStateCommittedInternal); err != nil {
+ slog.WarnContext(ctx, "failed to mark project rename journal committed", "projectID", projectID, "error", err)
+ }
+ }
+
+ if committer, ok := volumeMigration.(volumes.Committer); ok {
+ if err := committer.Commit(ctx); err != nil {
+ slog.WarnContext(ctx, "failed to clean up project source volumes after committed rename", "projectID", projectID, "error", err)
+ var cleanupErr *volumes.SourceCleanupError
+ if errors.As(err, &cleanupErr) {
+ if writeErr := s.writeProjectRenameJournalInternal(ctx, renameJournal, projectRenameJournalPhaseSourceCleanupPendingInternal); writeErr != nil {
+ slog.WarnContext(ctx, "failed to mark project rename source cleanup pending", "projectID", projectID, "error", writeErr)
+ }
+ }
+ return
+ } else if err := s.writeProjectRenameJournalInternal(ctx, renameJournal, projectRenameJournalPhaseOldVolumesRemovedInternal); err != nil {
+ slog.WarnContext(ctx, "failed to mark old project rename volumes removed", "projectID", projectID, "error", err)
+ }
+ }
+
+ s.completeProjectRenameJournalForUpdateInternal(ctx, renameJournal, projectID, journalActive)
+}
+
+func (s *ProjectService) completeProjectRenameJournalForUpdateInternal(ctx context.Context, renameJournal *projectRenameJournalInternal, projectID string, journalActive *bool) {
+ if renameJournal == nil {
+ return
+ }
+ if clearErr := s.clearProjectRenameJournalInternal(ctx, projectID); clearErr != nil {
+ slog.WarnContext(ctx, "failed to clear project rename journal", "projectID", projectID, "error", clearErr)
+ return
+ }
+ *journalActive = false
+}
+
+func (s *ProjectService) handleProjectUpdateFailureInternal(ctx context.Context, projectID, projectsDirectory string, proj *models.Project, backupPath string, backupSkipped []string, journalActive *bool, projectStateCommitted bool, err error) error {
+ if projectStateCommitted {
+ return err
+ }
+
+ if backupPath != "" {
+ if restoreErr := s.restoreProjectDirectoryBackupInternal(ctx, projectsDirectory, proj.Path, backupPath, backupSkipped); restoreErr != nil {
+ err = errors.Join(err, fmt.Errorf("failed to restore project files after update failure: %w", restoreErr))
+ }
+ }
+ if *journalActive {
+ if recoverErr := s.recoverProjectRenameJournalForProjectInternal(ctx, projectID); recoverErr != nil {
+ err = errors.Join(err, fmt.Errorf("project rename recovery failed: %w", recoverErr))
+ } else {
+ *journalActive = false
+ }
+ }
+ return err
+}
+
func (s *ProjectService) logProjectUpdateEventInternal(ctx context.Context, proj *models.Project, composeContent, envContent *string, fileChanges []project.ProjectFileChange, user models.User) {
metadata := models.JSON{
"action": "update",
@@ -3044,32 +3284,142 @@ func (s *ProjectService) getProjectForUpdate(ctx context.Context, projectID stri
return proj, projectsDirectory, nil
}
+func (s *ProjectService) prepareProjectRenameVolumeMigrationForUpdateInternal(ctx context.Context, proj *models.Project, name *string, projectsDirectory string, composeContent, envContent *string, fileTreeRevision *string, fileChanges []project.ProjectFileChange) (volumes.Migration, error) {
+ if !isProjectRenameRequestedInternal(proj, name) {
+ return nil, nil
+ }
+ if err := requireProjectFileRevisionInternal(fileTreeRevision, fileChanges); err != nil {
+ return nil, err
+ }
+
+ if composeContent == nil && envContent == nil && len(fileChanges) == 0 {
+ return s.prepareProjectRenameVolumeMigrationInternal(ctx, proj, name)
+ }
+
+ previewPath, err := os.MkdirTemp(projectsDirectory, ".project-update-preview-*")
+ if err != nil {
+ return nil, fmt.Errorf("failed to create project update preview: %w", err)
+ }
+ defer func() {
+ if removeErr := os.RemoveAll(previewPath); removeErr != nil {
+ slog.WarnContext(ctx, "failed to remove project update preview", "path", previewPath, "error", removeErr)
+ }
+ }()
+
+ if err := projects.CopyDirectoryContents(proj.Path, previewPath); err != nil {
+ return nil, fmt.Errorf("failed to prepare project update preview: %w", err)
+ }
+
+ previewProject := *proj
+ previewProject.Path = previewPath
+ if err := s.applyProjectFileChangesInternal(ctx, &previewProject, "", fileChanges); err != nil {
+ return nil, fmt.Errorf("failed to prepare project update preview: %w", err)
+ }
+ if err := s.persistUpdatedProjectFiles(ctx, &previewProject, projectsDirectory, composeContent, envContent); err != nil {
+ return nil, fmt.Errorf("failed to prepare project update preview: %w", err)
+ }
+
+ return s.prepareProjectRenameVolumeMigrationInternal(ctx, &previewProject, name)
+}
+
+func (s *ProjectService) prepareProjectRenameVolumeMigrationInternal(ctx context.Context, proj *models.Project, name *string) (volumes.Migration, error) {
+ oldComposeName, newComposeName, ok := projectRenameVolumeMigrationComposeNamesInternal(s, proj, name)
+ if !ok {
+ return nil, nil
+ }
+
+ composeProject, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
+ if err != nil {
+ var notFound *common.ProjectComposeFileNotFoundError
+ if errors.As(err, &notFound) {
+ return nil, nil
+ }
+ return nil, fmt.Errorf("failed to load compose project for volume rename: %w", err)
+ }
+
+ dockerClient, err := s.dockerService.GetClient(ctx)
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker for volume rename: %w", err)
+ }
+
+ return volumes.PlanMigration(ctx, dockerClient, composeProject, oldComposeName, newComposeName)
+}
+
+func projectRenameVolumeMigrationComposeNamesInternal(s *ProjectService, proj *models.Project, name *string) (string, string, bool) {
+ if s == nil || s.dockerService == nil || proj == nil || name == nil {
+ return "", "", false
+ }
+
+ newProjectName := strings.TrimSpace(*name)
+ if newProjectName == "" || proj.Name == newProjectName || proj.Status != models.ProjectStatusStopped {
+ return "", "", false
+ }
+
+ oldComposeName := normalizeComposeProjectName(proj.Name)
+ newComposeName := normalizeComposeProjectName(newProjectName)
+ if oldComposeName == "" || newComposeName == "" || oldComposeName == newComposeName {
+ return "", "", false
+ }
+
+ return oldComposeName, newComposeName, true
+}
+
+func isProjectRenameRequestedInternal(proj *models.Project, name *string) bool {
+ if proj == nil || name == nil {
+ return false
+ }
+ newName := strings.TrimSpace(*name)
+ return newName != "" && proj.Name != newName
+}
+
func isGitOpsManagedProjectInternal(proj *models.Project) bool {
return proj != nil && proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != ""
}
-func (s *ProjectService) persistProjectFileChanges(ctx context.Context, proj *models.Project, fileTreeRevision *string, fileChanges []project.ProjectFileChange) error {
+func requireProjectFileRevisionInternal(fileTreeRevision *string, fileChanges []project.ProjectFileChange) error {
if len(fileChanges) == 0 {
return nil
}
if fileTreeRevision == nil || strings.TrimSpace(*fileTreeRevision) == "" {
return &common.ProjectFileBadRequestError{Err: errors.New("file tree revision is required")}
}
+ return nil
+}
+
+func (s *ProjectService) persistProjectFileChanges(ctx context.Context, proj *models.Project, fileTreeRevision *string, fileChanges []project.ProjectFileChange) error {
+ if err := requireProjectFileRevisionInternal(fileTreeRevision, fileChanges); err != nil {
+ return err
+ }
+ expectedRevision := ""
+ if fileTreeRevision != nil {
+ expectedRevision = strings.TrimSpace(*fileTreeRevision)
+ }
+ return s.applyProjectFileChangesInternal(ctx, proj, expectedRevision, fileChanges)
+}
+
+func (s *ProjectService) applyProjectFileChangesInternal(ctx context.Context, proj *models.Project, expectedRevision string, fileChanges []project.ProjectFileChange) error {
+ if len(fileChanges) == 0 {
+ return nil
+ }
+ opts := s.projectFileApplyOptionsInternal(ctx, proj, expectedRevision)
+ if err := projects.ApplyProjectFileChanges(proj.Path, fileChanges, opts); err != nil {
+ return wrapProjectFileErrorInternal(err)
+ }
+ return nil
+}
+func (s *ProjectService) projectFileApplyOptionsInternal(ctx context.Context, proj *models.Project, expectedRevision string) projects.ProjectFileApplyOptions {
composeFileName := projects.DefaultComposeFileName
if composeFile, err := s.resolveProjectComposeFileInternal(ctx, proj); err == nil {
composeFileName = filepath.Base(composeFile)
}
- if err := projects.ApplyProjectFileChanges(proj.Path, fileChanges, projects.ProjectFileApplyOptions{
- ExpectedRevision: strings.TrimSpace(*fileTreeRevision),
+ return projects.ProjectFileApplyOptions{
+ ExpectedRevision: strings.TrimSpace(expectedRevision),
MaxDepth: s.config.ProjectFileTreeMaxDepth,
SkipDirectories: s.config.ProjectScanSkipDirs,
ComposeFileName: composeFileName,
- }); err != nil {
- return wrapProjectFileErrorInternal(err)
}
- return nil
}
// wrapProjectFileErrorInternal maps pkg/projects sentinel errors onto the
@@ -3150,11 +3500,14 @@ func (s *ProjectService) restoreProjectDirectoryBackupInternal(ctx context.Conte
return nil
}
-func (s *ProjectService) withProjectRenameRollback(ctx context.Context, proj *models.Project, run func() error) error {
+func (s *ProjectService) withProjectRenameRollback(ctx context.Context, proj *models.Project, projectStateCommitted *bool, run func() error) error {
originalPath := proj.Path
originalDirName := proj.DirName
if err := run(); err != nil {
+ if projectStateCommitted != nil && *projectStateCommitted {
+ return err
+ }
if proj.Path != originalPath {
if renameErr := os.Rename(proj.Path, originalPath); renameErr != nil {
slog.WarnContext(ctx, "failed to rollback project directory rename", "from", proj.Path, "to", originalPath, "error", renameErr)
@@ -3656,6 +4009,33 @@ func (s *ProjectService) persistGitSyncEnvFilesInternal(projectPath, projectsDir
return nil
}
+func (s *ProjectService) ensureProjectStoppedForRenameInternal(ctx context.Context, proj *models.Project, name *string) error {
+ if !isProjectRenameRequestedInternal(proj, name) {
+ return nil
+ }
+ if proj.Status != models.ProjectStatusStopped && proj.Status != models.ProjectStatusUnknown {
+ return fmt.Errorf("project must be stopped before renaming (current status: %s)", proj.Status)
+ }
+
+ services, err := s.GetProjectServices(ctx, proj.ID)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to resolve project status before rename", "projectID", proj.ID, "error", err)
+ return fmt.Errorf("project must be stopped before renaming (current status: %s): failed to verify live status: %w", proj.Status, err)
+ }
+
+ status := s.calculateProjectStatus(services)
+ if status != models.ProjectStatusStopped {
+ return fmt.Errorf("project must be stopped before renaming (current status: %s)", status)
+ }
+
+ serviceCount, runningCount := s.getServiceCounts(services)
+ proj.Status = models.ProjectStatusStopped
+ proj.StatusReason = nil
+ proj.ServiceCount = serviceCount
+ proj.RunningCount = runningCount
+ return nil
+}
+
func (s *ProjectService) applyProjectRenameIfNeeded(proj *models.Project, name *string, projectsDirectory string) error {
if name == nil {
return nil
@@ -4612,3 +4992,455 @@ func (s *ProjectService) calculateProjectStatus(services []ProjectServiceInfo) m
}
return models.ProjectStatusUnknown
}
+
+const (
+ projectRenameJournalKeyPrefixInternal = "project_rename_journal:"
+ projectRenameRollbackCleanupKeyPrefixInternal = "project_rename_rollback_cleanup:"
+
+ projectRenameJournalPhaseStartedInternal = "started"
+ projectRenameJournalPhaseTargetsCopiedInternal = "targets_copied"
+ projectRenameJournalPhaseOldVolumesRemovedInternal = "old_volumes_removed"
+ projectRenameJournalPhaseProjectStateCommittedInternal = "project_state_committed"
+ projectRenameJournalPhaseSourceCleanupPendingInternal = "source_cleanup_pending"
+ projectRenameJournalPhaseProjectStateRolledBackInternal = "project_state_rolled_back"
+)
+
+type projectRenameJournalInternal struct {
+ ProjectID string `json:"projectId"`
+ OldName string `json:"oldName"`
+ NewName string `json:"newName"`
+ OldPath string `json:"oldPath"`
+ NewPath string `json:"newPath"`
+ OldDirName *string `json:"oldDirName,omitempty"`
+ NewDirName string `json:"newDirName"`
+ Phase string `json:"phase"`
+ Volumes []volumes.JournalVolume `json:"volumes,omitempty"`
+ UpdatedAt time.Time `json:"updatedAt"`
+}
+
+type projectRenameRollbackCleanupInternal struct {
+ ProjectID string `json:"projectId"`
+ OldName string `json:"oldName"`
+ OldPath string `json:"oldPath"`
+ NewName string `json:"newName"`
+ NewPath string `json:"newPath"`
+ Volumes []volumes.JournalVolume `json:"volumes,omitempty"`
+ UpdatedAt time.Time `json:"updatedAt"`
+}
+
+func projectRenameJournalKeyInternal(projectID string) string {
+ return projectRenameJournalKeyPrefixInternal + strings.TrimSpace(projectID)
+}
+
+func projectRenameRollbackCleanupKeyInternal(projectID string) string {
+ return projectRenameRollbackCleanupKeyPrefixInternal + strings.TrimSpace(projectID)
+}
+
+func (s *ProjectService) prepareProjectRenameJournalInternal(proj *models.Project, name *string, projectsDirectory string, migration volumes.Migration) *projectRenameJournalInternal {
+ if s == nil || s.kvService == nil || proj == nil || name == nil {
+ return nil
+ }
+
+ newName := strings.TrimSpace(*name)
+ if newName == "" || proj.Name == newName {
+ return nil
+ }
+
+ newDirName := strings.TrimSpace(projects.SanitizeProjectName(newName))
+ if newDirName == "" || strings.Trim(newDirName, "_") == "" {
+ return nil
+ }
+
+ journal := &projectRenameJournalInternal{
+ ProjectID: proj.ID,
+ OldName: proj.Name,
+ NewName: newName,
+ OldPath: filepath.Clean(proj.Path),
+ NewPath: filepath.Clean(filepath.Join(projectsDirectory, newDirName)),
+ OldDirName: cloneStringPtrInternal(proj.DirName),
+ NewDirName: newDirName,
+ Phase: projectRenameJournalPhaseStartedInternal,
+ }
+
+ if source, ok := migration.(volumes.JournalSource); ok {
+ journal.Volumes = source.JournalVolumes()
+ }
+
+ return journal
+}
+
+func (s *ProjectService) writeProjectRenameJournalInternal(ctx context.Context, journal *projectRenameJournalInternal, phase string) error {
+ if s == nil || s.kvService == nil || journal == nil {
+ return nil
+ }
+ journal.Phase = phase
+ journal.UpdatedAt = time.Now().UTC()
+
+ payload, err := json.Marshal(journal)
+ if err != nil {
+ return fmt.Errorf("marshal project rename journal: %w", err)
+ }
+
+ if err := s.kvService.Set(ctx, projectRenameJournalKeyInternal(journal.ProjectID), string(payload)); err != nil {
+ return fmt.Errorf("write project rename journal: %w", err)
+ }
+ return nil
+}
+
+func (s *ProjectService) clearProjectRenameJournalInternal(ctx context.Context, projectID string) error {
+ if s == nil || s.kvService == nil || strings.TrimSpace(projectID) == "" {
+ return nil
+ }
+ return s.kvService.Delete(ctx, projectRenameJournalKeyInternal(projectID))
+}
+
+func (s *ProjectService) writeProjectRenameRollbackCleanupInternal(ctx context.Context, journal *projectRenameJournalInternal) error {
+ if s == nil || s.kvService == nil || journal == nil || strings.TrimSpace(journal.ProjectID) == "" || len(journal.Volumes) == 0 {
+ return nil
+ }
+
+ cleanup := projectRenameRollbackCleanupInternal{
+ ProjectID: journal.ProjectID,
+ OldName: journal.OldName,
+ OldPath: filepath.Clean(journal.OldPath),
+ NewName: journal.NewName,
+ NewPath: filepath.Clean(journal.NewPath),
+ Volumes: journal.Volumes,
+ UpdatedAt: time.Now().UTC(),
+ }
+ payload, err := json.Marshal(cleanup)
+ if err != nil {
+ return fmt.Errorf("marshal project rename rollback cleanup: %w", err)
+ }
+ if err := s.kvService.Set(ctx, projectRenameRollbackCleanupKeyInternal(journal.ProjectID), string(payload)); err != nil {
+ return fmt.Errorf("write project rename rollback cleanup: %w", err)
+ }
+ return nil
+}
+
+func (s *ProjectService) clearProjectRenameRollbackCleanupInternal(ctx context.Context, projectID string) error {
+ if s == nil || s.kvService == nil || strings.TrimSpace(projectID) == "" {
+ return nil
+ }
+ return s.kvService.Delete(ctx, projectRenameRollbackCleanupKeyInternal(projectID))
+}
+
+func projectRenameJournalTargetsCopiedInternal(phase string) bool {
+ switch phase {
+ case projectRenameJournalPhaseTargetsCopiedInternal,
+ projectRenameJournalPhaseOldVolumesRemovedInternal,
+ projectRenameJournalPhaseProjectStateCommittedInternal,
+ projectRenameJournalPhaseSourceCleanupPendingInternal:
+ return true
+ default:
+ return false
+ }
+}
+
+func projectRenameJournalFilesystemSyncPendingInternal(phase string) bool {
+ switch phase {
+ case projectRenameJournalPhaseStartedInternal,
+ projectRenameJournalPhaseTargetsCopiedInternal:
+ return true
+ default:
+ return false
+ }
+}
+
+func (s *ProjectService) RecoverProjectRenameJournals(ctx context.Context) error {
+ if s == nil || s.kvService == nil {
+ return nil
+ }
+
+ entries, err := s.kvService.ListByPrefix(ctx, projectRenameJournalKeyPrefixInternal)
+ if err != nil {
+ return err
+ }
+
+ var recoverErr error
+ for _, entry := range entries {
+ var journal projectRenameJournalInternal
+ if err := json.Unmarshal([]byte(entry.Value), &journal); err != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("decode project rename journal %s: %w", entry.Key, err))
+ continue
+ }
+ if err := s.recoverProjectRenameJournalInternal(ctx, &journal); err != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("recover project rename journal %s: %w", entry.Key, err))
+ continue
+ }
+ }
+ return errors.Join(recoverErr, s.recoverProjectRenameRollbackCleanupsInternal(ctx))
+}
+
+func (s *ProjectService) recoverProjectRenameJournalForProjectInternal(ctx context.Context, projectID string) error {
+ if s == nil || s.kvService == nil || strings.TrimSpace(projectID) == "" {
+ return nil
+ }
+
+ raw, ok, err := s.kvService.Get(ctx, projectRenameJournalKeyInternal(projectID))
+ if err != nil || !ok {
+ return err
+ }
+
+ var journal projectRenameJournalInternal
+ if err := json.Unmarshal([]byte(raw), &journal); err != nil {
+ return fmt.Errorf("decode project rename journal: %w", err)
+ }
+ return s.recoverProjectRenameJournalInternal(ctx, &journal)
+}
+
+func (s *ProjectService) recoverProjectRenameJournalInternal(ctx context.Context, journal *projectRenameJournalInternal) error {
+ if s == nil || journal == nil || strings.TrimSpace(journal.ProjectID) == "" {
+ return nil
+ }
+
+ var proj models.Project
+ dbErr := s.db.WithContext(ctx).First(&proj, "id = ?", journal.ProjectID).Error
+ if dbErr != nil && !errors.Is(dbErr, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("load project for rename recovery: %w", dbErr)
+ }
+
+ projectCommitted := dbErr == nil && (proj.Name == journal.NewName || filepath.Clean(proj.Path) == filepath.Clean(journal.NewPath))
+ if projectCommitted {
+ if journal.Phase == projectRenameJournalPhaseSourceCleanupPendingInternal {
+ if err := s.cleanupProjectRenameJournalSourcesInternal(ctx, journal); err != nil {
+ return err
+ }
+ return s.clearProjectRenameJournalInternal(ctx, journal.ProjectID)
+ }
+ if err := s.cleanupProjectRenameJournalSourcesInternal(ctx, journal); err != nil {
+ var cleanupErr *volumes.SourceCleanupError
+ if errors.As(err, &cleanupErr) {
+ if writeErr := s.writeProjectRenameJournalInternal(ctx, journal, projectRenameJournalPhaseSourceCleanupPendingInternal); writeErr != nil {
+ return errors.Join(err, writeErr)
+ }
+ }
+ return err
+ }
+ return s.clearProjectRenameJournalInternal(ctx, journal.ProjectID)
+ }
+
+ if err := s.rollbackProjectRenameJournalInternal(ctx, journal); err != nil {
+ return err
+ }
+ if err := s.writeProjectRenameJournalInternal(ctx, journal, projectRenameJournalPhaseProjectStateRolledBackInternal); err != nil {
+ return err
+ }
+ return s.clearProjectRenameJournalInternal(ctx, journal.ProjectID)
+}
+
+func (s *ProjectService) cleanupProjectRenameJournalSourcesInternal(ctx context.Context, journal *projectRenameJournalInternal) error {
+ dockerClient, err := s.projectRenameRecoveryDockerInternal(ctx, len(journal.Volumes) > 0)
+ if err != nil {
+ return err
+ }
+
+ if err := volumes.EnsureTargetsReadyForCleanup(ctx, dockerClient, journal.Volumes); err != nil {
+ var missingWithSource *volumes.TargetMissingWithSourceError
+ if errors.As(err, &missingWithSource) {
+ slog.WarnContext(ctx, "rolling back project rename because target volume is missing and source volume remains", "projectID", journal.ProjectID, "sourceVolume", missingWithSource.SourceVolume, "targetVolume", missingWithSource.TargetVolume)
+ return s.rollbackProjectRenameJournalInternal(ctx, journal)
+ }
+ var externallyRemoved *volumes.VolumesExternallyRemovedError
+ if errors.As(err, &externallyRemoved) {
+ slog.WarnContext(ctx, "project rename cleanup found source and target volumes externally removed", "projectID", journal.ProjectID, "volumeCount", len(externallyRemoved.Volumes), "error", externallyRemoved)
+ } else {
+ return err
+ }
+ }
+
+ return volumes.RemoveSourceVolumes(ctx, dockerClient, journal.Volumes)
+}
+
+func (s *ProjectService) rollbackProjectRenameJournalInternal(ctx context.Context, journal *projectRenameJournalInternal) error {
+ directoryRollback, directoryErr := rollbackProjectRenameDirectoryInternal(journal)
+
+ volumeErr := s.rollbackProjectRenameJournalVolumesInternal(ctx, journal)
+
+ if err := s.db.WithContext(ctx).Model(&models.Project{}).
+ Where("id = ?", journal.ProjectID).
+ Updates(map[string]any{
+ "name": journal.OldName,
+ "path": journal.OldPath,
+ "dir_name": journal.OldDirName,
+ }).Error; err != nil {
+ return errors.Join(directoryErr, volumeErr, fmt.Errorf("restore project database state: %w", err))
+ }
+
+ if directoryErr != nil {
+ slog.WarnContext(ctx, "keeping project rename journal after restoring database state because directory rollback failed", "projectID", journal.ProjectID, "pathsMissing", directoryRollback.PathsMissing, "error", directoryErr)
+ }
+
+ if volumeErr != nil {
+ if volumes.OnlyPreservedTargetErrors(volumeErr) {
+ slog.WarnContext(ctx, "clearing project rename journal after preserving target volume data", "projectID", journal.ProjectID, "pathsMissing", directoryRollback.PathsMissing, "error", volumeErr)
+ } else {
+ if cleanupErr := s.writeProjectRenameRollbackCleanupInternal(ctx, journal); cleanupErr != nil {
+ return errors.Join(directoryErr, volumeErr, cleanupErr)
+ }
+ slog.WarnContext(ctx, "queued project rename target volume cleanup after restoring database state despite volume rollback failure", "projectID", journal.ProjectID, "pathsMissing", directoryRollback.PathsMissing, "error", volumeErr)
+ }
+ }
+
+ dockerutil.InvalidateVolumeUsageCache()
+ return directoryErr
+}
+
+func (s *ProjectService) recoverProjectRenameRollbackCleanupsInternal(ctx context.Context) error {
+ if s == nil || s.kvService == nil {
+ return nil
+ }
+
+ entries, err := s.kvService.ListByPrefix(ctx, projectRenameRollbackCleanupKeyPrefixInternal)
+ if err != nil {
+ return err
+ }
+
+ var recoverErr error
+ for _, entry := range entries {
+ var cleanup projectRenameRollbackCleanupInternal
+ if err := json.Unmarshal([]byte(entry.Value), &cleanup); err != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("decode project rename rollback cleanup %s: %w", entry.Key, err))
+ continue
+ }
+ if err := s.recoverProjectRenameRollbackCleanupInternal(ctx, &cleanup); err != nil {
+ recoverErr = errors.Join(recoverErr, fmt.Errorf("recover project rename rollback cleanup %s: %w", entry.Key, err))
+ continue
+ }
+ }
+ return recoverErr
+}
+
+func (s *ProjectService) recoverProjectRenameRollbackCleanupInternal(ctx context.Context, cleanup *projectRenameRollbackCleanupInternal) error {
+ if s == nil || cleanup == nil || strings.TrimSpace(cleanup.ProjectID) == "" {
+ return nil
+ }
+ if len(cleanup.Volumes) == 0 {
+ return s.clearProjectRenameRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ }
+
+ var proj models.Project
+ dbErr := s.db.WithContext(ctx).First(&proj, "id = ?", cleanup.ProjectID).Error
+ if dbErr != nil {
+ if errors.Is(dbErr, gorm.ErrRecordNotFound) {
+ slog.WarnContext(ctx, "clearing project rename rollback cleanup because project no longer exists", "projectID", cleanup.ProjectID)
+ return s.clearProjectRenameRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ }
+ return fmt.Errorf("load project for rename rollback cleanup: %w", dbErr)
+ }
+
+ if proj.Name != cleanup.OldName || filepath.Clean(proj.Path) != filepath.Clean(cleanup.OldPath) {
+ slog.WarnContext(ctx, "clearing project rename rollback cleanup because project state changed", "projectID", cleanup.ProjectID, "projectName", proj.Name, "projectPath", proj.Path)
+ return s.clearProjectRenameRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ }
+
+ dockerClient, err := s.projectRenameRecoveryDockerInternal(ctx, len(cleanup.Volumes) > 0)
+ if err != nil {
+ return err
+ }
+
+ if err := volumes.CleanupRollbackTargetVolumes(ctx, dockerClient, cleanup.Volumes); err != nil {
+ if volumes.OnlyPreservedTargetErrors(err) {
+ slog.WarnContext(ctx, "clearing project rename rollback cleanup after preserving target volume data", "projectID", cleanup.ProjectID, "error", err)
+ return s.clearProjectRenameRollbackCleanupInternal(ctx, cleanup.ProjectID)
+ }
+ return err
+ }
+
+ dockerutil.InvalidateVolumeUsageCache()
+ return s.clearProjectRenameRollbackCleanupInternal(ctx, cleanup.ProjectID)
+}
+
+func (s *ProjectService) rollbackProjectRenameJournalVolumesInternal(ctx context.Context, journal *projectRenameJournalInternal) error {
+ if !projectRenameJournalTargetsCopiedInternal(journal.Phase) {
+ return nil
+ }
+
+ dockerClient, err := s.projectRenameRecoveryDockerInternal(ctx, len(journal.Volumes) > 0)
+ if err != nil {
+ return err
+ }
+
+ return volumes.RollbackVolumes(ctx, dockerClient, journal.Volumes)
+}
+
+func (s *ProjectService) projectRenameRecoveryDockerInternal(ctx context.Context, dockerRequired bool) (*client.Client, error) {
+ if !dockerRequired {
+ return nil, nil
+ }
+ if s.dockerService == nil {
+ return nil, errors.New("docker service unavailable")
+ }
+
+ dockerClient, err := s.dockerService.GetClient(ctx)
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ return dockerClient, nil
+}
+
+type projectRenameDirectoryRollbackInternal struct {
+ PathsMissing bool
+}
+
+func rollbackProjectRenameDirectoryInternal(journal *projectRenameJournalInternal) (projectRenameDirectoryRollbackInternal, error) {
+ var result projectRenameDirectoryRollbackInternal
+ oldPath := filepath.Clean(journal.OldPath)
+ newPath := filepath.Clean(journal.NewPath)
+ if oldPath == "" || newPath == "" || oldPath == newPath {
+ return result, nil
+ }
+
+ oldExists := pathExistsInternal(oldPath)
+ newExists := pathExistsInternal(newPath)
+ switch {
+ case oldExists && newExists:
+ conflictPath, err := relocateProjectRenameConflictDirectoryInternal(newPath)
+ if err != nil {
+ slog.Warn("project rename directory rollback found both paths and failed to relocate target path; keeping old path and clearing journal", "oldPath", oldPath, "newPath", newPath, "error", err)
+ } else {
+ slog.Warn("project rename directory rollback found both paths; moved target path aside and kept old path", "oldPath", oldPath, "newPath", newPath, "conflictPath", conflictPath)
+ }
+ case !oldExists && newExists:
+ if err := os.Rename(newPath, oldPath); err != nil {
+ return result, fmt.Errorf("rollback project directory rename: %w", err)
+ }
+ case !oldExists && !newExists:
+ result.PathsMissing = true
+ slog.Warn("project rename directory paths are missing during rollback", "oldPath", oldPath, "newPath", newPath)
+ }
+ return result, nil
+}
+
+func relocateProjectRenameConflictDirectoryInternal(path string) (string, error) {
+ parent := filepath.Dir(path)
+ base := filepath.Base(path)
+ now := time.Now().UTC().UnixNano()
+ for attempt := range 10 {
+ conflictPath := filepath.Join(parent, fmt.Sprintf(".%s.rename-conflict-%d-%d", base, now, attempt))
+ if _, err := os.Stat(conflictPath); err == nil {
+ continue
+ } else if !os.IsNotExist(err) {
+ return "", fmt.Errorf("check conflict path: %w", err)
+ }
+ if err := os.Rename(path, conflictPath); err != nil {
+ return "", fmt.Errorf("relocate project rename target path: %w", err)
+ }
+ return conflictPath, nil
+ }
+ return "", fmt.Errorf("relocate project rename target path: no available conflict path for %s", path)
+}
+
+func pathExistsInternal(path string) bool {
+ _, err := os.Stat(path)
+ return err == nil
+}
+
+func cloneStringPtrInternal(value *string) *string {
+ if value == nil {
+ return nil
+ }
+ cloned := *value
+ return &cloned
+}
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index 95357e599..423bec424 100644
--- a/backend/internal/services/project_service_test.go
+++ b/backend/internal/services/project_service_test.go
@@ -15,6 +15,7 @@ import (
"path/filepath"
"runtime"
"strings"
+ "sync/atomic"
"testing"
"time"
@@ -22,6 +23,7 @@ import (
composeapi "github.com/docker/compose/v5/pkg/api"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumes"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/iconcatalog"
@@ -32,6 +34,7 @@ import (
glsqlite "github.com/glebarez/sqlite"
"github.com/moby/moby/api/types/container"
dockertypesimage "github.com/moby/moby/api/types/image"
+ "github.com/moby/moby/api/types/volume"
"github.com/opencontainers/go-digest"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -1134,7 +1137,31 @@ func TestProjectService_UpdateProjectServicesForcesRecreateInternal(t *testing.T
assert.True(t, forceRecreate, "service updates must force recreate after pulling the updated image")
}
-func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing.T) {
+type fakeProjectVolumeRenameMigrationInternal struct {
+ applyCalled bool
+ commitCalled bool
+ rollbackCalled bool
+ applyErr error
+ commitErr error
+ rollbackErr error
+}
+
+func (m *fakeProjectVolumeRenameMigrationInternal) Apply(context.Context) error {
+ m.applyCalled = true
+ return m.applyErr
+}
+
+func (m *fakeProjectVolumeRenameMigrationInternal) Rollback(context.Context) error {
+ m.rollbackCalled = true
+ return m.rollbackErr
+}
+
+func (m *fakeProjectVolumeRenameMigrationInternal) Commit(context.Context) error {
+ m.commitCalled = true
+ return m.commitErr
+}
+
+func TestProjectService_UpdateProject_RenameFailsWhenVolumeMigrationPreparationFails(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1143,16 +1170,44 @@ func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := NewEventService(db, nil, nil)
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/_ping"):
+ _, _ = io.WriteString(w, "OK")
+ case strings.HasSuffix(r.URL.Path, "/version"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]string{
+ "ApiVersion": "1.41",
+ "MinAPIVersion": "1.24",
+ "Version": "24.0.0",
+ }))
+ case strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/bar_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{
+ "Name": "bar_data",
+ }))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(dockerServer.Close)
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, dockerServer.URL))
+
+ dockerService := &DockerClientService{client: newTestDockerClient(t, dockerServer)}
+ svc := NewProjectService(db, settingsService, eventService, nil, dockerService, nil, config.Load())
originalDirName := "Foo"
- originalPath := filepath.Join(projectsDir, originalDirName)
- require.NoError(t, os.MkdirAll(originalPath, 0o755))
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
+ require.NoError(t, os.WriteFile(filepath.Join(originalPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n driver: local\n"), 0o644))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-1"},
+ BaseModel: models.BaseModel{ID: "proj-volume-conflict"},
Name: "Foo",
DirName: &originalDirName,
Path: originalPath,
@@ -1160,29 +1215,22 @@ func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing
}
require.NoError(t, db.Create(project).Error)
- updated, err := svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
+ _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
- require.NoError(t, err)
-
- expectedPath := filepath.Join(projectsDir, "bar")
- assert.Equal(t, "bar", updated.Name)
- assert.Equal(t, expectedPath, updated.Path)
- require.NotNil(t, updated.DirName)
- assert.Equal(t, "bar", *updated.DirName)
- assert.NoDirExists(t, originalPath)
- assert.DirExists(t, expectedPath)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "target volume already exists")
+ assert.DirExists(t, originalPath)
+ assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))
var fromDB models.Project
require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
- assert.Equal(t, "bar", fromDB.Name)
- assert.Equal(t, expectedPath, fromDB.Path)
- require.NotNil(t, fromDB.DirName)
- assert.Equal(t, "bar", *fromDB.DirName)
+ assert.Equal(t, "Foo", fromDB.Name)
+ assert.Equal(t, originalPath, fromDB.Path)
}
-func TestProjectService_UpdateProject_RenameFailsWhenTargetDirectoryExists(t *testing.T) {
+func TestProjectService_ApplyProjectUpdateWithRenameJournal_AppliesVolumeMigrationWhenNameChanges(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1195,15 +1243,13 @@ func TestProjectService_UpdateProject_RenameFailsWhenTargetDirectoryExists(t *te
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- originalDirName := "Foo"
- originalPath := filepath.Join(projectsDir, originalDirName)
- require.NoError(t, os.MkdirAll(originalPath, 0o755))
+ migration := &fakeProjectVolumeRenameMigrationInternal{}
- targetPath := filepath.Join(projectsDir, "bar")
- require.NoError(t, os.MkdirAll(targetPath, 0o755))
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-2"},
+ BaseModel: models.BaseModel{ID: "proj-volume-success"},
Name: "Foo",
DirName: &originalDirName,
Path: originalPath,
@@ -1211,24 +1257,142 @@ func TestProjectService_UpdateProject_RenameFailsWhenTargetDirectoryExists(t *te
}
require.NoError(t, db.Create(project).Error)
- _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.Error(t, err)
- assert.Contains(t, err.Error(), "project directory already exists")
- assert.DirExists(t, originalPath)
- assert.DirExists(t, targetPath)
+ projectForUpdate := *project
+ journalActive := false
+ projectStateCommitted := false
+ err = svc.applyProjectUpdateWithRenameJournalInternal(ctx, &projectForUpdate, new("bar"), projectsDir, nil, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
+ require.NoError(t, err)
+
+ assert.True(t, migration.applyCalled)
+ assert.True(t, migration.commitCalled)
+ assert.False(t, migration.rollbackCalled)
+ assert.True(t, projectStateCommitted)
+ assert.Equal(t, "bar", projectForUpdate.Name)
+ assert.DirExists(t, filepath.Join(projectsDir, "bar"))
+ assert.NoDirExists(t, originalPath)
var fromDB models.Project
require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
- assert.Equal(t, "Foo", fromDB.Name)
- assert.Equal(t, originalPath, fromDB.Path)
- require.NotNil(t, fromDB.DirName)
- assert.Equal(t, "Foo", *fromDB.DirName)
+ assert.Equal(t, "bar", fromDB.Name)
+ assert.Equal(t, filepath.Join(projectsDir, "bar"), fromDB.Path)
}
-func TestProjectService_UpdateProject_RenameFailsWhenProjectRunning(t *testing.T) {
+func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesComposePreview(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.NotFound(w, r)
+ case strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{
+ "Name": "nginx_data",
+ "Driver": "local",
+ "Labels": map[string]string{
+ composeapi.ProjectLabel: "nginx",
+ composeapi.VolumeLabel: "data",
+ },
+ }))
+ case strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(dockerServer.Close)
+
+ dockerService := &DockerClientService{client: newTestDockerClient(t, dockerServer)}
+ svc := NewProjectService(db, settingsService, nil, nil, dockerService, nil, config.Load())
+
+ projectPath := filepath.Join(projectsDir, "nginx")
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ oldCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n driver: local\n"
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(oldCompose), 0o644))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-preview-volume-rename"},
+ Name: "nginx",
+ DirName: ptr("nginx"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+
+ t.Run("skips volume made explicit in pending compose", func(t *testing.T) {
+ newCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n name: fixed-data\n"
+
+ migration, err := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil, nil)
+
+ require.NoError(t, err)
+ require.Nil(t, migration)
+ bytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
+ require.NoError(t, readErr)
+ require.Equal(t, oldCompose, string(bytes))
+ require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ })
+
+ t.Run("plans unchanged auto-managed volume from pending compose", func(t *testing.T) {
+ newCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n driver: local\n"
+
+ migration, err := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil, nil)
+
+ require.NoError(t, err)
+ require.NotNil(t, migration)
+ journalSource, ok := migration.(volumes.JournalSource)
+ require.True(t, ok)
+ volumes := journalSource.JournalVolumes()
+ require.Len(t, volumes, 1)
+ require.Equal(t, "data", volumes[0].Key)
+ require.Equal(t, "nginx_data", volumes[0].OldName)
+ require.Equal(t, "web_data", volumes[0].NewName)
+ require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ })
+
+ t.Run("plans auto-managed volume when pending compose name renames project", func(t *testing.T) {
+ newCompose := "name: web\nservices:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n driver: local\n"
+
+ migration, err := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil, nil)
+
+ require.NoError(t, err)
+ require.NotNil(t, migration)
+ journalSource, ok := migration.(volumes.JournalSource)
+ require.True(t, ok)
+ volumes := journalSource.JournalVolumes()
+ require.Len(t, volumes, 1)
+ require.Equal(t, "data", volumes[0].Key)
+ require.Equal(t, "nginx_data", volumes[0].OldName)
+ require.Equal(t, "web_data", volumes[0].NewName)
+ require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ })
+
+ t.Run("plans interpolated explicit name from pending compose", func(t *testing.T) {
+ newCompose := "services:\n app:\n image: nginx:alpine\n volumes:\n - data:/data\nvolumes:\n data:\n name: ${DATA_VOLUME:-nginx_data}\n"
+
+ migration, err := svc.prepareProjectRenameVolumeMigrationForUpdateInternal(ctx, project, new("web"), projectsDir, &newCompose, nil, nil, nil)
+
+ require.NoError(t, err)
+ require.NotNil(t, migration)
+ journalSource, ok := migration.(volumes.JournalSource)
+ require.True(t, ok)
+ volumes := journalSource.JournalVolumes()
+ require.Len(t, volumes, 1)
+ require.Equal(t, "data", volumes[0].Key)
+ require.Equal(t, "nginx_data", volumes[0].OldName)
+ require.Equal(t, "web_data", volumes[0].NewName)
+ require.Empty(t, projectUpdatePreviewDirsInternal(t, projectsDir))
+ })
+}
+
+func TestProjectService_ApplyProjectUpdateWithRenameJournal_RollsBackVolumeMigrationWhenProjectSaveFails(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1241,37 +1405,43 @@ func TestProjectService_UpdateProject_RenameFailsWhenProjectRunning(t *testing.T
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ migration := &fakeProjectVolumeRenameMigrationInternal{}
+
+ require.NoError(t, db.Callback().Update().Before("gorm:update").Register("arcane_test_project_save_failure", func(tx *gorm.DB) {
+ if tx.Statement != nil && tx.Statement.Schema != nil && tx.Statement.Schema.Name == "Project" {
+ tx.AddError(errors.New("forced project save failure"))
+ }
+ }))
+
originalDirName := "Foo"
- originalPath := filepath.Join(projectsDir, originalDirName)
- require.NoError(t, os.MkdirAll(originalPath, 0o755))
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-3"},
+ BaseModel: models.BaseModel{ID: "proj-volume-save-fail"},
Name: "Foo",
DirName: &originalDirName,
Path: originalPath,
- Status: models.ProjectStatusRunning,
+ Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
+ projectForUpdate := *project
+ journalActive := false
+ projectStateCommitted := false
+ err = svc.withProjectRenameRollback(ctx, &projectForUpdate, &projectStateCommitted, func() error {
+ return svc.applyProjectUpdateWithRenameJournalInternal(ctx, &projectForUpdate, new("bar"), projectsDir, nil, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
})
require.Error(t, err)
- assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
+ assert.Contains(t, err.Error(), "forced project save failure")
+ assert.True(t, migration.applyCalled)
+ assert.False(t, migration.commitCalled)
+ assert.True(t, migration.rollbackCalled)
+ assert.False(t, projectStateCommitted)
assert.DirExists(t, originalPath)
assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))
-
- var fromDB models.Project
- require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
- assert.Equal(t, "Foo", fromDB.Name)
- assert.Equal(t, originalPath, fromDB.Path)
- require.NotNil(t, fromDB.DirName)
- assert.Equal(t, "Foo", *fromDB.DirName)
}
-func TestProjectService_UpdateProject_ValidatesComposeUsingExistingProjectName(t *testing.T) {
+func TestProjectService_ApplyProjectUpdateWithRenameJournal_SucceedsCommittedRenameWhenSourceCleanupFails(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1284,37 +1454,45 @@ func TestProjectService_UpdateProject_ValidatesComposeUsingExistingProjectName(t
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "demo"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ migration := &fakeProjectVolumeRenameMigrationInternal{
+ commitErr: errors.New("source cleanup failed"),
+ }
+
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-compose-name"},
- Name: "demo",
- DirName: &dirName,
- Path: projectPath,
+ BaseModel: models.BaseModel{ID: "proj-volume-cleanup-fail"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- compose := `name: ${COMPOSE_PROJECT_NAME}
-services:
- app:
- image: nginx:alpine
-`
- env := "COMPOSE_PROJECT_NAME=\n"
-
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
+ projectForUpdate := *project
+ journalActive := false
+ projectStateCommitted := false
+ err = svc.withProjectRenameRollback(ctx, &projectForUpdate, &projectStateCommitted, func() error {
+ return svc.applyProjectUpdateWithRenameJournalInternal(ctx, &projectForUpdate, new("bar"), projectsDir, nil, nil, nil, nil, migration, nil, &journalActive, &projectStateCommitted)
})
require.NoError(t, err)
- require.NotNil(t, updated)
- assert.Equal(t, "demo", updated.Name)
+ require.True(t, migration.applyCalled)
+ require.True(t, migration.commitCalled)
+ require.False(t, migration.rollbackCalled)
+ require.True(t, projectStateCommitted)
+ require.NoDirExists(t, originalPath)
+ require.DirExists(t, filepath.Join(projectsDir, "bar"))
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "bar", fromDB.Name)
+ require.Equal(t, filepath.Join(projectsDir, "bar"), fromDB.Path)
}
-func TestProjectService_UpdateProject_AllowsMissingEnvFileDuringComposeValidation(t *testing.T) {
+func TestProjectService_UpdateProject_ClearsJournalForNonRenameWhenRecoveryDockerUnavailable(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
projectsDir := t.TempDir()
@@ -1322,43 +1500,64 @@ func TestProjectService_UpdateProject_AllowsMissingEnvFileDuringComposeValidatio
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := NewEventService(db, nil, nil)
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
-
- dirName := "env-required"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load()).WithKVService(kvService)
+ oldDir := "nginx"
+ projectPath := createComposeProjectDir(t, projectsDir, oldDir)
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-env-file"},
- Name: "env-required",
- DirName: &dirName,
+ BaseModel: models.BaseModel{ID: "proj-non-rename-recovery-docker-unavailable"},
+ Name: "nginx",
+ DirName: &oldDir,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- compose := `services:
- app:
- image: nginx:alpine
- env_file:
- - .env
-`
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: projectPath,
+ NewPath: filepath.Join(projectsDir, "web"),
+ OldDirName: &oldDir,
+ NewDirName: "web",
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ envContent := "FOO=bar\n"
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, &envContent, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
- require.NotNil(t, updated)
+ require.Equal(t, "nginx", updated.Name)
- _, statErr := os.Stat(filepath.Join(projectPath, ".env"))
- require.NoError(t, statErr)
+ envBytes, err := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, err)
+ require.Equal(t, envContent, string(envBytes))
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
}
-func TestProjectService_UpdateProject_AllowsMissingLocalIncludeDuringComposeValidation(t *testing.T) {
+func TestProjectService_UpdateProject_AllowsRenameAfterJournalRecoveryDockerUnavailable(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
projectsDir := t.TempDir()
@@ -1366,62 +1565,60 @@ func TestProjectService_UpdateProject_AllowsMissingLocalIncludeDuringComposeVali
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := NewEventService(db, nil, nil)
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
-
- dirName := "include-new"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load()).WithKVService(kvService)
+ oldDir := "nginx"
+ projectPath := createComposeProjectDir(t, projectsDir, oldDir)
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-missing-include"},
- Name: "include-new",
- DirName: &dirName,
+ BaseModel: models.BaseModel{ID: "proj-rename-recovery-docker-unavailable"},
+ Name: "nginx",
+ DirName: &oldDir,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- compose := `include:
- - metadata.yaml
-services:
- app:
- image: nginx:alpine
-`
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: projectPath,
+ NewPath: filepath.Join(projectsDir, "web"),
+ OldDirName: &oldDir,
+ NewDirName: "web",
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- updated, err := svc.UpdateProject(ctx, project.ID, nil, ptr(compose), nil, nil, nil, models.User{
+ updated, err := svc.UpdateProject(ctx, project.ID, ptr("web"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
require.NotNil(t, updated)
+ require.Equal(t, "web", updated.Name)
+ require.NoDirExists(t, projectPath)
+ require.DirExists(t, filepath.Join(projectsDir, "web"))
- includePath := filepath.Join(projectPath, "metadata.yaml")
- assert.NoFileExists(t, includePath)
-
- details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
- require.NoError(t, err)
- require.Len(t, details.IncludeFiles, 1)
- assert.Equal(t, "metadata.yaml", details.IncludeFiles[0].RelativePath)
-
- includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "metadata.yaml")
- require.NoError(t, err)
- assert.Equal(t, "metadata.yaml", includeFile.RelativePath)
- assert.Contains(t, includeFile.Content, "This file will be created when you save changes")
-
- includeContent := "services: {}\n"
- require.NoError(t, svc.UpdateProjectIncludeFile(ctx, project.ID, "metadata.yaml", includeContent, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- }))
-
- writtenContent, err := os.ReadFile(includePath)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Equal(t, includeContent, string(writtenContent))
+ require.False(t, ok)
}
-func TestProjectService_UpdateProject_RejectsMissingExternalIncludeDuringComposeValidation(t *testing.T) {
+func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1433,39 +1630,43 @@ func TestProjectService_UpdateProject_RejectsMissingExternalIncludeDuringCompose
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ configureProjectRuntimeDockerInternal(t, nil)
- dirName := "include-external"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-external-include"},
- Name: "include-external",
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
-
- compose := `include:
- - ../metadata.yaml
-services:
- app:
- image: nginx:alpine
-`
+ BaseModel: models.BaseModel{ID: "proj-1"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- updated, err := svc.UpdateProject(ctx, project.ID, nil, ptr(compose), nil, nil, nil, models.User{
+ updated, err := svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
- require.Error(t, err)
- assert.Nil(t, updated)
- assert.Contains(t, err.Error(), "invalid compose file")
- assert.NoFileExists(t, filepath.Join(projectsDir, "metadata.yaml"))
- assert.NoFileExists(t, filepath.Join(projectPath, "compose.yaml"))
+ require.NoError(t, err)
+
+ expectedPath := filepath.Join(projectsDir, "bar")
+ assert.Equal(t, "bar", updated.Name)
+ assert.Equal(t, expectedPath, updated.Path)
+ require.NotNil(t, updated.DirName)
+ assert.Equal(t, "bar", *updated.DirName)
+ assert.NoDirExists(t, originalPath)
+ assert.DirExists(t, expectedPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ assert.Equal(t, "bar", fromDB.Name)
+ assert.Equal(t, expectedPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ assert.Equal(t, "bar", *fromDB.DirName)
}
-func TestProjectService_CreateProject_RejectsExternalInclude(t *testing.T) {
+func TestProjectService_UpdateProject_RenameFailsWhenTargetDirectoryExists(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1477,31 +1678,41 @@ func TestProjectService_CreateProject_RejectsExternalInclude(t *testing.T) {
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))
+ configureProjectRuntimeDockerInternal(t, nil)
- compose := `include:
- - ../metadata.yaml
-services:
- app:
- image: nginx:alpine
-`
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
- project, err := svc.CreateProject(ctx, "evil", compose, nil, nil, models.User{
+ targetPath := filepath.Join(projectsDir, "bar")
+ require.NoError(t, os.MkdirAll(targetPath, 0o755))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-2"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.Error(t, err)
- assert.Nil(t, project)
- assert.Contains(t, err.Error(), "invalid compose file")
- assert.NoDirExists(t, filepath.Join(projectsDir, "evil"))
- assert.FileExists(t, filepath.Join(projectsDir, "metadata.yaml"))
+ assert.Contains(t, err.Error(), "project directory already exists")
+ assert.DirExists(t, originalPath)
+ assert.DirExists(t, targetPath)
- var count int64
- require.NoError(t, db.Model(&models.Project{}).Where("name = ?", "evil").Count(&count).Error)
- assert.Zero(t, count)
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ assert.Equal(t, "Foo", fromDB.Name)
+ assert.Equal(t, originalPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ assert.Equal(t, "Foo", *fromDB.DirName)
}
-func TestProjectService_CreateProject_RejectsArrayPathInclude(t *testing.T) {
+func TestProjectService_UpdateProject_RenameFailsWhenProjectRunning(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1513,33 +1724,38 @@ func TestProjectService_CreateProject_RejectsArrayPathInclude(t *testing.T) {
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))
- compose := `include:
- - path:
- - ./local.yaml
- - ../metadata.yaml
-services:
- app:
- image: nginx:alpine
-`
+ originalDirName := "Foo"
+ originalPath := filepath.Join(projectsDir, originalDirName)
+ require.NoError(t, os.MkdirAll(originalPath, 0o755))
- project, err := svc.CreateProject(ctx, "evil-array", compose, nil, nil, models.User{
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-3"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusRunning,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.Error(t, err)
- assert.Nil(t, project)
- assert.Contains(t, err.Error(), "invalid compose file")
- assert.NoDirExists(t, filepath.Join(projectsDir, "evil-array"))
- assert.FileExists(t, filepath.Join(projectsDir, "metadata.yaml"))
+ assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
+ assert.DirExists(t, originalPath)
+ assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))
- var count int64
- require.NoError(t, db.Model(&models.Project{}).Where("name = ?", "evil-array").Count(&count).Error)
- assert.Zero(t, count)
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ assert.Equal(t, "Foo", fromDB.Name)
+ assert.Equal(t, originalPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ assert.Equal(t, "Foo", *fromDB.DirName)
}
-func TestProjectService_CreateProject_WritesStagedProjectFiles(t *testing.T) {
+func TestProjectService_UpdateProject_RenameRejectsStaleStoppedWhenRuntimeIsRunning(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1548,95 +1764,112 @@ func TestProjectService_CreateProject_WritesStagedProjectFiles(t *testing.T) {
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ configureProjectRuntimeDockerInternal(t, []container.Summary{
+ {
+ ID: "app-container",
+ Names: []string{"/foo-app-1"},
+ Image: "nginx:alpine",
+ State: container.StateRunning,
+ Status: "Up 30 seconds",
+ Labels: map[string]string{
+ composeapi.ProjectLabel: "foo",
+ composeapi.ServiceLabel: "app",
+ composeapi.ConfigHashLabel: "app-hash",
+ composeapi.WorkingDirLabel: filepath.Join(projectsDir, "Foo"),
+ },
+ },
+ })
- includeContent := "services: {}\n"
- compose := `include:
- - config/app.yaml
-services:
- app:
- image: nginx:alpine
-`
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
- project, err := svc.CreateProject(ctx, "with-files", compose, nil, []projecttypes.ProjectFileDraft{
- {RelativePath: "config", IsDirectory: true},
- {RelativePath: "config/app.yaml", Content: includeContent},
- {RelativePath: "README.md", Content: "hello\n"},
- }, models.User{
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-stale-stopped-running-rename"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
- require.NoError(t, err)
- require.NotNil(t, project)
-
- assert.FileExists(t, filepath.Join(project.Path, "compose.yaml"))
- assert.FileExists(t, filepath.Join(project.Path, ".env"))
- assert.FileExists(t, filepath.Join(project.Path, "config", "app.yaml"))
- assert.FileExists(t, filepath.Join(project.Path, "README.md"))
-
- details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeProjectFiles: true})
- require.NoError(t, err)
- assert.NotEmpty(t, details.FileTreeRevision)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
+ assert.DirExists(t, originalPath)
+ assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))
- relativePaths := make([]string, 0, len(details.ProjectFiles))
- for _, file := range details.ProjectFiles {
- relativePaths = append(relativePaths, file.RelativePath)
- }
- assert.Contains(t, relativePaths, "config")
- assert.Contains(t, relativePaths, filepath.ToSlash(filepath.Join("config", "app.yaml")))
- assert.Contains(t, relativePaths, "README.md")
- assert.NotContains(t, relativePaths, "compose.yaml")
- assert.NotContains(t, relativePaths, ".env")
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ assert.Equal(t, "Foo", fromDB.Name)
+ assert.Equal(t, originalPath, fromDB.Path)
+ assert.Equal(t, models.ProjectStatusStopped, fromDB.Status)
}
-func TestProjectService_GetProjectDetails_UsesFileTreeMaxDepthForProjectFiles(t *testing.T) {
+func TestProjectService_UpdateProject_RenameResolvesUnknownStoppedStatusBeforeVolumeMigration(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- t.Setenv("PROJECT_SCAN_MAX_DEPTH", "3")
- t.Setenv("PROJECT_FILE_TREE_MAX_DEPTH", "8")
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := NewEventService(db, nil, nil)
- cfg := config.Load()
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, cfg)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- deepFolder := filepath.ToSlash(filepath.Join("level1", "level2", "level3", "level4", "level5"))
- project, err := svc.CreateProject(ctx, "deep-files", "services:\n app:\n image: nginx:alpine\n", nil, []projecttypes.ProjectFileDraft{
- {RelativePath: deepFolder, IsDirectory: true},
- }, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
+ server := newProjectRuntimeDockerServerInternal(t, nil)
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
- assert.DirExists(t, filepath.Join(project.Path, filepath.FromSlash(deepFolder)))
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
+ statusReason := "stale runtime status"
- filesAtScanDepth, _, err := projects.ReadProjectFileTree(project.Path, cfg.ProjectScanMaxDepth, cfg.ProjectScanSkipDirs, "compose.yaml")
- require.NoError(t, err)
- scanDepthRelativePaths := make([]string, 0, len(filesAtScanDepth))
- for _, file := range filesAtScanDepth {
- scanDepthRelativePaths = append(scanDepthRelativePaths, file.RelativePath)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-unknown-stopped-rename"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusUnknown,
+ StatusReason: &statusReason,
}
- assert.NotContains(t, scanDepthRelativePaths, deepFolder)
+ require.NoError(t, db.Create(project).Error)
- details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeProjectFiles: true})
+ updated, err := svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.NoError(t, err)
- fileTreeRelativePaths := make([]string, 0, len(details.ProjectFiles))
- for _, file := range details.ProjectFiles {
- fileTreeRelativePaths = append(fileTreeRelativePaths, file.RelativePath)
- }
- assert.Contains(t, fileTreeRelativePaths, deepFolder)
+ expectedPath := filepath.Join(projectsDir, "bar")
+ assert.Equal(t, "bar", updated.Name)
+ assert.Equal(t, expectedPath, updated.Path)
+ assert.Equal(t, models.ProjectStatusStopped, updated.Status)
+ assert.Nil(t, updated.StatusReason)
+ assert.Equal(t, 1, updated.ServiceCount)
+ assert.Equal(t, 0, updated.RunningCount)
+ assert.NoDirExists(t, originalPath)
+ assert.DirExists(t, expectedPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ assert.Equal(t, "bar", fromDB.Name)
+ assert.Equal(t, expectedPath, fromDB.Path)
+ assert.Equal(t, models.ProjectStatusStopped, fromDB.Status)
+ assert.Nil(t, fromDB.StatusReason)
+ assert.Equal(t, 1, fromDB.ServiceCount)
+ assert.Equal(t, 0, fromDB.RunningCount)
}
-func TestProjectService_UpdateProject_AppliesStagedProjectFileChanges(t *testing.T) {
+func TestProjectService_UpdateProject_RenameRejectsUnknownWhenRuntimeIsRunning(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1645,40 +1878,61 @@ func TestProjectService_UpdateProject_AppliesStagedProjectFileChanges(t *testing
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- project, err := svc.CreateProject(ctx, "editable-files", "services:\n app:\n image: nginx:alpine\n", nil, nil, models.User{
+ server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
+ {
+ ID: "app-container",
+ Names: []string{"/foo-app-1"},
+ Image: "nginx:alpine",
+ State: container.StateRunning,
+ Status: "Up 30 seconds",
+ Labels: map[string]string{
+ composeapi.ProjectLabel: "foo",
+ composeapi.ServiceLabel: "app",
+ composeapi.ConfigHashLabel: "app-hash",
+ composeapi.WorkingDirLabel: "/host/path/projects/Foo",
+ },
+ },
+ })
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
+ statusReason := "stale runtime status"
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-unknown-running-rename"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusUnknown,
+ StatusReason: &statusReason,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ _, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
- require.NoError(t, err)
-
- _, revision, err := projects.ReadProjectFileTree(project.Path, config.Load().ProjectScanMaxDepth, config.Load().ProjectScanSkipDirs, "compose.yaml")
- require.NoError(t, err)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
+ assert.DirExists(t, originalPath)
+ assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))
- updated := "updated\n"
- _, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, &revision, []projecttypes.ProjectFileChange{
- {Operation: "create_folder", RelativePath: "config"},
- {Operation: "create_folder", RelativePath: "archive"},
- {Operation: "create_file", RelativePath: "config/app.yaml", Content: new("hello\n")},
- {Operation: "update_file", RelativePath: "config/app.yaml", Content: &updated},
- {Operation: "rename", RelativePath: "config/app.yaml", NewName: "renamed.yaml"},
- {Operation: "move", RelativePath: "config/renamed.yaml", NewParentPath: "archive"},
- }, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
-
- bytes, err := os.ReadFile(filepath.Join(project.Path, "archive", "renamed.yaml"))
- require.NoError(t, err)
- assert.Equal(t, updated, string(bytes))
- assert.NoFileExists(t, filepath.Join(project.Path, "config", "renamed.yaml"))
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ assert.Equal(t, "Foo", fromDB.Name)
+ assert.Equal(t, originalPath, fromDB.Path)
+ assert.Equal(t, models.ProjectStatusUnknown, fromDB.Status)
+ require.NotNil(t, fromDB.StatusReason)
+ assert.Equal(t, statusReason, *fromDB.StatusReason)
}
-func TestProjectService_UpdateProject_RejectsStaleProjectFileRevision(t *testing.T) {
+func TestProjectService_UpdateProject_ValidatesComposeUsingExistingProjectName(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1691,72 +1945,36 @@ func TestProjectService_UpdateProject_RejectsStaleProjectFileRevision(t *testing
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- project, err := svc.CreateProject(ctx, "stale-files", "services:\n app:\n image: nginx:alpine\n", nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
-
- _, revision, err := projects.ReadProjectFileTree(project.Path, config.Load().ProjectScanMaxDepth, config.Load().ProjectScanSkipDirs, "compose.yaml")
- require.NoError(t, err)
- require.NoError(t, os.WriteFile(filepath.Join(project.Path, "external.txt"), []byte("external\n"), 0o644))
-
- _, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, &revision, []projecttypes.ProjectFileChange{
- {Operation: "create_file", RelativePath: "notes.txt", Content: new("new\n")},
- }, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.Error(t, err)
-
- var conflictErr *common.ProjectFileConflictError
- assert.ErrorAs(t, err, &conflictErr)
- assert.NoFileExists(t, filepath.Join(project.Path, "notes.txt"))
-}
-
-func TestProjectService_UpdateProject_RejectsStaleDeepProjectFileRevision(t *testing.T) {
- db := setupProjectTestDB(t)
- ctx := context.Background()
-
- projectsDir := t.TempDir()
- t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- t.Setenv("PROJECT_SCAN_MAX_DEPTH", "3")
- t.Setenv("PROJECT_FILE_TREE_MAX_DEPTH", "8")
+ dirName := "demo"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-compose-name"},
+ Name: "demo",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- eventService := NewEventService(db, nil, nil)
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ compose := `name: ${COMPOSE_PROJECT_NAME}
+services:
+ app:
+ image: nginx:alpine
+`
+ env := "COMPOSE_PROJECT_NAME=\n"
- project, err := svc.CreateProject(ctx, "stale-deep-files", "services:\n app:\n image: nginx:alpine\n", nil, nil, models.User{
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
-
- details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeProjectFiles: true})
- require.NoError(t, err)
- require.NotEmpty(t, details.FileTreeRevision)
-
- deepParent := filepath.Join(project.Path, "level1", "level2", "level3", "level4")
- require.NoError(t, os.MkdirAll(deepParent, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(deepParent, "external.txt"), []byte("external\n"), 0o644))
-
- _, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, &details.FileTreeRevision, []projecttypes.ProjectFileChange{
- {Operation: "create_file", RelativePath: "notes.txt", Content: new("new\n")},
- }, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.Error(t, err)
-
- var conflictErr *common.ProjectFileConflictError
- assert.ErrorAs(t, err, &conflictErr)
- assert.NoFileExists(t, filepath.Join(project.Path, "notes.txt"))
+ require.NotNil(t, updated)
+ assert.Equal(t, "demo", updated.Name)
}
-func TestProjectService_GetProjectFileContent_RejectsExternalInclude(t *testing.T) {
+func TestProjectService_UpdateProject_AllowsMissingEnvFileDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1769,37 +1987,38 @@ func TestProjectService_GetProjectFileContent_RejectsExternalInclude(t *testing.
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "include-read"
+ dirName := "env-required"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-external-include-read"},
- Name: "include-read",
+ BaseModel: models.BaseModel{ID: "proj-env-file"},
+ Name: "env-required",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- compose := `include:
- - ../metadata.yaml
-services:
+ compose := `services:
app:
image: nginx:alpine
+ env_file:
+ - .env
`
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))
- includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "../metadata.yaml")
- require.Error(t, err)
- assert.Empty(t, includeFile)
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
- var forbiddenErr *common.ProjectFileForbiddenError
- assert.ErrorAs(t, err, &forbiddenErr)
+ _, statErr := os.Stat(filepath.Join(projectPath, ".env"))
+ require.NoError(t, statErr)
}
-func TestProjectService_GetProjectFileContent_RejectsSymlinkInclude(t *testing.T) {
+func TestProjectService_UpdateProject_AllowsMissingLocalIncludeDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1812,17 +2031,13 @@ func TestProjectService_GetProjectFileContent_RejectsSymlinkInclude(t *testing.T
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "include-symlink"
+ dirName := "include-new"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- outsidePath := filepath.Join(t.TempDir(), "outside.yaml")
- require.NoError(t, os.WriteFile(outsidePath, []byte("services: {}\n"), 0o644))
- require.NoError(t, os.Symlink(outsidePath, filepath.Join(projectPath, "evil-link")))
-
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-symlink-include-read"},
- Name: "include-symlink",
+ BaseModel: models.BaseModel{ID: "proj-missing-include"},
+ Name: "include-new",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
@@ -1830,22 +2045,44 @@ func TestProjectService_GetProjectFileContent_RejectsSymlinkInclude(t *testing.T
require.NoError(t, db.Create(project).Error)
compose := `include:
- - ./evil-link
+ - metadata.yaml
services:
app:
image: nginx:alpine
`
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))
- includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "evil-link")
- require.Error(t, err)
- assert.Empty(t, includeFile)
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, ptr(compose), nil, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
- var forbiddenErr *common.ProjectFileForbiddenError
- assert.ErrorAs(t, err, &forbiddenErr)
+ includePath := filepath.Join(projectPath, "metadata.yaml")
+ assert.NoFileExists(t, includePath)
+
+ details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
+ require.NoError(t, err)
+ require.Len(t, details.IncludeFiles, 1)
+ assert.Equal(t, "metadata.yaml", details.IncludeFiles[0].RelativePath)
+
+ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "metadata.yaml")
+ require.NoError(t, err)
+ assert.Equal(t, "metadata.yaml", includeFile.RelativePath)
+ assert.Contains(t, includeFile.Content, "This file will be created when you save changes")
+
+ includeContent := "services: {}\n"
+ require.NoError(t, svc.UpdateProjectIncludeFile(ctx, project.ID, "metadata.yaml", includeContent, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ }))
+
+ writtenContent, err := os.ReadFile(includePath)
+ require.NoError(t, err)
+ assert.Equal(t, includeContent, string(writtenContent))
}
-func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkInclude(t *testing.T) {
+func TestProjectService_UpdateProject_RejectsMissingExternalIncludeDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1858,17 +2095,13 @@ func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkInclude(
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "include-intermediate-symlink"
+ dirName := "include-external"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- outsideDir := t.TempDir()
- require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "secret.yaml"), []byte("services: {}\n"), 0o644))
- require.NoError(t, os.Symlink(outsideDir, filepath.Join(projectPath, "subdir")))
-
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-intermediate-symlink-include-read"},
- Name: "include-intermediate-symlink",
+ BaseModel: models.BaseModel{ID: "proj-external-include"},
+ Name: "include-external",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
@@ -1876,22 +2109,24 @@ func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkInclude(
require.NoError(t, db.Create(project).Error)
compose := `include:
- - ./subdir/secret.yaml
+ - ../metadata.yaml
services:
app:
image: nginx:alpine
`
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))
- includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "subdir/secret.yaml")
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, ptr(compose), nil, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.Error(t, err)
- assert.Empty(t, includeFile)
-
- var forbiddenErr *common.ProjectFileForbiddenError
- assert.ErrorAs(t, err, &forbiddenErr)
+ assert.Nil(t, updated)
+ assert.Contains(t, err.Error(), "invalid compose file")
+ assert.NoFileExists(t, filepath.Join(projectsDir, "metadata.yaml"))
+ assert.NoFileExists(t, filepath.Join(projectPath, "compose.yaml"))
}
-func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkProjectFile(t *testing.T) {
+func TestProjectService_CreateProject_RejectsExternalInclude(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1903,34 +2138,31 @@ func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkProjectF
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))
- dirName := "project-file-intermediate-symlink"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services: {}\n"), 0o644))
-
- outsideDir := t.TempDir()
- require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "secret.yaml"), []byte("services: {}\n"), 0o644))
- require.NoError(t, os.Symlink(outsideDir, filepath.Join(projectPath, "subdir")))
-
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-intermediate-symlink-project-file-read"},
- Name: "project-file-intermediate-symlink",
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
+ compose := `include:
+ - ../metadata.yaml
+services:
+ app:
+ image: nginx:alpine
+`
- includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "subdir/secret.yaml")
+ project, err := svc.CreateProject(ctx, "evil", compose, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.Error(t, err)
- assert.Empty(t, includeFile)
+ assert.Nil(t, project)
+ assert.Contains(t, err.Error(), "invalid compose file")
+ assert.NoDirExists(t, filepath.Join(projectsDir, "evil"))
+ assert.FileExists(t, filepath.Join(projectsDir, "metadata.yaml"))
- var forbiddenErr *common.ProjectFileForbiddenError
- assert.ErrorAs(t, err, &forbiddenErr)
+ var count int64
+ require.NoError(t, db.Model(&models.Project{}).Where("name = ?", "evil").Count(&count).Error)
+ assert.Zero(t, count)
}
-func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation(t *testing.T) {
+func TestProjectService_CreateProject_RejectsArrayPathInclude(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1942,41 +2174,33 @@ func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))
- dirName := "env-existing"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("FOO=bar\n"), 0o600))
-
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-existing-env-file"},
- Name: "env-existing",
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
-
- compose := `services:
+ compose := `include:
+ - path:
+ - ./local.yaml
+ - ../metadata.yaml
+services:
app:
image: nginx:alpine
- env_file:
- - .env
`
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ project, err := svc.CreateProject(ctx, "evil-array", compose, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
- require.NoError(t, err)
- require.NotNil(t, updated)
+ require.Error(t, err)
+ assert.Nil(t, project)
+ assert.Contains(t, err.Error(), "invalid compose file")
+ assert.NoDirExists(t, filepath.Join(projectsDir, "evil-array"))
+ assert.FileExists(t, filepath.Join(projectsDir, "metadata.yaml"))
- envBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Equal(t, "FOO=bar\n", string(envBytes))
+ var count int64
+ require.NoError(t, db.Model(&models.Project{}).Where("name = ?", "evil-array").Count(&count).Error)
+ assert.Zero(t, count)
}
-func TestProjectService_UpdateProject_UsesProvidedEnvContentDuringComposeValidation(t *testing.T) {
+func TestProjectService_CreateProject_WritesStagedProjectFiles(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -1989,84 +2213,91 @@ func TestProjectService_UpdateProject_UsesProvidedEnvContentDuringComposeValidat
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "env-updated"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
-
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-new-env-file"},
- Name: "env-updated",
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
-
- compose := `services:
+ includeContent := "services: {}\n"
+ compose := `include:
+ - config/app.yaml
+services:
app:
image: nginx:alpine
- env_file:
- - .env
`
- env := "FOO=updated\n"
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, nil, models.User{
+ project, err := svc.CreateProject(ctx, "with-files", compose, nil, []projecttypes.ProjectFileDraft{
+ {RelativePath: "config", IsDirectory: true},
+ {RelativePath: "config/app.yaml", Content: includeContent},
+ {RelativePath: "README.md", Content: "hello\n"},
+ }, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
- require.NotNil(t, updated)
+ require.NotNil(t, project)
- envBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Equal(t, env, string(envBytes))
+ assert.FileExists(t, filepath.Join(project.Path, "compose.yaml"))
+ assert.FileExists(t, filepath.Join(project.Path, ".env"))
+ assert.FileExists(t, filepath.Join(project.Path, "config", "app.yaml"))
+ assert.FileExists(t, filepath.Join(project.Path, "README.md"))
+
+ details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeProjectFiles: true})
+ require.NoError(t, err)
+ assert.NotEmpty(t, details.FileTreeRevision)
+
+ relativePaths := make([]string, 0, len(details.ProjectFiles))
+ for _, file := range details.ProjectFiles {
+ relativePaths = append(relativePaths, file.RelativePath)
+ }
+ assert.Contains(t, relativePaths, "config")
+ assert.Contains(t, relativePaths, filepath.ToSlash(filepath.Join("config", "app.yaml")))
+ assert.Contains(t, relativePaths, "README.md")
+ assert.NotContains(t, relativePaths, "compose.yaml")
+ assert.NotContains(t, relativePaths, ".env")
}
-func TestProjectService_UpdateProject_ReturnsEnvParseErrorDuringComposeValidation(t *testing.T) {
+func TestProjectService_GetProjectDetails_UsesFileTreeMaxDepthForProjectFiles(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+ t.Setenv("PROJECT_SCAN_MAX_DEPTH", "3")
+ t.Setenv("PROJECT_FILE_TREE_MAX_DEPTH", "8")
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
eventService := NewEventService(db, nil, nil)
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ cfg := config.Load()
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, cfg)
- dirName := "env-invalid"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ deepFolder := filepath.ToSlash(filepath.Join("level1", "level2", "level3", "level4", "level5"))
+ project, err := svc.CreateProject(ctx, "deep-files", "services:\n app:\n image: nginx:alpine\n", nil, []projecttypes.ProjectFileDraft{
+ {RelativePath: deepFolder, IsDirectory: true},
+ }, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-invalid-env-file"},
- Name: "env-invalid",
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
+ assert.DirExists(t, filepath.Join(project.Path, filepath.FromSlash(deepFolder)))
+
+ filesAtScanDepth, _, err := projects.ReadProjectFileTree(project.Path, cfg.ProjectScanMaxDepth, cfg.ProjectScanSkipDirs, "compose.yaml")
+ require.NoError(t, err)
+ scanDepthRelativePaths := make([]string, 0, len(filesAtScanDepth))
+ for _, file := range filesAtScanDepth {
+ scanDepthRelativePaths = append(scanDepthRelativePaths, file.RelativePath)
}
- require.NoError(t, db.Create(project).Error)
+ assert.NotContains(t, scanDepthRelativePaths, deepFolder)
- compose := `services:
- app:
- image: nginx:alpine
- environment:
- - REQUIRED=${REQUIRED}
-`
- env := "BROKEN=${UNTERMINATED\n"
+ details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeProjectFiles: true})
+ require.NoError(t, err)
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.Error(t, err)
- assert.Nil(t, updated)
- assert.Contains(t, err.Error(), "invalid compose file: parse provided env content")
- assert.Contains(t, err.Error(), "parse env")
+ fileTreeRelativePaths := make([]string, 0, len(details.ProjectFiles))
+ for _, file := range details.ProjectFiles {
+ fileTreeRelativePaths = append(fileTreeRelativePaths, file.RelativePath)
+ }
+ assert.Contains(t, fileTreeRelativePaths, deepFolder)
}
-func TestProjectService_UpdateProject_UsesGlobalEnvDuringComposeValidation(t *testing.T) {
+func TestProjectService_UpdateProject_AppliesStagedProjectFileChanges(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2079,47 +2310,41 @@ func TestProjectService_UpdateProject_UsesGlobalEnvDuringComposeValidation(t *te
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "global-env-update"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=/srv/media\nMYPATH=/containers/\n"), 0o600))
-
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-global-env-update"},
- Name: dirName,
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
+ project, err := svc.CreateProject(ctx, "editable-files", "services:\n app:\n image: nginx:alpine\n", nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
- compose := `services:
- cats:
- image: mikesir87/cats:1.0
- volumes:
- - ${DATA_NAS_FOLDER}:/data
- - ${MYPATH}cats/templates:/app/templates
-`
+ _, revision, err := projects.ReadProjectFileTree(project.Path, config.Load().ProjectScanMaxDepth, config.Load().ProjectScanSkipDirs, "compose.yaml")
+ require.NoError(t, err)
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ updated := "updated\n"
+ _, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, &revision, []projecttypes.ProjectFileChange{
+ {Operation: "create_folder", RelativePath: "config"},
+ {Operation: "create_folder", RelativePath: "archive"},
+ {Operation: "create_file", RelativePath: "config/app.yaml", Content: new("hello\n")},
+ {Operation: "update_file", RelativePath: "config/app.yaml", Content: &updated},
+ {Operation: "rename", RelativePath: "config/app.yaml", NewName: "renamed.yaml"},
+ {Operation: "move", RelativePath: "config/renamed.yaml", NewParentPath: "archive"},
+ }, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
- require.NotNil(t, updated)
- composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
- require.NoError(t, readErr)
- assert.Equal(t, compose, string(composeBytes))
+ bytes, err := os.ReadFile(filepath.Join(project.Path, "archive", "renamed.yaml"))
+ require.NoError(t, err)
+ assert.Equal(t, updated, string(bytes))
+ assert.NoFileExists(t, filepath.Join(project.Path, "config", "renamed.yaml"))
}
-func TestProjectService_UpdateProject_DoesNotResolveHostEnvThroughGlobalEnvDuringComposeValidation(t *testing.T) {
+func TestProjectService_UpdateProject_RejectsStaleProjectFileRevision(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- t.Setenv("HOST_ONLY_PATH", "/host/secret")
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
@@ -2127,42 +2352,37 @@ func TestProjectService_UpdateProject_DoesNotResolveHostEnvThroughGlobalEnvDurin
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "host-env-guard"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=${HOST_ONLY_PATH}\n"), 0o600))
-
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-host-env-guard"},
- Name: dirName,
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
+ project, err := svc.CreateProject(ctx, "stale-files", "services:\n app:\n image: nginx:alpine\n", nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
- compose := `services:
- app:
- image: nginx:alpine
- volumes:
- - ${DATA_NAS_FOLDER}:/data
-`
+ _, revision, err := projects.ReadProjectFileTree(project.Path, config.Load().ProjectScanMaxDepth, config.Load().ProjectScanSkipDirs, "compose.yaml")
+ require.NoError(t, err)
+ require.NoError(t, os.WriteFile(filepath.Join(project.Path, "external.txt"), []byte("external\n"), 0o644))
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ _, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, &revision, []projecttypes.ProjectFileChange{
+ {Operation: "create_file", RelativePath: "notes.txt", Content: new("new\n")},
+ }, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.Error(t, err)
- assert.Nil(t, updated)
- assert.Contains(t, err.Error(), "invalid compose file")
+
+ var conflictErr *common.ProjectFileConflictError
+ assert.ErrorAs(t, err, &conflictErr)
+ assert.NoFileExists(t, filepath.Join(project.Path, "notes.txt"))
}
-func TestProjectService_UpdateProject_DerivesProjectOverrideEnvWhenGitSourceExists(t *testing.T) {
+func TestProjectService_UpdateProject_RejectsStaleDeepProjectFileRevision(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
projectsDir := t.TempDir()
t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+ t.Setenv("PROJECT_SCAN_MAX_DEPTH", "3")
+ t.Setenv("PROJECT_FILE_TREE_MAX_DEPTH", "8")
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
@@ -2170,40 +2390,34 @@ func TestProjectService_UpdateProject_DerivesProjectOverrideEnvWhenGitSourceExis
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "override-edit"
- projectPath := filepath.Join(projectsDir, dirName)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
-
- project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-override-edit"},
- Name: "override-edit",
- DirName: &dirName,
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }
- require.NoError(t, db.Create(project).Error)
-
- updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("BASE=git\nLOCAL_ONLY=example\n"), nil, nil, models.User{
+ project, err := svc.CreateProject(ctx, "stale-deep-files", "services:\n app:\n image: nginx:alpine\n", nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
- require.NotNil(t, updated)
- overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
- require.NoError(t, readErr)
- assert.Equal(t, "LOCAL_ONLY=example\n", string(overrideBytes))
+ details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeProjectFiles: true})
+ require.NoError(t, err)
+ require.NotEmpty(t, details.FileTreeRevision)
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Contains(t, string(effectiveBytes), "BASE=git\n")
- assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=example\n")
-}
+ deepParent := filepath.Join(project.Path, "level1", "level2", "level3", "level4")
+ require.NoError(t, os.MkdirAll(deepParent, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(deepParent, "external.txt"), []byte("external\n"), 0o644))
-func TestProjectService_UpdateProject_DeletingGitBackedKeyFallsBackToGit(t *testing.T) {
+ _, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, &details.FileTreeRevision, []projecttypes.ProjectFileChange{
+ {Operation: "create_file", RelativePath: "notes.txt", Content: new("new\n")},
+ }, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.Error(t, err)
+
+ var conflictErr *common.ProjectFileConflictError
+ assert.ErrorAs(t, err, &conflictErr)
+ assert.NoFileExists(t, filepath.Join(project.Path, "notes.txt"))
+}
+
+func TestProjectService_GetProjectFileContent_RejectsExternalInclude(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2216,43 +2430,37 @@ func TestProjectService_UpdateProject_DeletingGitBackedKeyFallsBackToGit(t *test
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "override-delete"
+ dirName := "include-read"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-override-delete"},
- Name: "override-delete",
+ BaseModel: models.BaseModel{ID: "proj-external-include-read"},
+ Name: "include-read",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("BASE=git\nLOCAL_ONLY=1\n"), nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
- require.NotNil(t, updated)
+ compose := `include:
+ - ../metadata.yaml
+services:
+ app:
+ image: nginx:alpine
+`
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))
- overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
- require.NoError(t, readErr)
- assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "../metadata.yaml")
+ require.Error(t, err)
+ assert.Empty(t, includeFile)
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Contains(t, string(effectiveBytes), "BASE=git\n")
- assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
- assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
- assert.NotContains(t, string(overrideBytes), "TOKEN=")
+ var forbiddenErr *common.ProjectFileForbiddenError
+ assert.ErrorAs(t, err, &forbiddenErr)
}
-func TestProjectService_ApplyGitSyncProjectFiles_MigratesDirectEnvIntoProjectOverride(t *testing.T) {
+func TestProjectService_GetProjectFileContent_RejectsSymlinkInclude(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2265,45 +2473,40 @@ func TestProjectService_ApplyGitSyncProjectFiles_MigratesDirectEnvIntoProjectOve
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "git-sync-migrate"
+ dirName := "include-symlink"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TOKEN=stale-local\nLOCAL_ONLY=1\n"), 0o600))
+
+ outsidePath := filepath.Join(t.TempDir(), "outside.yaml")
+ require.NoError(t, os.WriteFile(outsidePath, []byte("services: {}\n"), 0o644))
+ require.NoError(t, os.Symlink(outsidePath, filepath.Join(projectPath, "evil-link")))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-git-sync-migrate"},
- Name: "git-sync-migrate",
+ BaseModel: models.BaseModel{ID: "proj-symlink-include-read"},
+ Name: "include-symlink",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- gitEnv := "TOKEN=git\nREMOTE_ONLY=1\n"
- updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", &gitEnv, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
- require.NotNil(t, updated)
-
- gitSourceBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
- require.NoError(t, readErr)
- assert.Equal(t, gitEnv, string(gitSourceBytes))
+ compose := `include:
+ - ./evil-link
+services:
+ app:
+ image: nginx:alpine
+`
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))
- overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
- require.NoError(t, readErr)
- assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "evil-link")
+ require.Error(t, err)
+ assert.Empty(t, includeFile)
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
- assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
- assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
+ var forbiddenErr *common.ProjectFileForbiddenError
+ assert.ErrorAs(t, err, &forbiddenErr)
}
-func TestProjectService_ApplyGitSyncProjectFiles_NormalizesStaleCopiedGitOverrides(t *testing.T) {
+func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkInclude(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2316,42 +2519,40 @@ func TestProjectService_ApplyGitSyncProjectFiles_NormalizesStaleCopiedGitOverrid
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "git-sync-normalize"
+ dirName := "include-intermediate-symlink"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nSHARED=1\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
+
+ outsideDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "secret.yaml"), []byte("services: {}\n"), 0o644))
+ require.NoError(t, os.Symlink(outsideDir, filepath.Join(projectPath, "subdir")))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-git-sync-normalize"},
- Name: "git-sync-normalize",
+ BaseModel: models.BaseModel{ID: "proj-intermediate-symlink-include-read"},
+ Name: "include-intermediate-symlink",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", new("BASE=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"), models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
- require.NotNil(t, updated)
+ compose := `include:
+ - ./subdir/secret.yaml
+services:
+ app:
+ image: nginx:alpine
+`
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))
- overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
- require.NoError(t, readErr)
- assert.Equal(t, "TOKEN=local\n", string(overrideBytes))
+ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "subdir/secret.yaml")
+ require.Error(t, err)
+ assert.Empty(t, includeFile)
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Contains(t, string(effectiveBytes), "BASE=git-updated\n")
- assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
- assert.Contains(t, string(effectiveBytes), "TOKEN=local\n")
+ var forbiddenErr *common.ProjectFileForbiddenError
+ assert.ErrorAs(t, err, &forbiddenErr)
}
-func TestProjectService_ApplyGitSyncProjectFiles_RemovesLegacyDeletedGitMasks(t *testing.T) {
+func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkProjectFile(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2364,43 +2565,33 @@ func TestProjectService_ApplyGitSyncProjectFiles_RemovesLegacyDeletedGitMasks(t
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "git-sync-delete-mask"
+ dirName := "project-file-intermediate-symlink"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("TOKEN=git\nSHARED=1\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=\nLOCAL_ONLY=1\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("LOCAL_ONLY=1\nSHARED=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services: {}\n"), 0o644))
+
+ outsideDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "secret.yaml"), []byte("services: {}\n"), 0o644))
+ require.NoError(t, os.Symlink(outsideDir, filepath.Join(projectPath, "subdir")))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-git-sync-delete-mask"},
- Name: "git-sync-delete-mask",
+ BaseModel: models.BaseModel{ID: "proj-intermediate-symlink-project-file-read"},
+ Name: "project-file-intermediate-symlink",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", new("TOKEN=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"), models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
- require.NoError(t, err)
- require.NotNil(t, updated)
-
- overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
- require.NoError(t, readErr)
- assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "subdir/secret.yaml")
+ require.Error(t, err)
+ assert.Empty(t, includeFile)
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Contains(t, string(effectiveBytes), "TOKEN=git-updated\n")
- assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
- assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
- assert.NotContains(t, string(overrideBytes), "TOKEN=")
+ var forbiddenErr *common.ProjectFileForbiddenError
+ assert.ErrorAs(t, err, &forbiddenErr)
}
-func TestProjectService_ApplyGitSyncProjectFiles_RemovesGitEnvSource(t *testing.T) {
+func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2413,38 +2604,40 @@ func TestProjectService_ApplyGitSyncProjectFiles_RemovesGitEnvSource(t *testing.
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "git-sync-remove"
+ dirName := "env-existing"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("FOO=bar\n"), 0o600))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-git-sync-remove"},
- Name: "git-sync-remove",
+ BaseModel: models.BaseModel{ID: "proj-existing-env-file"},
+ Name: "env-existing",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", nil, models.User{
+ compose := `services:
+ app:
+ image: nginx:alpine
+ env_file:
+ - .env
+`
+
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
require.NotNil(t, updated)
- _, statErr := os.Stat(filepath.Join(projectPath, ".env.git"))
- assert.True(t, os.IsNotExist(statErr))
-
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ envBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
require.NoError(t, readErr)
- assert.Equal(t, "BASE=git\n", string(effectiveBytes))
+ assert.Equal(t, "FOO=bar\n", string(envBytes))
}
-func TestProjectService_ApplyGitSyncProjectFiles_UsesGlobalEnvDuringComposeValidation(t *testing.T) {
+func TestProjectService_UpdateProject_UsesProvidedEnvContentDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2457,14 +2650,13 @@ func TestProjectService_ApplyGitSyncProjectFiles_UsesGlobalEnvDuringComposeValid
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "git-sync-global-env"
+ dirName := "env-updated"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=/srv/media\nMYPATH=/containers/\n"), 0o600))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-git-sync-global-env"},
- Name: dirName,
+ BaseModel: models.BaseModel{ID: "proj-new-env-file"},
+ Name: "env-updated",
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
@@ -2472,26 +2664,26 @@ func TestProjectService_ApplyGitSyncProjectFiles_UsesGlobalEnvDuringComposeValid
require.NoError(t, db.Create(project).Error)
compose := `services:
- cats:
- image: mikesir87/cats:1.0
- volumes:
- - ${DATA_NAS_FOLDER}:/data
- - ${MYPATH}cats/templates:/app/templates
+ app:
+ image: nginx:alpine
+ env_file:
+ - .env
`
+ env := "FOO=updated\n"
- updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, compose, nil, models.User{
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, nil, models.User{
BaseModel: models.BaseModel{ID: "u1"},
Username: "tester",
})
require.NoError(t, err)
require.NotNil(t, updated)
- composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
+ envBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
require.NoError(t, readErr)
- assert.Equal(t, compose, string(composeBytes))
+ assert.Equal(t, env, string(envBytes))
}
-func TestProjectService_PersistGitSyncEnvFiles_UsesPreparedState(t *testing.T) {
+func TestProjectService_UpdateProject_ReturnsEnvParseErrorDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2504,32 +2696,38 @@ func TestProjectService_PersistGitSyncEnvFiles_UsesPreparedState(t *testing.T) {
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "git-sync-prepared-state"
+ dirName := "env-invalid"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\n"), 0o600))
-
- update, err := svc.prepareGitSyncEnvUpdateInternal(projectPath, new("BASE=git-updated\nTOKEN=git\nREMOTE=1\n"))
- require.NoError(t, err)
- require.NotNil(t, update.effectiveContent)
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=unexpected\n"), 0o600))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-invalid-env-file"},
+ Name: "env-invalid",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- require.NoError(t, svc.persistGitSyncEnvFilesInternal(projectPath, projectsDir, update))
-
- overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
- require.NoError(t, readErr)
- assert.Equal(t, "TOKEN=local\n", string(overrideBytes))
+ compose := `services:
+ app:
+ image: nginx:alpine
+ environment:
+ - REQUIRED=${REQUIRED}
+`
+ env := "BROKEN=${UNTERMINATED\n"
- effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
- require.NoError(t, readErr)
- assert.Equal(t, "BASE=git-updated\nREMOTE=1\nTOKEN=local\n", string(effectiveBytes))
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.Error(t, err)
+ assert.Nil(t, updated)
+ assert.Contains(t, err.Error(), "invalid compose file: parse provided env content")
+ assert.Contains(t, err.Error(), "parse env")
}
-func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.T) {
+func TestProjectService_UpdateProject_UsesGlobalEnvDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2542,120 +2740,85 @@ func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.
eventService := NewEventService(db, nil, nil)
svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- dirName := "details-override"
+ dirName := "global-env-update"
projectPath := filepath.Join(projectsDir, dirName)
require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=secret\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=secret\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=/srv/media\nMYPATH=/containers/\n"), 0o600))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-details-override"},
- Name: "details-override",
+ BaseModel: models.BaseModel{ID: "proj-global-env-update"},
+ Name: dirName,
DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
+ compose := `services:
+ cats:
+ image: mikesir87/cats:1.0
+ volumes:
+ - ${DATA_NAS_FOLDER}:/data
+ - ${MYPATH}cats/templates:/app/templates
+`
+
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.NoError(t, err)
- assert.Equal(t, "BASE=git\nTOKEN=secret\n", details.EnvContent)
+ require.NotNil(t, updated)
+
+ composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
+ require.NoError(t, readErr)
+ assert.Equal(t, compose, string(composeBytes))
}
-func TestBuildProjectUpdateInfoSummaryInternal(t *testing.T) {
- now := time.Now().UTC()
+func TestProjectService_UpdateProject_DoesNotResolveHostEnvThroughGlobalEnvDuringComposeValidation(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
- tests := []struct {
- name string
- imageRefs []string
- updates map[string]*imagetypes.UpdateInfo
- wantStatus string
- wantCount int
- wantChecked int
- wantErrors int
- wantUpdates int
- wantError string
- }{
- {
- name: "unknown when no checks exist",
- imageRefs: []string{"nginx:latest"},
- updates: nil,
- wantStatus: "unknown",
- wantCount: 1,
- wantChecked: 0,
- wantErrors: 0,
- wantUpdates: 0,
- },
- {
- name: "has update when any image has update",
- imageRefs: []string{"nginx:latest", "redis:7"},
- updates: map[string]*imagetypes.UpdateInfo{
- "nginx:latest": {HasUpdate: true, CheckTime: now},
- "redis:7": {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
- },
- wantStatus: "has_update",
- wantCount: 2,
- wantChecked: 2,
- wantErrors: 0,
- wantUpdates: 1,
- },
- {
- name: "error when no updates but a check failed",
- imageRefs: []string{"nginx:latest"},
- updates: map[string]*imagetypes.UpdateInfo{
- "nginx:latest": {HasUpdate: false, CheckTime: now, Error: "rate limited"},
- },
- wantStatus: "error",
- wantCount: 1,
- wantChecked: 1,
- wantErrors: 1,
- wantUpdates: 0,
- wantError: "rate limited",
- },
- {
- name: "up to date when all images checked without updates",
- imageRefs: []string{"nginx:latest", "redis:7"},
- updates: map[string]*imagetypes.UpdateInfo{
- "nginx:latest": {HasUpdate: false, CheckTime: now},
- "redis:7": {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
- },
- wantStatus: "up_to_date",
- wantCount: 2,
- wantChecked: 2,
- wantErrors: 0,
- wantUpdates: 0,
- },
- }
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+ t.Setenv("HOST_ONLY_PATH", "/host/secret")
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- summary := buildProjectUpdateInfoSummaryInternal(tt.imageRefs, tt.updates)
- require.NotNil(t, summary)
- assert.Equal(t, tt.wantStatus, summary.Status)
- assert.Equal(t, tt.wantCount, summary.ImageCount)
- assert.Equal(t, tt.wantChecked, summary.CheckedImageCount)
- assert.Equal(t, tt.wantErrors, summary.ErrorCount)
- assert.Equal(t, tt.wantUpdates, summary.ImagesWithUpdates)
- assert.Equal(t, tt.wantUpdates > 0, summary.HasUpdate)
- assert.Equal(t, tt.imageRefs, summary.ImageRefs)
- if tt.wantError != "" {
- require.NotNil(t, summary.ErrorMessage)
- assert.Equal(t, tt.wantError, *summary.ErrorMessage)
- } else {
- assert.Nil(t, summary.ErrorMessage)
- }
- if tt.wantUpdates > 0 {
- assert.Equal(t, []string{tt.imageRefs[0]}, summary.UpdatedImageRefs)
- } else {
- assert.Empty(t, summary.UpdatedImageRefs)
- }
- })
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+
+ dirName := "host-env-guard"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=${HOST_ONLY_PATH}\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-host-env-guard"},
+ Name: dirName,
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
}
+ require.NoError(t, db.Create(project).Error)
+
+ compose := `services:
+ app:
+ image: nginx:alpine
+ volumes:
+ - ${DATA_NAS_FOLDER}:/data
+`
+
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.Error(t, err)
+ assert.Nil(t, updated)
+ assert.Contains(t, err.Error(), "invalid compose file")
}
-func TestProjectService_GetProjectDetails_IncludesUpdateInfo(t *testing.T) {
+func TestProjectService_UpdateProject_DerivesProjectOverrideEnvWhenGitSourceExists(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2664,46 +2827,44 @@ func TestProjectService_GetProjectDetails_IncludesUpdateInfo(t *testing.T) {
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
- imageService := &ImageService{db: db}
- svc := NewProjectService(db, settingsService, nil, imageService, nil, nil, config.Load())
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- projectPath := createComposeProjectDir(t, projectsDir, "updates-demo")
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:latest\n"), 0o644))
+ dirName := "override-edit"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
- projectRecord := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-update-info"},
- Name: "updates-demo",
- DirName: ptr("updates-demo"),
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-override-edit"},
+ Name: "override-edit",
+ DirName: &dirName,
Path: projectPath,
Status: models.ProjectStatusStopped,
}
- require.NoError(t, db.Create(projectRecord).Error)
-
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:update-demo",
- Repository: "docker.io/library/nginx",
- Tag: "latest",
- HasUpdate: true,
- UpdateType: "digest",
- CurrentVersion: "latest",
- CheckTime: time.Now().UTC(),
- }).Error)
+ require.NoError(t, db.Create(project).Error)
- details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.AllDetails())
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("BASE=git\nLOCAL_ONLY=example\n"), nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.NoError(t, err)
- require.NotNil(t, details.UpdateInfo)
- assert.Equal(t, "has_update", details.UpdateInfo.Status)
- assert.True(t, details.UpdateInfo.HasUpdate)
- assert.Equal(t, 1, details.UpdateInfo.ImageCount)
- assert.Equal(t, 1, details.UpdateInfo.CheckedImageCount)
- assert.Equal(t, 1, details.UpdateInfo.ImagesWithUpdates)
- assert.Equal(t, []string{"nginx:latest"}, details.UpdateInfo.ImageRefs)
- assert.Equal(t, []string{"nginx:latest"}, details.UpdateInfo.UpdatedImageRefs)
+ require.NotNil(t, updated)
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=example\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "BASE=git\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=example\n")
}
-func TestProjectService_GetProjectDetails_RefreshesRuntimeStatusWithoutRuntimeServices(t *testing.T) {
+func TestProjectService_UpdateProject_DeletingGitBackedKeyFallsBackToGit(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2712,71 +2873,47 @@ func TestProjectService_GetProjectDetails_RefreshesRuntimeStatusWithoutRuntimeSe
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
- projectPath := createComposeProjectDir(t, projectsDir, "projectA")
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n server:\n image: nginx:alpine\n worker:\n image: busybox:latest\n"), 0o644))
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
- {
- ID: "server-container",
- Names: []string{"/projecta-server-1"},
- Image: "nginx:alpine",
- State: container.StateRunning,
- Status: "Up 30 seconds (healthy)",
- Ports: []container.PortSummary{
- {
- IP: netip.MustParseAddr("0.0.0.0"),
- PrivatePort: 80,
- PublicPort: 8080,
- Type: "tcp",
- },
- },
- Labels: map[string]string{
- composeapi.ProjectLabel: "projecta",
- composeapi.ServiceLabel: "server",
- composeapi.ConfigHashLabel: "server-hash",
- composeapi.WorkingDirLabel: "/host/path/projects/projectA",
- },
- },
- {
- ID: "worker-container",
- Names: []string{"/projecta-worker-1"},
- Image: "busybox:latest",
- State: container.StateRunning,
- Status: "Up 30 seconds",
- Labels: map[string]string{
- composeapi.ProjectLabel: "projecta",
- composeapi.ServiceLabel: "worker",
- composeapi.ConfigHashLabel: "worker-hash",
- composeapi.WorkingDirLabel: "/host/path/projects/projectA",
- },
- },
- })
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ dirName := "override-delete"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
- projectRecord := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-runtime-refresh"},
- Name: "projectA",
- DirName: ptr("projectA"),
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- ServiceCount: 2,
- RunningCount: 0,
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-override-delete"},
+ Name: "override-delete",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
}
- require.NoError(t, db.Create(projectRecord).Error)
-
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, db.Create(project).Error)
- details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.DetailsOptions{})
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("BASE=git\nLOCAL_ONLY=1\n"), nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.NoError(t, err)
- assert.Equal(t, string(models.ProjectStatusRunning), details.Status)
- assert.Equal(t, 2, details.ServiceCount)
- assert.Equal(t, 2, details.RunningCount)
- assert.Empty(t, details.RuntimeServices)
+ require.NotNil(t, updated)
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "BASE=git\n")
+ assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
+ assert.NotContains(t, string(overrideBytes), "TOKEN=")
}
-func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(t *testing.T) {
+func TestProjectService_ApplyGitSyncProjectFiles_MigratesDirectEnvIntoProjectOverride(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2785,52 +2922,49 @@ func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
- projectPath := createComposeProjectDir(t, projectsDir, "projectA")
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n server:\n image: nginx:alpine\n"), 0o644))
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
- {
- ID: "server-container",
- Names: []string{"/projecta-server-1"},
- Image: "nginx:alpine",
- State: container.StateRunning,
- Status: "Up 30 seconds",
- Labels: map[string]string{
- composeapi.ProjectLabel: "projecta",
- composeapi.ServiceLabel: "server",
- composeapi.ConfigHashLabel: "server-hash",
- composeapi.WorkingDirLabel: "/host/path/projects/projectA",
- },
- },
- })
- t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+ dirName := "git-sync-migrate"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TOKEN=stale-local\nLOCAL_ONLY=1\n"), 0o600))
- projectRecord := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-runtime-services"},
- Name: "projectA",
- DirName: ptr("projectA"),
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- ServiceCount: 1,
- RunningCount: 0,
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-migrate"},
+ Name: "git-sync-migrate",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
}
- require.NoError(t, db.Create(projectRecord).Error)
-
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, db.Create(project).Error)
- details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.DetailsOptions{IncludeRuntimeServices: true})
+ gitEnv := "TOKEN=git\nREMOTE_ONLY=1\n"
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", &gitEnv, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.NoError(t, err)
- require.Len(t, details.RuntimeServices, 1)
- assert.Equal(t, string(models.ProjectStatusRunning), details.Status)
- assert.Equal(t, "server", details.RuntimeServices[0].Name)
- assert.Equal(t, "running", details.RuntimeServices[0].Status)
- assert.Equal(t, "server-container", details.RuntimeServices[0].ContainerID)
- assert.Equal(t, "projecta-server-1", details.RuntimeServices[0].ContainerName)
+ require.NotNil(t, updated)
+
+ gitSourceBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
+ require.NoError(t, readErr)
+ assert.Equal(t, gitEnv, string(gitSourceBytes))
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
+ assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
}
-func TestProjectService_ListProjects_FiltersByUpdateStatus(t *testing.T) {
+func TestProjectService_ApplyGitSyncProjectFiles_NormalizesStaleCopiedGitOverrides(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
@@ -2839,1581 +2973,3890 @@ func TestProjectService_ListProjects_FiltersByUpdateStatus(t *testing.T) {
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
- imageService := &ImageService{db: db}
- svc := NewProjectService(db, settingsService, nil, imageService, nil, nil, config.Load())
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- updatedPath := createComposeProjectDir(t, projectsDir, "updated-demo")
- require.NoError(t, os.WriteFile(filepath.Join(updatedPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:latest\n"), 0o644))
- upToDatePath := createComposeProjectDir(t, projectsDir, "current-demo")
- require.NoError(t, os.WriteFile(filepath.Join(upToDatePath, "compose.yaml"), []byte("services:\n app:\n image: redis:7\n"), 0o644))
- errorPath := createComposeProjectDir(t, projectsDir, "error-demo")
- require.NoError(t, os.WriteFile(filepath.Join(errorPath, "compose.yaml"), []byte("services:\n app:\n image: busybox:latest\n"), 0o644))
- unknownPath := createComposeProjectDir(t, projectsDir, "unknown-demo")
- require.NoError(t, os.WriteFile(filepath.Join(unknownPath, "compose.yaml"), []byte("services:\n app:\n image: alpine:latest\n"), 0o644))
+ dirName := "git-sync-normalize"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nSHARED=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-updated"},
- Name: "updated-demo",
- DirName: ptr("updated-demo"),
- Path: updatedPath,
- Status: models.ProjectStatusStopped,
- }).Error)
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-current"},
- Name: "current-demo",
- DirName: ptr("current-demo"),
- Path: upToDatePath,
- Status: models.ProjectStatusStopped,
- }).Error)
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-error"},
- Name: "error-demo",
- DirName: ptr("error-demo"),
- Path: errorPath,
- Status: models.ProjectStatusStopped,
- }).Error)
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-unknown"},
- Name: "unknown-demo",
- DirName: ptr("unknown-demo"),
- Path: unknownPath,
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-normalize"},
+ Name: "git-sync-normalize",
+ DirName: &dirName,
+ Path: projectPath,
Status: models.ProjectStatusStopped,
- }).Error)
-
- now := time.Now().UTC()
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:updated-image",
- Repository: "docker.io/library/nginx",
- Tag: "latest",
- HasUpdate: true,
- UpdateType: "digest",
- CurrentVersion: "latest",
- CheckTime: now,
- }).Error)
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:current-image",
- Repository: "docker.io/library/redis",
- Tag: "7",
- HasUpdate: false,
- UpdateType: "tag",
- CurrentVersion: "7",
- CheckTime: now.Add(-time.Minute),
- }).Error)
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:error-image",
- Repository: "docker.io/library/busybox",
- Tag: "latest",
- HasUpdate: false,
- UpdateType: "error",
- CurrentVersion: "latest",
- CheckTime: now.Add(-2 * time.Minute),
- LastError: ptr("registry timeout"),
- }).Error)
-
- tests := []struct {
- name string
- filter string
- expected []string
- }{
- {name: "has update", filter: "has_update", expected: []string{"updated-demo"}},
- {name: "up to date", filter: "up_to_date", expected: []string{"current-demo"}},
- {name: "error", filter: "error", expected: []string{"error-demo"}},
- {name: "unknown", filter: "unknown", expected: []string{"unknown-demo"}},
}
+ require.NoError(t, db.Create(project).Error)
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
- Filters: map[string]string{
- "updates": tt.filter,
- },
- Params: pagination.Params{Limit: -1},
- SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
- })
- require.NoError(t, err)
- require.EqualValues(t, len(tt.expected), page.TotalItems)
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", new("BASE=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"), models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
- names := make([]string, 0, len(items))
- for _, item := range items {
- names = append(names, item.Name)
- }
- assert.Equal(t, tt.expected, names)
- })
- }
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "TOKEN=local\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "BASE=git-updated\n")
+ assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
+ assert.Contains(t, string(effectiveBytes), "TOKEN=local\n")
}
-func TestBuildDiscoveredComposeProjectUpdateRowsInternal(t *testing.T) {
+func TestProjectService_ApplyGitSyncProjectFiles_RemovesLegacyDeletedGitMasks(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
- imageService := &ImageService{db: db}
- now := time.Now().UTC()
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:media-image",
- Repository: "docker.io/library/nginx",
- Tag: "latest",
- HasUpdate: true,
- UpdateType: models.UpdateTypeDigest,
- CurrentVersion: "latest",
- CheckTime: now,
- }).Error)
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:known-image",
- Repository: "docker.io/library/redis",
- Tag: "7",
- HasUpdate: true,
- UpdateType: models.UpdateTypeDigest,
- CurrentVersion: "7",
- CheckTime: now,
- }).Error)
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
- rows := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, []container.Summary{
- {
- ID: "media-web",
- Names: []string{"/media-web-1"},
- Image: "nginx:latest",
- ImageID: "sha256:media-image",
- State: "running",
- Labels: map[string]string{
- "com.docker.compose.project": "media",
- "com.docker.compose.service": "web",
- },
- },
- {
- ID: "known-cache",
- Image: "redis:7",
- ImageID: "sha256:known-image",
- State: "running",
- Labels: map[string]string{
- "com.docker.compose.project": "known",
- "com.docker.compose.service": "cache",
- },
- },
- {
- ID: "plain-container",
- Image: "busybox:latest",
- ImageID: "sha256:plain-image",
- State: "running",
- Labels: map[string]string{},
- },
- }, map[string]struct{}{"known": {}}, imageService, iconcatalog.DefaultCatalog)
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
- require.Len(t, rows, 1)
- row := rows[0]
- assert.Equal(t, "compose:media", row.ID)
- assert.Equal(t, "media", row.Name)
- assert.True(t, row.IsDiscovered)
- assert.Equal(t, string(models.ProjectStatusRunning), row.Status)
- require.NotNil(t, row.UpdateInfo)
- assert.True(t, row.UpdateInfo.HasUpdate)
- assert.Equal(t, []string{"nginx:latest"}, row.UpdateInfo.UpdatedImageRefs)
- require.Len(t, row.RuntimeServices, 1)
- assert.Equal(t, "web", row.RuntimeServices[0].Name)
-}
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
-func TestBuildDiscoveredComposeProjectUpdateRowsInternal_FallsBackToImageID(t *testing.T) {
- db := setupProjectTestDB(t)
- ctx := context.Background()
- imageService := &ImageService{db: db}
+ dirName := "git-sync-delete-mask"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("TOKEN=git\nSHARED=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=\nLOCAL_ONLY=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("LOCAL_ONLY=1\nSHARED=1\n"), 0o600))
- require.NoError(t, db.Create(&models.ImageUpdateRecord{
- ID: "sha256:media-image",
- Repository: "registry.example.test/custom/media",
- Tag: "latest",
- HasUpdate: true,
- UpdateType: models.UpdateTypeDigest,
- CurrentVersion: "latest",
- CheckTime: time.Now().UTC(),
- }).Error)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-delete-mask"},
+ Name: "git-sync-delete-mask",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- rows := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, []container.Summary{
- {
- ID: "media-web",
- Image: "nginx:latest",
- ImageID: "sha256:media-image",
- State: "running",
- Labels: map[string]string{
- "com.docker.compose.project": "media",
- "com.docker.compose.service": "web",
- },
- },
- }, map[string]struct{}{}, imageService, iconcatalog.DefaultCatalog)
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", new("TOKEN=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"), models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
- require.Len(t, rows, 1)
- assert.Equal(t, []string{"nginx:latest"}, rows[0].UpdateInfo.UpdatedImageRefs)
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "TOKEN=git-updated\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
+ assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
+ assert.NotContains(t, string(overrideBytes), "TOKEN=")
}
-func TestProjectService_ListProjects_FiltersArchivedProjects(t *testing.T) {
+func TestProjectService_ApplyGitSyncProjectFiles_RemovesGitEnvSource(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- projectsRoot := t.TempDir()
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- activePath := createComposeProjectDir(t, projectsRoot, "active-demo")
- archivedPath := createComposeProjectDir(t, projectsRoot, "archived-demo")
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-active"},
- Name: "active-demo",
- DirName: ptr("active-demo"),
- Path: activePath,
- Status: models.ProjectStatusStopped,
- }).Error)
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-archived"},
- Name: "archived-demo",
- DirName: ptr("archived-demo"),
- Path: archivedPath,
- Status: models.ProjectStatusStopped,
- IsArchived: true,
- ArchivedAt: new(time.Now().UTC()),
- }).Error)
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ dirName := "git-sync-remove"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
- items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
- Params: pagination.Params{Limit: -1},
- SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
- })
- require.NoError(t, err)
- require.EqualValues(t, 1, page.TotalItems)
- require.Len(t, items, 1)
- assert.Equal(t, "active-demo", items[0].Name)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-remove"},
+ Name: "git-sync-remove",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- items, page, err = svc.ListProjects(ctx, pagination.QueryParams{
- Filters: map[string]string{"archived": "true"},
- Params: pagination.Params{Limit: -1},
- SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
})
require.NoError(t, err)
- require.EqualValues(t, 1, page.TotalItems)
- require.Len(t, items, 1)
- assert.Equal(t, "archived-demo", items[0].Name)
- assert.True(t, items[0].IsArchived)
+ require.NotNil(t, updated)
- items, page, err = svc.ListProjects(ctx, pagination.QueryParams{
- Filters: map[string]string{"archived": "all"},
- Params: pagination.Params{Limit: -1},
- SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
- })
- require.NoError(t, err)
- require.EqualValues(t, 2, page.TotalItems)
- require.Len(t, items, 2)
- assert.Equal(t, []string{"active-demo", "archived-demo"}, []string{items[0].Name, items[1].Name})
+ _, statErr := os.Stat(filepath.Join(projectPath, ".env.git"))
+ assert.True(t, os.IsNotExist(statErr))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "BASE=git\n", string(effectiveBytes))
}
-func TestProjectService_ArchiveProject_RequiresStoppedProject(t *testing.T) {
+func TestProjectService_ApplyGitSyncProjectFiles_UsesGlobalEnvDuringComposeValidation(t *testing.T) {
db := setupProjectTestDB(t)
ctx := context.Background()
- projectsRoot := t.TempDir()
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
-
- projectPath := createComposeProjectDir(t, projectsRoot, "running-demo")
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-running"},
- Name: "running-demo",
- DirName: ptr("running-demo"),
- Path: projectPath,
- Status: models.ProjectStatusRunning,
- RunningCount: 1,
- }).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- err = svc.ArchiveProject(ctx, "project-running", models.User{BaseModel: models.BaseModel{ID: "user-1"}, Username: "tester"})
- require.Error(t, err)
- var stoppedErr *common.ProjectMustBeStoppedError
- assert.ErrorAs(t, err, &stoppedErr)
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- var stored models.Project
- require.NoError(t, db.First(&stored, "id = ?", "project-running").Error)
- assert.False(t, stored.IsArchived)
- assert.Nil(t, stored.ArchivedAt)
-}
+ dirName := "git-sync-global-env"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=/srv/media\nMYPATH=/containers/\n"), 0o600))
-func TestProjectService_ArchiveProject_TogglesArchiveFlag(t *testing.T) {
- db := setupProjectTestDB(t)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-global-env"},
+ Name: dirName,
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ compose := `services:
+ cats:
+ image: mikesir87/cats:1.0
+ volumes:
+ - ${DATA_NAS_FOLDER}:/data
+ - ${MYPATH}cats/templates:/app/templates
+`
+
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, compose, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
+ require.NoError(t, readErr)
+ assert.Equal(t, compose, string(composeBytes))
+}
+
+func TestProjectService_PersistGitSyncEnvFiles_UsesPreparedState(t *testing.T) {
+ db := setupProjectTestDB(t)
ctx := context.Background()
- projectsRoot := t.TempDir()
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- projectPath := createComposeProjectDir(t, projectsRoot, "stopped-demo")
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: "project-stopped"},
- Name: "stopped-demo",
- DirName: ptr("stopped-demo"),
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }).Error)
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- user := models.User{BaseModel: models.BaseModel{ID: "user-1"}, Username: "tester"}
+ dirName := "git-sync-prepared-state"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\n"), 0o600))
- require.NoError(t, svc.ArchiveProject(ctx, "project-stopped", user))
- var stored models.Project
- require.NoError(t, db.First(&stored, "id = ?", "project-stopped").Error)
- assert.True(t, stored.IsArchived)
- assert.NotNil(t, stored.ArchivedAt)
+ update, err := svc.prepareGitSyncEnvUpdateInternal(projectPath, new("BASE=git-updated\nTOKEN=git\nREMOTE=1\n"))
+ require.NoError(t, err)
+ require.NotNil(t, update.effectiveContent)
- require.NoError(t, svc.UnarchiveProject(ctx, "project-stopped", user))
- var unarchived models.Project
- require.NoError(t, db.First(&unarchived, "id = ?", "project-stopped").Error)
- assert.False(t, unarchived.IsArchived)
- assert.Nil(t, unarchived.ArchivedAt)
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=unexpected\n"), 0o600))
+
+ require.NoError(t, svc.persistGitSyncEnvFilesInternal(projectPath, projectsDir, update))
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "TOKEN=local\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "BASE=git-updated\nREMOTE=1\nTOKEN=local\n", string(effectiveBytes))
}
-func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(t *testing.T) {
- projectPath := filepath.Join(t.TempDir(), "arcane")
- now := time.Now()
- proj := models.Project{
- Name: "arcane",
- Path: projectPath,
- ServiceCount: 1,
- BaseModel: models.BaseModel{
- ID: "project-arcane",
- CreatedAt: now,
- UpdatedAt: &now,
- },
+func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+
+ dirName := "details-override"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=secret\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=secret\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-details-override"},
+ Name: "details-override",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
}
+ require.NoError(t, db.Create(project).Error)
+
+ details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
+ require.NoError(t, err)
+ assert.Equal(t, "BASE=git\nTOKEN=secret\n", details.EnvContent)
+}
+
+func TestBuildProjectUpdateInfoSummaryInternal(t *testing.T) {
+ now := time.Now().UTC()
tests := []struct {
- name string
- containerID string
- currentContainerID string
- currentErr error
- labels map[string]string
- wantProject bool
- wantService bool
+ name string
+ imageRefs []string
+ updates map[string]*imagetypes.UpdateInfo
+ wantStatus string
+ wantCount int
+ wantChecked int
+ wantErrors int
+ wantUpdates int
+ wantError string
}{
{
- name: "current Arcane server container disables project redeploy",
- containerID: "arcane1234567890",
- currentContainerID: "arcane1234567890",
- labels: map[string]string{
- "com.docker.compose.project": "arcane",
- "com.docker.compose.service": "server",
- libupdater.LabelArcane: "true",
- },
- wantProject: true,
- wantService: true,
- },
- {
- name: "current legacy Arcane server container disables project redeploy",
- containerID: "arcane1234567890",
- currentContainerID: "arcane1234567890",
- labels: map[string]string{
- "com.docker.compose.project": "arcane",
- "com.docker.compose.service": "server",
- libupdater.LabelArcaneLegacyServer: "true",
- },
- wantProject: true,
- wantService: true,
+ name: "unknown when no checks exist",
+ imageRefs: []string{"nginx:latest"},
+ updates: nil,
+ wantStatus: "unknown",
+ wantCount: 1,
+ wantChecked: 0,
+ wantErrors: 0,
+ wantUpdates: 0,
},
{
- name: "Arcane server container fails closed when current container is unavailable",
- containerID: "arcane1234567890",
- currentErr: errors.New("not running in docker"),
- labels: map[string]string{
- "com.docker.compose.project": "arcane",
- "com.docker.compose.service": "server",
- libupdater.LabelArcane: "true",
+ name: "has update when any image has update",
+ imageRefs: []string{"nginx:latest", "redis:7"},
+ updates: map[string]*imagetypes.UpdateInfo{
+ "nginx:latest": {HasUpdate: true, CheckTime: now},
+ "redis:7": {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
},
- wantProject: true,
- wantService: true,
+ wantStatus: "has_update",
+ wantCount: 2,
+ wantChecked: 2,
+ wantErrors: 0,
+ wantUpdates: 1,
},
{
- name: "Arcane agent container stays redeployable",
- containerID: "agent1234567890",
- currentContainerID: "agent1234567890",
- labels: map[string]string{
- "com.docker.compose.project": "arcane",
- "com.docker.compose.service": "agent",
- libupdater.LabelArcane: "true",
- libupdater.LabelArcaneAgent: "true",
+ name: "error when no updates but a check failed",
+ imageRefs: []string{"nginx:latest"},
+ updates: map[string]*imagetypes.UpdateInfo{
+ "nginx:latest": {HasUpdate: false, CheckTime: now, Error: "rate limited"},
},
+ wantStatus: "error",
+ wantCount: 1,
+ wantChecked: 1,
+ wantErrors: 1,
+ wantUpdates: 0,
+ wantError: "rate limited",
},
{
- name: "non Arcane container stays redeployable",
- containerID: "regular1234567890",
- currentContainerID: "regular1234567890",
- labels: map[string]string{
- "com.docker.compose.project": "arcane",
- "com.docker.compose.service": "postgres",
+ name: "up to date when all images checked without updates",
+ imageRefs: []string{"nginx:latest", "redis:7"},
+ updates: map[string]*imagetypes.UpdateInfo{
+ "nginx:latest": {HasUpdate: false, CheckTime: now},
+ "redis:7": {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
},
+ wantStatus: "up_to_date",
+ wantCount: 2,
+ wantChecked: 2,
+ wantErrors: 0,
+ wantUpdates: 0,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- service := &ProjectService{}
- details := service.mapProjectToDto(context.Background(), filepath.Dir(projectPath), proj, map[string][]container.Summary{
- "arcane": {
- {
- ID: tt.containerID,
- Image: "ghcr.io/getarcaneapp/arcane:latest",
- State: "running",
- Status: "Up",
- Names: []string{"/arcane-server"},
- Labels: tt.labels,
- },
- },
- }, tt.currentContainerID, tt.currentErr)
-
- require.Equal(t, tt.wantProject, details.RedeployDisabled)
- require.Len(t, details.RuntimeServices, 1)
- require.Equal(t, tt.wantService, details.RuntimeServices[0].RedeployDisabled)
- })
- }
-}
-
-func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSentinel(t *testing.T) {
- db := setupProjectTestDB(t)
- ctx := context.Background()
-
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ summary := buildProjectUpdateInfoSummaryInternal(tt.imageRefs, tt.updates)
+ require.NotNil(t, summary)
+ assert.Equal(t, tt.wantStatus, summary.Status)
+ assert.Equal(t, tt.wantCount, summary.ImageCount)
+ assert.Equal(t, tt.wantChecked, summary.CheckedImageCount)
+ assert.Equal(t, tt.wantErrors, summary.ErrorCount)
+ assert.Equal(t, tt.wantUpdates, summary.ImagesWithUpdates)
+ assert.Equal(t, tt.wantUpdates > 0, summary.HasUpdate)
+ assert.Equal(t, tt.imageRefs, summary.ImageRefs)
+ if tt.wantError != "" {
+ require.NotNil(t, summary.ErrorMessage)
+ assert.Equal(t, tt.wantError, *summary.ErrorMessage)
+ } else {
+ assert.Nil(t, summary.ErrorMessage)
+ }
+ if tt.wantUpdates > 0 {
+ assert.Equal(t, []string{tt.imageRefs[0]}, summary.UpdatedImageRefs)
+ } else {
+ assert.Empty(t, summary.UpdatedImageRefs)
+ }
+ })
+ }
+}
- for i := 0; i < 25; i++ {
- projectPath := createComposeProjectDir(t, projectsRoot, fmt.Sprintf("stopped-%02d", i))
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: fmt.Sprintf("project-%02d", i)},
- Name: fmt.Sprintf("stopped-%02d", i),
- DirName: ptr(fmt.Sprintf("stopped-%02d", i)),
- Path: projectPath,
- Status: models.ProjectStatusStopped,
- }).Error)
+func TestProjectService_GetProjectDetails_IncludesUpdateInfo(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ imageService := &ImageService{db: db}
+ svc := NewProjectService(db, settingsService, nil, imageService, nil, nil, config.Load())
+
+ projectPath := createComposeProjectDir(t, projectsDir, "updates-demo")
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:latest\n"), 0o644))
+
+ projectRecord := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-update-info"},
+ Name: "updates-demo",
+ DirName: ptr("updates-demo"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
}
+ require.NoError(t, db.Create(projectRecord).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:update-demo",
+ Repository: "docker.io/library/nginx",
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: "digest",
+ CurrentVersion: "latest",
+ CheckTime: time.Now().UTC(),
+ }).Error)
- items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
- Filters: map[string]string{
- "status": string(models.ProjectStatusStopped),
- },
- Params: pagination.Params{Limit: -1},
- SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
- })
+ details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.AllDetails())
require.NoError(t, err)
- assert.EqualValues(t, 25, page.TotalItems)
- require.Len(t, items, 25)
- assert.Equal(t, "stopped-00", items[0].Name)
- assert.Equal(t, "stopped-24", items[len(items)-1].Name)
+ require.NotNil(t, details.UpdateInfo)
+ assert.Equal(t, "has_update", details.UpdateInfo.Status)
+ assert.True(t, details.UpdateInfo.HasUpdate)
+ assert.Equal(t, 1, details.UpdateInfo.ImageCount)
+ assert.Equal(t, 1, details.UpdateInfo.CheckedImageCount)
+ assert.Equal(t, 1, details.UpdateInfo.ImagesWithUpdates)
+ assert.Equal(t, []string{"nginx:latest"}, details.UpdateInfo.ImageRefs)
+ assert.Equal(t, []string{"nginx:latest"}, details.UpdateInfo.UpdatedImageRefs)
}
-func TestProjectService_PrepareServiceBuildRequest_MapsComposeFields(t *testing.T) {
- svc := &ProjectService{}
- proj := &composetypes.Project{WorkingDir: "/tmp/project", Name: "demo"}
+func TestProjectService_GetProjectDetails_RefreshesRuntimeStatusWithoutRuntimeServices(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
- serviceCfg := composetypes.ServiceConfig{
- Name: "web",
- Image: "example/web:latest",
- Platform: "linux/amd64",
- Build: &composetypes.BuildConfig{
- Context: ".",
- Dockerfile: "Dockerfile.custom",
- Target: "prod",
- Args: composetypes.MappingWithEquals{
- "FOO": new("bar"),
- },
- Tags: []string{"example/web:sha", "example/web:latest"},
- CacheFrom: []string{"example/cache:latest"},
- CacheTo: []string{"type=local,dest=/tmp/cache"},
- NoCache: true,
- Pull: true,
- Network: "host",
- Isolation: "default",
- ShmSize: composetypes.UnitBytes(64 * 1024 * 1024),
- Ulimits: map[string]*composetypes.UlimitsConfig{
- "nofile": {Soft: 1024, Hard: 2048},
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ projectPath := createComposeProjectDir(t, projectsDir, "projectA")
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n server:\n image: nginx:alpine\n worker:\n image: busybox:latest\n"), 0o644))
+
+ server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
+ {
+ ID: "server-container",
+ Names: []string{"/projecta-server-1"},
+ Image: "nginx:alpine",
+ State: container.StateRunning,
+ Status: "Up 30 seconds (healthy)",
+ Ports: []container.PortSummary{
+ {
+ IP: netip.MustParseAddr("0.0.0.0"),
+ PrivatePort: 80,
+ PublicPort: 8080,
+ Type: "tcp",
+ },
},
- Entitlements: []string{"network.host"},
- Privileged: true,
- ExtraHosts: composetypes.HostsList{
- "registry.local": {"10.0.0.5"},
+ Labels: map[string]string{
+ composeapi.ProjectLabel: "projecta",
+ composeapi.ServiceLabel: "server",
+ composeapi.ConfigHashLabel: "server-hash",
+ composeapi.WorkingDirLabel: "/host/path/projects/projectA",
},
- Labels: composetypes.Labels{
- "com.example.team": "platform",
+ },
+ {
+ ID: "worker-container",
+ Names: []string{"/projecta-worker-1"},
+ Image: "busybox:latest",
+ State: container.StateRunning,
+ Status: "Up 30 seconds",
+ Labels: map[string]string{
+ composeapi.ProjectLabel: "projecta",
+ composeapi.ServiceLabel: "worker",
+ composeapi.ConfigHashLabel: "worker-hash",
+ composeapi.WorkingDirLabel: "/host/path/projects/projectA",
},
},
+ })
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+
+ projectRecord := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-runtime-refresh"},
+ Name: "projectA",
+ DirName: ptr("projectA"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ ServiceCount: 2,
+ RunningCount: 0,
}
+ require.NoError(t, db.Create(projectRecord).Error)
- req, _, _, err := svc.prepareServiceBuildRequest(
- context.Background(),
- "project-id",
- proj,
- "web",
- serviceCfg,
- ProjectBuildOptions{},
- )
- require.NoError(t, err)
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- assert.Equal(t, "/tmp/project", req.ContextDir)
- assert.Equal(t, "Dockerfile.custom", req.Dockerfile)
- assert.Equal(t, "prod", req.Target)
- assert.Equal(t, map[string]string{"FOO": "bar"}, req.BuildArgs)
- assert.Equal(t, []string{"example/web:latest", "example/web:sha"}, req.Tags)
- assert.Equal(t, []string{"linux/amd64"}, req.Platforms)
- assert.Equal(t, []string{"example/cache:latest"}, req.CacheFrom)
- assert.Equal(t, []string{"type=local,dest=/tmp/cache"}, req.CacheTo)
- assert.True(t, req.NoCache)
- assert.True(t, req.Pull)
- assert.Equal(t, "host", req.Network)
- assert.Equal(t, "default", req.Isolation)
- assert.Equal(t, int64(64*1024*1024), req.ShmSize)
- assert.Equal(t, map[string]string{"nofile": "1024:2048"}, req.Ulimits)
- assert.Equal(t, []string{"network.host"}, req.Entitlements)
- assert.True(t, req.Privileged)
- assert.Equal(t, map[string]string{"com.example.team": "platform"}, req.Labels)
- require.Len(t, req.ExtraHosts, 1)
- assert.Contains(t, req.ExtraHosts[0], "registry.local")
- assert.Contains(t, req.ExtraHosts[0], "10.0.0.5")
+ details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.DetailsOptions{})
+ require.NoError(t, err)
+ assert.Equal(t, string(models.ProjectStatusRunning), details.Status)
+ assert.Equal(t, 2, details.ServiceCount)
+ assert.Equal(t, 2, details.RunningCount)
+ assert.Empty(t, details.RuntimeServices)
}
-// TestProjectService_PrepareServiceBuildRequest_KeepsContainerPaths is a
-// regression test for #2314: Arcane's local build pipeline (the docker and
-// buildkit providers both read the build context via the Arcane process's own
-// filesystem) cannot use host paths, so prepareServiceBuildRequest must leave
-// the build context and any absolute Dockerfile path as container paths even
-// when the projects mount has a non-matching host prefix.
-func TestProjectService_PrepareServiceBuildRequest_KeepsContainerPaths(t *testing.T) {
- svc := &ProjectService{}
- proj := &composetypes.Project{WorkingDir: "/app/data/projects/demo", Name: "demo"}
+func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
- serviceCfg := composetypes.ServiceConfig{
- Name: "web",
- Image: "example/web:latest",
- Build: &composetypes.BuildConfig{
- Context: ".",
- Dockerfile: "/app/data/projects/demo/Dockerfile.custom",
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ projectPath := createComposeProjectDir(t, projectsDir, "projectA")
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n server:\n image: nginx:alpine\n"), 0o644))
+
+ server := newProjectRuntimeDockerServerInternal(t, []container.Summary{
+ {
+ ID: "server-container",
+ Names: []string{"/projecta-server-1"},
+ Image: "nginx:alpine",
+ State: container.StateRunning,
+ Status: "Up 30 seconds",
+ Labels: map[string]string{
+ composeapi.ProjectLabel: "projecta",
+ composeapi.ServiceLabel: "server",
+ composeapi.ConfigHashLabel: "server-hash",
+ composeapi.WorkingDirLabel: "/host/path/projects/projectA",
+ },
},
- }
+ })
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
+
+ projectRecord := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-runtime-services"},
+ Name: "projectA",
+ DirName: ptr("projectA"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ ServiceCount: 1,
+ RunningCount: 0,
+ }
+ require.NoError(t, db.Create(projectRecord).Error)
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.DetailsOptions{IncludeRuntimeServices: true})
+ require.NoError(t, err)
+ require.Len(t, details.RuntimeServices, 1)
+ assert.Equal(t, string(models.ProjectStatusRunning), details.Status)
+ assert.Equal(t, "server", details.RuntimeServices[0].Name)
+ assert.Equal(t, "running", details.RuntimeServices[0].Status)
+ assert.Equal(t, "server-container", details.RuntimeServices[0].ContainerID)
+ assert.Equal(t, "projecta-server-1", details.RuntimeServices[0].ContainerName)
+}
+
+func TestProjectService_ListProjects_FiltersByUpdateStatus(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ imageService := &ImageService{db: db}
+ svc := NewProjectService(db, settingsService, nil, imageService, nil, nil, config.Load())
+
+ updatedPath := createComposeProjectDir(t, projectsDir, "updated-demo")
+ require.NoError(t, os.WriteFile(filepath.Join(updatedPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:latest\n"), 0o644))
+ upToDatePath := createComposeProjectDir(t, projectsDir, "current-demo")
+ require.NoError(t, os.WriteFile(filepath.Join(upToDatePath, "compose.yaml"), []byte("services:\n app:\n image: redis:7\n"), 0o644))
+ errorPath := createComposeProjectDir(t, projectsDir, "error-demo")
+ require.NoError(t, os.WriteFile(filepath.Join(errorPath, "compose.yaml"), []byte("services:\n app:\n image: busybox:latest\n"), 0o644))
+ unknownPath := createComposeProjectDir(t, projectsDir, "unknown-demo")
+ require.NoError(t, os.WriteFile(filepath.Join(unknownPath, "compose.yaml"), []byte("services:\n app:\n image: alpine:latest\n"), 0o644))
+
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-updated"},
+ Name: "updated-demo",
+ DirName: ptr("updated-demo"),
+ Path: updatedPath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-current"},
+ Name: "current-demo",
+ DirName: ptr("current-demo"),
+ Path: upToDatePath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-error"},
+ Name: "error-demo",
+ DirName: ptr("error-demo"),
+ Path: errorPath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-unknown"},
+ Name: "unknown-demo",
+ DirName: ptr("unknown-demo"),
+ Path: unknownPath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+
+ now := time.Now().UTC()
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:updated-image",
+ Repository: "docker.io/library/nginx",
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: "digest",
+ CurrentVersion: "latest",
+ CheckTime: now,
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:current-image",
+ Repository: "docker.io/library/redis",
+ Tag: "7",
+ HasUpdate: false,
+ UpdateType: "tag",
+ CurrentVersion: "7",
+ CheckTime: now.Add(-time.Minute),
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:error-image",
+ Repository: "docker.io/library/busybox",
+ Tag: "latest",
+ HasUpdate: false,
+ UpdateType: "error",
+ CurrentVersion: "latest",
+ CheckTime: now.Add(-2 * time.Minute),
+ LastError: ptr("registry timeout"),
+ }).Error)
+
+ tests := []struct {
+ name string
+ filter string
+ expected []string
+ }{
+ {name: "has update", filter: "has_update", expected: []string{"updated-demo"}},
+ {name: "up to date", filter: "up_to_date", expected: []string{"current-demo"}},
+ {name: "error", filter: "error", expected: []string{"error-demo"}},
+ {name: "unknown", filter: "unknown", expected: []string{"unknown-demo"}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
+ Filters: map[string]string{
+ "updates": tt.filter,
+ },
+ Params: pagination.Params{Limit: -1},
+ SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, len(tt.expected), page.TotalItems)
+
+ names := make([]string, 0, len(items))
+ for _, item := range items {
+ names = append(names, item.Name)
+ }
+ assert.Equal(t, tt.expected, names)
+ })
+ }
+}
+
+func TestBuildDiscoveredComposeProjectUpdateRowsInternal(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ imageService := &ImageService{db: db}
+ now := time.Now().UTC()
+
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:media-image",
+ Repository: "docker.io/library/nginx",
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "latest",
+ CheckTime: now,
+ }).Error)
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:known-image",
+ Repository: "docker.io/library/redis",
+ Tag: "7",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "7",
+ CheckTime: now,
+ }).Error)
+
+ rows := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, []container.Summary{
+ {
+ ID: "media-web",
+ Names: []string{"/media-web-1"},
+ Image: "nginx:latest",
+ ImageID: "sha256:media-image",
+ State: "running",
+ Labels: map[string]string{
+ "com.docker.compose.project": "media",
+ "com.docker.compose.service": "web",
+ },
+ },
+ {
+ ID: "known-cache",
+ Image: "redis:7",
+ ImageID: "sha256:known-image",
+ State: "running",
+ Labels: map[string]string{
+ "com.docker.compose.project": "known",
+ "com.docker.compose.service": "cache",
+ },
+ },
+ {
+ ID: "plain-container",
+ Image: "busybox:latest",
+ ImageID: "sha256:plain-image",
+ State: "running",
+ Labels: map[string]string{},
+ },
+ }, map[string]struct{}{"known": {}}, imageService, iconcatalog.DefaultCatalog)
+
+ require.Len(t, rows, 1)
+ row := rows[0]
+ assert.Equal(t, "compose:media", row.ID)
+ assert.Equal(t, "media", row.Name)
+ assert.True(t, row.IsDiscovered)
+ assert.Equal(t, string(models.ProjectStatusRunning), row.Status)
+ require.NotNil(t, row.UpdateInfo)
+ assert.True(t, row.UpdateInfo.HasUpdate)
+ assert.Equal(t, []string{"nginx:latest"}, row.UpdateInfo.UpdatedImageRefs)
+ require.Len(t, row.RuntimeServices, 1)
+ assert.Equal(t, "web", row.RuntimeServices[0].Name)
+}
+
+func TestBuildDiscoveredComposeProjectUpdateRowsInternal_FallsBackToImageID(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ imageService := &ImageService{db: db}
+
+ require.NoError(t, db.Create(&models.ImageUpdateRecord{
+ ID: "sha256:media-image",
+ Repository: "registry.example.test/custom/media",
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: models.UpdateTypeDigest,
+ CurrentVersion: "latest",
+ CheckTime: time.Now().UTC(),
+ }).Error)
+
+ rows := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, []container.Summary{
+ {
+ ID: "media-web",
+ Image: "nginx:latest",
+ ImageID: "sha256:media-image",
+ State: "running",
+ Labels: map[string]string{
+ "com.docker.compose.project": "media",
+ "com.docker.compose.service": "web",
+ },
+ },
+ }, map[string]struct{}{}, imageService, iconcatalog.DefaultCatalog)
+
+ require.Len(t, rows, 1)
+ assert.Equal(t, []string{"nginx:latest"}, rows[0].UpdateInfo.UpdatedImageRefs)
+}
+
+func TestProjectService_ListProjects_FiltersArchivedProjects(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ projectsRoot := t.TempDir()
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ activePath := createComposeProjectDir(t, projectsRoot, "active-demo")
+ archivedPath := createComposeProjectDir(t, projectsRoot, "archived-demo")
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-active"},
+ Name: "active-demo",
+ DirName: ptr("active-demo"),
+ Path: activePath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-archived"},
+ Name: "archived-demo",
+ DirName: ptr("archived-demo"),
+ Path: archivedPath,
+ Status: models.ProjectStatusStopped,
+ IsArchived: true,
+ ArchivedAt: new(time.Now().UTC()),
+ }).Error)
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
+ Params: pagination.Params{Limit: -1},
+ SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, 1, page.TotalItems)
+ require.Len(t, items, 1)
+ assert.Equal(t, "active-demo", items[0].Name)
+
+ items, page, err = svc.ListProjects(ctx, pagination.QueryParams{
+ Filters: map[string]string{"archived": "true"},
+ Params: pagination.Params{Limit: -1},
+ SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, 1, page.TotalItems)
+ require.Len(t, items, 1)
+ assert.Equal(t, "archived-demo", items[0].Name)
+ assert.True(t, items[0].IsArchived)
+
+ items, page, err = svc.ListProjects(ctx, pagination.QueryParams{
+ Filters: map[string]string{"archived": "all"},
+ Params: pagination.Params{Limit: -1},
+ SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, 2, page.TotalItems)
+ require.Len(t, items, 2)
+ assert.Equal(t, []string{"active-demo", "archived-demo"}, []string{items[0].Name, items[1].Name})
+}
+
+func TestProjectService_ArchiveProject_RequiresStoppedProject(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsRoot := t.TempDir()
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ projectPath := createComposeProjectDir(t, projectsRoot, "running-demo")
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-running"},
+ Name: "running-demo",
+ DirName: ptr("running-demo"),
+ Path: projectPath,
+ Status: models.ProjectStatusRunning,
+ RunningCount: 1,
+ }).Error)
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ err = svc.ArchiveProject(ctx, "project-running", models.User{BaseModel: models.BaseModel{ID: "user-1"}, Username: "tester"})
+ require.Error(t, err)
+ var stoppedErr *common.ProjectMustBeStoppedError
+ assert.ErrorAs(t, err, &stoppedErr)
+
+ var stored models.Project
+ require.NoError(t, db.First(&stored, "id = ?", "project-running").Error)
+ assert.False(t, stored.IsArchived)
+ assert.Nil(t, stored.ArchivedAt)
+}
+
+func TestProjectService_ArchiveProject_TogglesArchiveFlag(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsRoot := t.TempDir()
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ projectPath := createComposeProjectDir(t, projectsRoot, "stopped-demo")
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: "project-stopped"},
+ Name: "stopped-demo",
+ DirName: ptr("stopped-demo"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ user := models.User{BaseModel: models.BaseModel{ID: "user-1"}, Username: "tester"}
+
+ require.NoError(t, svc.ArchiveProject(ctx, "project-stopped", user))
+ var stored models.Project
+ require.NoError(t, db.First(&stored, "id = ?", "project-stopped").Error)
+ assert.True(t, stored.IsArchived)
+ assert.NotNil(t, stored.ArchivedAt)
+
+ require.NoError(t, svc.UnarchiveProject(ctx, "project-stopped", user))
+ var unarchived models.Project
+ require.NoError(t, db.First(&unarchived, "id = ?", "project-stopped").Error)
+ assert.False(t, unarchived.IsArchived)
+ assert.Nil(t, unarchived.ArchivedAt)
+}
+
+func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(t *testing.T) {
+ projectPath := filepath.Join(t.TempDir(), "arcane")
+ now := time.Now()
+ proj := models.Project{
+ Name: "arcane",
+ Path: projectPath,
+ ServiceCount: 1,
+ BaseModel: models.BaseModel{
+ ID: "project-arcane",
+ CreatedAt: now,
+ UpdatedAt: &now,
+ },
+ }
+
+ tests := []struct {
+ name string
+ containerID string
+ currentContainerID string
+ currentErr error
+ labels map[string]string
+ wantProject bool
+ wantService bool
+ }{
+ {
+ name: "current Arcane server container disables project redeploy",
+ containerID: "arcane1234567890",
+ currentContainerID: "arcane1234567890",
+ labels: map[string]string{
+ "com.docker.compose.project": "arcane",
+ "com.docker.compose.service": "server",
+ libupdater.LabelArcane: "true",
+ },
+ wantProject: true,
+ wantService: true,
+ },
+ {
+ name: "current legacy Arcane server container disables project redeploy",
+ containerID: "arcane1234567890",
+ currentContainerID: "arcane1234567890",
+ labels: map[string]string{
+ "com.docker.compose.project": "arcane",
+ "com.docker.compose.service": "server",
+ libupdater.LabelArcaneLegacyServer: "true",
+ },
+ wantProject: true,
+ wantService: true,
+ },
+ {
+ name: "Arcane server container fails closed when current container is unavailable",
+ containerID: "arcane1234567890",
+ currentErr: errors.New("not running in docker"),
+ labels: map[string]string{
+ "com.docker.compose.project": "arcane",
+ "com.docker.compose.service": "server",
+ libupdater.LabelArcane: "true",
+ },
+ wantProject: true,
+ wantService: true,
+ },
+ {
+ name: "Arcane agent container stays redeployable",
+ containerID: "agent1234567890",
+ currentContainerID: "agent1234567890",
+ labels: map[string]string{
+ "com.docker.compose.project": "arcane",
+ "com.docker.compose.service": "agent",
+ libupdater.LabelArcane: "true",
+ libupdater.LabelArcaneAgent: "true",
+ },
+ },
+ {
+ name: "non Arcane container stays redeployable",
+ containerID: "regular1234567890",
+ currentContainerID: "regular1234567890",
+ labels: map[string]string{
+ "com.docker.compose.project": "arcane",
+ "com.docker.compose.service": "postgres",
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ service := &ProjectService{}
+ details := service.mapProjectToDto(context.Background(), filepath.Dir(projectPath), proj, map[string][]container.Summary{
+ "arcane": {
+ {
+ ID: tt.containerID,
+ Image: "ghcr.io/getarcaneapp/arcane:latest",
+ State: "running",
+ Status: "Up",
+ Names: []string{"/arcane-server"},
+ Labels: tt.labels,
+ },
+ },
+ }, tt.currentContainerID, tt.currentErr)
+
+ require.Equal(t, tt.wantProject, details.RedeployDisabled)
+ require.Len(t, details.RuntimeServices, 1)
+ require.Equal(t, tt.wantService, details.RuntimeServices[0].RedeployDisabled)
+ })
+ }
+}
+
+func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSentinel(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ for i := 0; i < 25; i++ {
+ projectPath := createComposeProjectDir(t, projectsRoot, fmt.Sprintf("stopped-%02d", i))
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: fmt.Sprintf("project-%02d", i)},
+ Name: fmt.Sprintf("stopped-%02d", i),
+ DirName: ptr(fmt.Sprintf("stopped-%02d", i)),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }).Error)
+ }
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
+ Filters: map[string]string{
+ "status": string(models.ProjectStatusStopped),
+ },
+ Params: pagination.Params{Limit: -1},
+ SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc},
+ })
+ require.NoError(t, err)
+ assert.EqualValues(t, 25, page.TotalItems)
+ require.Len(t, items, 25)
+ assert.Equal(t, "stopped-00", items[0].Name)
+ assert.Equal(t, "stopped-24", items[len(items)-1].Name)
+}
+
+func TestProjectService_PrepareServiceBuildRequest_MapsComposeFields(t *testing.T) {
+ svc := &ProjectService{}
+ proj := &composetypes.Project{WorkingDir: "/tmp/project", Name: "demo"}
+
+ serviceCfg := composetypes.ServiceConfig{
+ Name: "web",
+ Image: "example/web:latest",
+ Platform: "linux/amd64",
+ Build: &composetypes.BuildConfig{
+ Context: ".",
+ Dockerfile: "Dockerfile.custom",
+ Target: "prod",
+ Args: composetypes.MappingWithEquals{
+ "FOO": new("bar"),
+ },
+ Tags: []string{"example/web:sha", "example/web:latest"},
+ CacheFrom: []string{"example/cache:latest"},
+ CacheTo: []string{"type=local,dest=/tmp/cache"},
+ NoCache: true,
+ Pull: true,
+ Network: "host",
+ Isolation: "default",
+ ShmSize: composetypes.UnitBytes(64 * 1024 * 1024),
+ Ulimits: map[string]*composetypes.UlimitsConfig{
+ "nofile": {Soft: 1024, Hard: 2048},
+ },
+ Entitlements: []string{"network.host"},
+ Privileged: true,
+ ExtraHosts: composetypes.HostsList{
+ "registry.local": {"10.0.0.5"},
+ },
+ Labels: composetypes.Labels{
+ "com.example.team": "platform",
+ },
+ },
+ }
+
+ req, _, _, err := svc.prepareServiceBuildRequest(
+ context.Background(),
+ "project-id",
+ proj,
+ "web",
+ serviceCfg,
+ ProjectBuildOptions{},
+ )
+ require.NoError(t, err)
+
+ assert.Equal(t, "/tmp/project", req.ContextDir)
+ assert.Equal(t, "Dockerfile.custom", req.Dockerfile)
+ assert.Equal(t, "prod", req.Target)
+ assert.Equal(t, map[string]string{"FOO": "bar"}, req.BuildArgs)
+ assert.Equal(t, []string{"example/web:latest", "example/web:sha"}, req.Tags)
+ assert.Equal(t, []string{"linux/amd64"}, req.Platforms)
+ assert.Equal(t, []string{"example/cache:latest"}, req.CacheFrom)
+ assert.Equal(t, []string{"type=local,dest=/tmp/cache"}, req.CacheTo)
+ assert.True(t, req.NoCache)
+ assert.True(t, req.Pull)
+ assert.Equal(t, "host", req.Network)
+ assert.Equal(t, "default", req.Isolation)
+ assert.Equal(t, int64(64*1024*1024), req.ShmSize)
+ assert.Equal(t, map[string]string{"nofile": "1024:2048"}, req.Ulimits)
+ assert.Equal(t, []string{"network.host"}, req.Entitlements)
+ assert.True(t, req.Privileged)
+ assert.Equal(t, map[string]string{"com.example.team": "platform"}, req.Labels)
+ require.Len(t, req.ExtraHosts, 1)
+ assert.Contains(t, req.ExtraHosts[0], "registry.local")
+ assert.Contains(t, req.ExtraHosts[0], "10.0.0.5")
+}
+
+// TestProjectService_PrepareServiceBuildRequest_KeepsContainerPaths is a
+// regression test for #2314: Arcane's local build pipeline (the docker and
+// buildkit providers both read the build context via the Arcane process's own
+// filesystem) cannot use host paths, so prepareServiceBuildRequest must leave
+// the build context and any absolute Dockerfile path as container paths even
+// when the projects mount has a non-matching host prefix.
+func TestProjectService_PrepareServiceBuildRequest_KeepsContainerPaths(t *testing.T) {
+ svc := &ProjectService{}
+ proj := &composetypes.Project{WorkingDir: "/app/data/projects/demo", Name: "demo"}
+
+ serviceCfg := composetypes.ServiceConfig{
+ Name: "web",
+ Image: "example/web:latest",
+ Build: &composetypes.BuildConfig{
+ Context: ".",
+ Dockerfile: "/app/data/projects/demo/Dockerfile.custom",
+ },
+ }
+
+ req, _, _, err := svc.prepareServiceBuildRequest(
+ context.Background(),
+ "project-id",
+ proj,
+ "web",
+ serviceCfg,
+ ProjectBuildOptions{},
+ )
+ require.NoError(t, err)
+
+ assert.Equal(t, "/app/data/projects/demo", req.ContextDir)
+ assert.Equal(t, "/app/data/projects/demo/Dockerfile.custom", req.Dockerfile)
+}
+
+// TestProjectService_PrepareServiceBuildRequest_BuildDotKeepsContainerPath
+// reproduces the exact configuration from #2314: a compose file with
+// `build: .` next to its Dockerfile, on an installation where the projects
+// directory is bind-mounted from a different host path than the container
+// path. The resulting BuildRequest must point at the container path so the
+// local builder can stat / tar the directory.
+func TestProjectService_PrepareServiceBuildRequest_BuildDotKeepsContainerPath(t *testing.T) {
+ svc := &ProjectService{}
+ proj := &composetypes.Project{WorkingDir: "/app/data/projects/caddy", Name: "caddy"}
+
+ serviceCfg := composetypes.ServiceConfig{
+ Name: "caddy",
+ Image: "caddy",
+ Build: &composetypes.BuildConfig{
+ Context: ".",
+ },
+ }
+
+ req, _, _, err := svc.prepareServiceBuildRequest(
+ context.Background(),
+ "project-id",
+ proj,
+ "caddy",
+ serviceCfg,
+ ProjectBuildOptions{},
+ )
+ require.NoError(t, err)
+
+ assert.Equal(t, "/app/data/projects/caddy", req.ContextDir)
+ assert.Equal(t, "Dockerfile", req.Dockerfile)
+}
+
+func TestProjectService_PrepareServiceBuildRequest_UsesInlineDockerfile(t *testing.T) {
+ svc := &ProjectService{}
+ proj := &composetypes.Project{WorkingDir: "/tmp/project", Name: "demo"}
+
+ serviceCfg := composetypes.ServiceConfig{
+ Name: "web",
+ Image: "example/web:latest",
+ Build: &composetypes.BuildConfig{
+ Context: ".",
+ DockerfileInline: "FROM alpine:3.20\nRUN echo inline\n",
+ },
+ }
+
+ req, _, _, err := svc.prepareServiceBuildRequest(
+ context.Background(),
+ "project-id",
+ proj,
+ "web",
+ serviceCfg,
+ ProjectBuildOptions{},
+ )
+ require.NoError(t, err)
+
+ assert.Equal(t, "/tmp/project", req.ContextDir)
+ assert.Empty(t, req.Dockerfile)
+ assert.Equal(t, "FROM alpine:3.20\nRUN echo inline\n", req.DockerfileInline)
+}
+
+func TestNormalizePullPolicy(t *testing.T) {
+ assert.Equal(t, "missing", normalizePullPolicy("if_not_present"))
+ assert.Equal(t, "build", normalizePullPolicy(" BUILD "))
+ assert.Equal(t, "", normalizePullPolicy(""))
+}
+
+func TestDecideDeployImageAction(t *testing.T) {
+ t.Run("build service with explicit build policy", func(t *testing.T) {
+ svc := composetypes.ServiceConfig{
+ PullPolicy: "build",
+ Build: &composetypes.BuildConfig{Context: "."},
+ }
+
+ decision := decideDeployImageAction(svc, "")
+ assert.True(t, decision.Build)
+ assert.False(t, decision.PullAlways)
+ })
+
+ t.Run("build service default policy uses pull then fallback build", func(t *testing.T) {
+ svc := composetypes.ServiceConfig{Build: &composetypes.BuildConfig{Context: "."}}
+ decision := decideDeployImageAction(svc, "")
+ assert.True(t, decision.PullIfMissing)
+ assert.True(t, decision.FallbackBuildOnPullFail)
+ assert.False(t, decision.Build)
+ })
+
+ t.Run("non-build service never policy requires local only", func(t *testing.T) {
+ svc := composetypes.ServiceConfig{PullPolicy: "never"}
+ decision := decideDeployImageAction(svc, "")
+ assert.True(t, decision.RequireLocalOnly)
+ assert.False(t, decision.PullIfMissing)
+ })
+
+ t.Run("compose pull policy wins over deploy override", func(t *testing.T) {
+ svc := composetypes.ServiceConfig{PullPolicy: "never"}
+ decision := decideDeployImageAction(svc, "always")
+ assert.True(t, decision.RequireLocalOnly)
+ assert.False(t, decision.PullAlways)
+ })
+}
+
+func TestProjectService_PrepareServiceBuildRequest_GeneratedImageProviderGuardrails(t *testing.T) {
+ svc := &ProjectService{}
+ proj := &composetypes.Project{WorkingDir: "/tmp/project", Name: "demo"}
+
+ serviceCfg := composetypes.ServiceConfig{
+ Name: "web",
+ Build: &composetypes.BuildConfig{
+ Context: ".",
+ },
+ }
+
+ _, _, _, err := svc.prepareServiceBuildRequest(
+ context.Background(),
+ "project-id",
+ proj,
+ "web",
+ serviceCfg,
+ ProjectBuildOptions{Provider: "depot"},
+ )
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "must define an image when using depot")
+
+ _, _, _, err = svc.prepareServiceBuildRequest(
+ context.Background(),
+ "project-id",
+ proj,
+ "web",
+ serviceCfg,
+ ProjectBuildOptions{Provider: "local", Push: new(true)},
+ )
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "must define an image when push is enabled")
+}
+
+func TestProjectService_DeployProject_StopsOnBuildPreparationError(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectDir := filepath.Join(projectsRoot, "demo")
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+ composeContent := "services:\n" +
+ " web:\n" +
+ " pull_policy: build\n" +
+ " build:\n" +
+ " context: .\n"
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte(composeContent), 0o644))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot+":"+projectsRoot))
+
+ proj := &models.Project{
+ BaseModel: models.BaseModel{ID: "p1"},
+ Name: "demo",
+ Path: projectDir,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(proj).Error)
+
+ buildSvc := &BuildService{builder: testBuildBuilder{err: errors.New("boom build")}}
+ svc := NewProjectService(db, settingsService, nil, nil, nil, buildSvc, config.Load())
+
+ err = svc.DeployProject(ctx, "p1", models.User{BaseModel: models.BaseModel{ID: "u1"}, Username: "tester"}, nil)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to prepare project images for deploy")
+ assert.Contains(t, err.Error(), "boom build")
+
+ var updated models.Project
+ require.NoError(t, db.First(&updated, "id = ?", "p1").Error)
+ assert.Equal(t, models.ProjectStatusStopped, updated.Status)
+}
+
+func TestProjectService_DeployProject_BuildsGeneratedImageWithoutPull(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectDir := filepath.Join(projectsRoot, "demo")
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+ composeContent := "services:\n" +
+ " caddy:\n" +
+ " build:\n" +
+ " dockerfile_inline: |\n" +
+ " FROM caddy:builder AS builder\n" +
+ " RUN xcaddy build --with github.com/caddyserver/replace-response\n" +
+ "\n" +
+ " FROM caddy:latest\n" +
+ " COPY --from=builder /usr/bin/caddy /usr/bin/caddy\n"
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte(composeContent), 0o644))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot+":"+projectsRoot))
+
+ proj := &models.Project{
+ BaseModel: models.BaseModel{ID: "p-generated"},
+ Name: "build-test",
+ Path: projectDir,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(proj).Error)
+
+ buildSvc := &BuildService{builder: testBuildBuilder{err: errors.New("boom build")}}
+ svc := NewProjectService(db, settingsService, nil, nil, nil, buildSvc, config.Load())
+
+ err = svc.DeployProject(ctx, proj.ID, models.User{BaseModel: models.BaseModel{ID: "u1"}, Username: "tester"}, nil)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to prepare project images for deploy")
+ assert.Contains(t, err.Error(), "boom build")
+ assert.NotContains(t, err.Error(), "failed to pull image arcane.local/")
+ assert.NotContains(t, err.Error(), "failed to resolve reference \"arcane.local/")
+}
+
+func TestResolveBuildContextInternal_AllowsRemoteGitContext(t *testing.T) {
+ svc := composetypes.ServiceConfig{
+ Build: &composetypes.BuildConfig{
+ Context: "https://github.com/getarcaneapp/arcane.git#main:docker/app",
+ },
+ }
+
+ contextDir, err := resolveBuildContextInternal("/projects/demo", svc, "web")
+ require.NoError(t, err)
+ assert.Equal(t, "https://github.com/getarcaneapp/arcane.git#main:docker/app", contextDir)
+}
+
+func TestResolveBuildContextInternal_AllowsRemoteGitContextWithoutGitSuffix(t *testing.T) {
+ svc := composetypes.ServiceConfig{
+ Build: &composetypes.BuildConfig{
+ Context: "https://git.sr.ht/~jordanreger/nws-alerts#main:docker/app",
+ },
+ }
+
+ contextDir, err := resolveBuildContextInternal("/projects/demo", svc, "web")
+ require.NoError(t, err)
+ assert.Equal(t, "https://git.sr.ht/~jordanreger/nws-alerts#main:docker/app", contextDir)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_IgnoresSymlinkedProjectDirsWhenDisabled(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ targetRoot := t.TempDir()
+ createComposeProjectDir(t, projectsRoot, "regular")
+ linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
+ require.NoError(t, os.Symlink(linkTarget, filepath.Join(projectsRoot, "linked")))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ assert.Equal(t, "regular", items[0].Name)
+ assert.Equal(t, filepath.Join(projectsRoot, "regular"), items[0].Path)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_DetectsSymlinkedProjectDirsWhenEnabled(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ targetRoot := t.TempDir()
+ linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
+ linkPath := filepath.Join(projectsRoot, "linked")
+ require.NoError(t, os.Symlink(linkTarget, linkPath))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ assert.Equal(t, "linked", items[0].Name)
+ assert.Equal(t, linkPath, items[0].Path)
+}
+
+func TestProjectService_CountProjectFolders_RespectsFollowProjectSymlinks(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ targetRoot := t.TempDir()
+ createComposeProjectDir(t, projectsRoot, "regular")
+ linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
+ require.NoError(t, os.Symlink(linkTarget, filepath.Join(projectsRoot, "linked")))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
+ count, err := svc.countProjectFolders(ctx)
+ require.NoError(t, err)
+ assert.Equal(t, 1, count)
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+ count, err = svc.countProjectFolders(ctx)
+ require.NoError(t, err)
+ assert.Equal(t, 2, count)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_DiscoversNestedProjectsAndRelativePaths(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ nestedPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
+ topLevelPath := createComposeProjectDir(t, projectsRoot, "project2")
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
+ SortParams: pagination.SortParams{Sort: "path", Order: pagination.SortAsc},
+ Params: pagination.Params{Limit: -1},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, 2, page.TotalItems)
+ require.Len(t, items, 2)
+
+ assert.Equal(t, "main-project/sub-project1", items[0].RelativePath)
+ assert.Equal(t, nestedPath, items[0].Path)
+ assert.Equal(t, "sub-project1", items[0].DirName)
+
+ assert.Equal(t, "project2", items[1].RelativePath)
+ assert.Equal(t, topLevelPath, items[1].Path)
+ assert.Equal(t, "project2", items[1].DirName)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_RespectsConfiguredScanMaxDepth(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ topLevelPath := createComposeProjectDir(t, projectsRoot, "project1")
+ createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ assert.Equal(t, "project1", items[0].Name)
+ assert.Equal(t, topLevelPath, items[0].Path)
+}
+
+func TestProjectService_ListProjects_LoadsProjectIconFromGlobalEnvInIncludedMetadata(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectPath := filepath.Join(projectsRoot, "demo")
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+
+ require.NoError(t, os.WriteFile(
+ filepath.Join(projectsRoot, projects.GlobalEnvFileName),
+ []byte("ICON_CDN_URL=https://cdn.jsdelivr.net/gh/selfhst/icons@main\n"),
+ 0o600,
+ ))
+
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(`include:
+ - metadata.yaml
+services:
+ watchtower:
+ image: nickfedor/watchtower:latest
+`), 0o600))
+
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "metadata.yaml"), []byte(`x-watchtower-icon-light: &watchtower-icon "${ICON_CDN_URL:+${ICON_CDN_URL}/svg/watchtower.svg}"
+x-arcane:
+ icon-light: *watchtower-icon
+ icon-dark: *watchtower-icon
+services:
+ watchtower:
+ labels:
+ com.getarcaneapp.arcane.icon-light: *watchtower-icon
+ com.getarcaneapp.arcane.icon-dark: *watchtower-icon
+`), 0o600))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
+ SortParams: pagination.SortParams{Sort: "path", Order: pagination.SortAsc},
+ Params: pagination.Params{Limit: -1},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, 1, page.TotalItems)
+ require.Len(t, items, 1)
+ assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconLightURL)
+ assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconDarkURL)
+}
+
+func TestProjectService_CountProjectFolders_RecursivelyCountsNestedProjects(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
+ createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project2"))
+ createComposeProjectDir(t, projectsRoot, "project2")
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ count, err := svc.countProjectFolders(ctx)
+ require.NoError(t, err)
+ assert.Equal(t, 3, count)
+}
+
+func TestProjectService_CountProjectFolders_RespectsConfiguredScanMaxDepth(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ createComposeProjectDir(t, projectsRoot, "project1")
+ createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ count, err := svc.countProjectFolders(ctx)
+ require.NoError(t, err)
+ assert.Equal(t, 1, count)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_RemovesDeletedNestedProject(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+
+ require.NoError(t, os.Remove(filepath.Join(projectPath, "compose.yaml")))
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err = svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ assert.Empty(t, items)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectsWhenDirectoryEmptyOrUnmounted(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ // An existing-but-empty projects directory simulates a mis-mapped or unmounted
+ // projects volume: GetProjectsDirectory resolves (and MkdirAll's) it, discovery
+ // finds nothing, and every stored project path is now missing on disk.
+ projectsRoot := t.TempDir()
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ // Seed a small deployment's worth of filesystem-managed projects whose
+ // directories do not exist. Each would individually be pruned as "directory no
+ // longer exists"; together they would wipe the table — exactly what the
+ // mass-wipe guard must prevent, even for deployments with only a handful of
+ // projects (the guard must not give small installs a free pass).
+ const seeded = 3
+ for i := range seeded {
+ require.NoError(t, db.WithContext(ctx).Create(&models.Project{
+ Name: fmt.Sprintf("project-%d", i),
+ Path: filepath.Join(projectsRoot, fmt.Sprintf("project-%d", i)),
+ Status: models.ProjectStatusStopped,
+ }).Error)
+ }
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ assert.Len(t, items, seeded, "an empty/mis-mapped projects directory must not wipe existing project records")
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectWithAmbiguousCustomCompose(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectPath := createComposeProjectDir(t, projectsRoot, "ambiguous-project")
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+
+ // Replace the standard compose.yaml with two custom-named compose files. The
+ // directory still holds compose content, but DetectComposeFile can't pick one
+ // and returns common.AmbiguousComposeFileError. The reconcile must NOT delete the
+ // record: the project's files are intact on disk and it may be deployable.
+ require.NoError(t, os.Remove(filepath.Join(projectPath, "compose.yaml")))
+ composeBody := []byte("services:\n app:\n image: nginx:alpine\n")
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "app.yaml"), composeBody, 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "extra.yaml"), composeBody, 0o644))
+
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err = svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ assert.Len(t, items, 1, "project with ambiguous compose files must not be deleted")
+ assert.Equal(t, projectPath, items[0].Path)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_RemovesProjectsBeyondReducedScanMaxDepth(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ topLevelPath := createComposeProjectDir(t, projectsRoot, "project1")
+ nestedPath := createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ // Initial sync at the default scan depth discovers both the top-level and
+ // the nested project, persisting them to the database.
+ defaultSvc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, defaultSvc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := defaultSvc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 2)
+
+ // Lowering the scan depth must prune the nested project from the database on
+ // the next sync, even though its compose file still exists on disk.
+ t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
+ depthLimitedSvc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, depthLimitedSvc.SyncProjectsFromFileSystem(ctx))
+
+ items, err = depthLimitedSvc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ assert.Equal(t, "project1", items[0].Name)
+ assert.Equal(t, topLevelPath, items[0].Path)
+
+ // The pruned project's files must remain untouched on disk so raising the
+ // depth again re-discovers it.
+ assert.FileExists(t, filepath.Join(nestedPath, "compose.yaml"))
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_PreservesDBRecordsWhenDirectoryUnreadable(t *testing.T) {
+ if runtime.GOOS == "windows" {
+ t.Skip("POSIX permission-denied behavior is not portable to Windows")
+ }
+ if os.Geteuid() == 0 {
+ t.Skip("test requires a non-root UID to trigger permission-denied on ReadDir")
+ }
+
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ createComposeProjectDir(t, projectsRoot, "project1")
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ before, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, before, 1)
+
+ unreadable := t.TempDir()
+ require.NoError(t, os.Chmod(unreadable, 0))
+ t.Cleanup(func() { _ = os.Chmod(unreadable, 0o700) })
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", unreadable))
+
+ syncErr := svc.SyncProjectsFromFileSystem(ctx)
+ require.Error(t, syncErr, "sync should propagate the permission-denied error")
+
+ after, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ assert.Len(t, after, 1, "DB records must not be wiped when discovery fails")
+ assert.Equal(t, before[0].Path, after[0].Path)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_AllowsDuplicateLeafDirectoriesInDifferentParents(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ firstPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project1", "app"))
+ secondPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project2", "app"))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ var items []models.Project
+ require.NoError(t, db.WithContext(ctx).Order("path asc").Find(&items).Error)
+ require.Len(t, items, 2)
+
+ require.NotNil(t, items[0].DirName)
+ require.NotNil(t, items[1].DirName)
+ assert.Equal(t, "app", *items[0].DirName)
+ assert.Equal(t, "app", *items[1].DirName)
+ assert.Equal(t, firstPath, items[0].Path)
+ assert.Equal(t, secondPath, items[1].Path)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_DetectsNestedSymlinkedProjectDirsWhenEnabled(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ targetRoot := t.TempDir()
+ targetPath := createComposeProjectDir(t, targetRoot, filepath.Join("main-project", "sub-project1"))
+ linkPath := filepath.Join(projectsRoot, "linked-root")
+ require.NoError(t, os.Symlink(filepath.Join(targetRoot, "main-project"), linkPath))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
+ SortParams: pagination.SortParams{Sort: "path", Order: pagination.SortAsc},
+ Params: pagination.Params{Limit: -1},
+ })
+ require.NoError(t, err)
+ require.EqualValues(t, 1, page.TotalItems)
+ require.Len(t, items, 1)
+ assert.Equal(t, filepath.Join(linkPath, "sub-project1"), items[0].Path)
+ assert.Equal(t, "linked-root/sub-project1", items[0].RelativePath)
+ assert.Equal(t, targetPath, filepath.Join(targetRoot, "main-project", "sub-project1"))
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_RemovesSymlinkedProjectsWhenDisabled(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ targetRoot := t.TempDir()
+ linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
+ linkPath := filepath.Join(projectsRoot, "linked")
+ require.NoError(t, os.Symlink(linkTarget, linkPath))
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err = svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ assert.Empty(t, items)
+
+ _, statErr := os.Lstat(linkPath)
+ require.NoError(t, statErr)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_RefreshesServiceCountOnComposeChange(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectPath := createComposeProjectDir(t, projectsRoot, "demo")
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ var project models.Project
+ require.NoError(t, db.WithContext(ctx).Where("path = ?", projectPath).First(&project).Error)
+ assert.Equal(t, 1, project.ServiceCount)
+
+ updatedCompose := "services:\n app:\n image: nginx:alpine\n worker:\n image: busybox:latest\n"
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(updatedCompose), 0o644))
+
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ require.NoError(t, db.WithContext(ctx).Where("id = ?", project.ID).First(&project).Error)
+ assert.Equal(t, 2, project.ServiceCount)
+}
+
+func TestProjectService_SyncProjectsFromFileSystem_PreservesGitOpsProjectWithCustomComposeFilename(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ require.NoError(t, db.AutoMigrate(&models.GitOpsSync{}))
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectDir := filepath.Join(projectsRoot, "Radarr-3")
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))
+
+ syncProjectID := "proj-custom-compose"
+ syncID := "sync-custom-compose"
+ sync := &models.GitOpsSync{
+ BaseModel: models.BaseModel{ID: syncID},
+ Name: "Radarr Sync",
+ EnvironmentID: "0",
+ RepositoryID: "repo-1",
+ ComposePath: "apps/media/radarr.yaml",
+ ProjectName: "Radarr",
+ ProjectID: &syncProjectID,
+ SyncDirectory: true,
+ }
+ require.NoError(t, db.Create(sync).Error)
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: syncProjectID},
+ Name: "Radarr",
+ DirName: ptr("Radarr-3"),
+ Path: projectDir,
+ Status: models.ProjectStatusStopped,
+ GitOpsManagedBy: &syncID,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+
+ items, err := svc.ListAllProjects(ctx)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ assert.Equal(t, syncProjectID, items[0].ID)
+ assert.Equal(t, projectDir, items[0].Path)
+ assert.Equal(t, syncID, *items[0].GitOpsManagedBy)
+}
+
+func TestProjectService_GetProjectDetails_UsesGitOpsCustomComposeFilename(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+ require.NoError(t, db.AutoMigrate(&models.GitOpsSync{}))
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ projectsRoot := t.TempDir()
+ projectDir := filepath.Join(projectsRoot, "Radarr-3")
+ composeContent := "services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte(composeContent), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, ".env"), []byte("TZ=UTC\n"), 0o644))
+
+ syncProjectID := "proj-custom-compose-details"
+ syncID := "sync-custom-compose-details"
+ require.NoError(t, db.Create(&models.GitOpsSync{
+ BaseModel: models.BaseModel{ID: syncID},
+ Name: "Radarr Sync",
+ EnvironmentID: "0",
+ RepositoryID: "repo-1",
+ ComposePath: "apps/media/radarr.yaml",
+ ProjectName: "Radarr",
+ ProjectID: &syncProjectID,
+ SyncDirectory: true,
+ }).Error)
+
+ require.NoError(t, db.Create(&models.Project{
+ BaseModel: models.BaseModel{ID: syncProjectID},
+ Name: "Radarr",
+ DirName: ptr("Radarr-3"),
+ Path: projectDir,
+ Status: models.ProjectStatusStopped,
+ GitOpsManagedBy: &syncID,
+ }).Error)
+
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+
+ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+
+ composeFromContent, envFromContent, err := svc.GetProjectContent(ctx, syncProjectID)
+ require.NoError(t, err)
+ assert.Equal(t, composeContent, composeFromContent)
+ assert.Equal(t, "TZ=UTC\n", envFromContent)
+
+ details, err := svc.GetProjectDetails(ctx, syncProjectID, projecttypes.AllDetails())
+ require.NoError(t, err)
+ assert.Equal(t, "radarr.yaml", details.ComposeFileName)
+ assert.Equal(t, composeContent, details.ComposeContent)
+ assert.Equal(t, "TZ=UTC\n", details.EnvContent)
+ assert.Equal(t, 1, len(details.Services))
+}
+
+func TestProjectService_UpdateProject_WritesThroughSymlinkedProjectPath(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
- req, _, _, err := svc.prepareServiceBuildRequest(
- context.Background(),
- "project-id",
- proj,
- "web",
- serviceCfg,
- ProjectBuildOptions{},
- )
+ settingsService, err := NewSettingsService(ctx, db)
require.NoError(t, err)
- assert.Equal(t, "/app/data/projects/demo", req.ContextDir)
- assert.Equal(t, "/app/data/projects/demo/Dockerfile.custom", req.Dockerfile)
-}
+ projectsRoot := t.TempDir()
+ targetRoot := t.TempDir()
+ targetPath := createComposeProjectDir(t, targetRoot, "demo-target")
+ linkPath := filepath.Join(projectsRoot, "demo")
+ require.NoError(t, os.Symlink(targetPath, linkPath))
-// TestProjectService_PrepareServiceBuildRequest_BuildDotKeepsContainerPath
-// reproduces the exact configuration from #2314: a compose file with
-// `build: .` next to its Dockerfile, on an installation where the projects
-// directory is bind-mounted from a different host path than the container
-// path. The resulting BuildRequest must point at the container path so the
-// local builder can stat / tar the directory.
-func TestProjectService_PrepareServiceBuildRequest_BuildDotKeepsContainerPath(t *testing.T) {
- svc := &ProjectService{}
- proj := &composetypes.Project{WorkingDir: "/app/data/projects/caddy", Name: "caddy"}
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
- serviceCfg := composetypes.ServiceConfig{
- Name: "caddy",
- Image: "caddy",
- Build: &composetypes.BuildConfig{
- Context: ".",
- },
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-symlink-update"},
+ Name: "demo",
+ DirName: new("demo"),
+ Path: linkPath,
+ Status: models.ProjectStatusStopped,
}
+ require.NoError(t, db.Create(project).Error)
- req, _, _, err := svc.prepareServiceBuildRequest(
- context.Background(),
- "project-id",
- proj,
- "caddy",
- serviceCfg,
- ProjectBuildOptions{},
- )
+ updatedCompose := "services:\n app:\n image: nginx:1.27-alpine\n"
+ updatedEnv := "FOO=updated\n"
+
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, new(updatedCompose), new(updatedEnv), nil, nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
require.NoError(t, err)
+ require.NotNil(t, updated)
+ assert.Equal(t, linkPath, updated.Path)
- assert.Equal(t, "/app/data/projects/caddy", req.ContextDir)
- assert.Equal(t, "Dockerfile", req.Dockerfile)
+ composeBytes, readErr := os.ReadFile(filepath.Join(targetPath, "compose.yaml"))
+ require.NoError(t, readErr)
+ assert.Equal(t, updatedCompose, string(composeBytes))
+
+ envBytes, readErr := os.ReadFile(filepath.Join(targetPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, updatedEnv, string(envBytes))
}
-func TestProjectService_PrepareServiceBuildRequest_UsesInlineDockerfile(t *testing.T) {
- svc := &ProjectService{}
- proj := &composetypes.Project{WorkingDir: "/tmp/project", Name: "demo"}
+func createComposeProjectDir(t *testing.T, root, name string) string {
+ t.Helper()
- serviceCfg := composetypes.ServiceConfig{
- Name: "web",
- Image: "example/web:latest",
- Build: &composetypes.BuildConfig{
- Context: ".",
- DockerfileInline: "FROM alpine:3.20\nRUN echo inline\n",
- },
- }
+ projectPath := filepath.Join(root, name)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))
- req, _, _, err := svc.prepareServiceBuildRequest(
- context.Background(),
- "project-id",
- proj,
- "web",
- serviceCfg,
- ProjectBuildOptions{},
- )
- require.NoError(t, err)
+ return projectPath
+}
- assert.Equal(t, "/tmp/project", req.ContextDir)
- assert.Empty(t, req.Dockerfile)
- assert.Equal(t, "FROM alpine:3.20\nRUN echo inline\n", req.DockerfileInline)
+func configureProjectRuntimeDockerInternal(t *testing.T, containers []container.Summary) {
+ t.Helper()
+
+ server := newProjectRuntimeDockerServerInternal(t, containers)
+ t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURLInternal(t, server.URL))
}
-func TestNormalizePullPolicy(t *testing.T) {
- assert.Equal(t, "missing", normalizePullPolicy("if_not_present"))
- assert.Equal(t, "build", normalizePullPolicy(" BUILD "))
- assert.Equal(t, "", normalizePullPolicy(""))
+func projectUpdatePreviewDirsInternal(t *testing.T, projectsDir string) []string {
+ t.Helper()
+
+ matches, err := filepath.Glob(filepath.Join(projectsDir, ".project-update-preview-*"))
+ require.NoError(t, err)
+ return matches
}
-func TestDecideDeployImageAction(t *testing.T) {
- t.Run("build service with explicit build policy", func(t *testing.T) {
- svc := composetypes.ServiceConfig{
- PullPolicy: "build",
- Build: &composetypes.BuildConfig{Context: "."},
+func newProjectRuntimeDockerServerInternal(t *testing.T, containers []container.Summary) *httptest.Server {
+ t.Helper()
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/_ping"):
+ _, _ = io.WriteString(w, "OK")
+ case strings.HasSuffix(r.URL.Path, "/version"):
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]string{
+ "ApiVersion": "1.41",
+ "MinAPIVersion": "1.24",
+ "Version": "24.0.0",
+ })
+ case strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(containers)
+ case strings.Contains(r.URL.Path, "/containers/") && strings.HasSuffix(r.URL.Path, "/json"):
+ containerID := strings.TrimSuffix(strings.TrimPrefix(r.URL.Path[strings.LastIndex(r.URL.Path, "/containers/"):], "/containers/"), "/json")
+ for _, c := range containers {
+ if c.ID != containerID {
+ continue
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(container.InspectResponse{
+ ID: c.ID,
+ State: &container.State{
+ Status: c.State,
+ Running: c.State == container.StateRunning,
+ },
+ })
+ return
+ }
+ http.NotFound(w, r)
+ default:
+ http.NotFound(w, r)
}
+ }))
+ t.Cleanup(server.Close)
+ return server
+}
- decision := decideDeployImageAction(svc, "")
- assert.True(t, decision.Build)
- assert.False(t, decision.PullAlways)
- })
+func dockerHostFromProjectRuntimeServerURLInternal(t *testing.T, serverURL string) string {
+ t.Helper()
- t.Run("build service default policy uses pull then fallback build", func(t *testing.T) {
- svc := composetypes.ServiceConfig{Build: &composetypes.BuildConfig{Context: "."}}
- decision := decideDeployImageAction(svc, "")
- assert.True(t, decision.PullIfMissing)
- assert.True(t, decision.FallbackBuildOnPullFail)
- assert.False(t, decision.Build)
- })
+ parsed, err := url.Parse(serverURL)
+ require.NoError(t, err)
+ return "tcp://" + parsed.Host
+}
- t.Run("non-build service never policy requires local only", func(t *testing.T) {
- svc := composetypes.ServiceConfig{PullPolicy: "never"}
- decision := decideDeployImageAction(svc, "")
- assert.True(t, decision.RequireLocalOnly)
- assert.False(t, decision.PullIfMissing)
- })
+//go:fix inline
+func ptr(v string) *string {
+ return new(v)
+}
- t.Run("compose pull policy wins over deploy override", func(t *testing.T) {
- svc := composetypes.ServiceConfig{PullPolicy: "never"}
- decision := decideDeployImageAction(svc, "always")
- assert.True(t, decision.RequireLocalOnly)
- assert.False(t, decision.PullAlways)
- })
+func TestResolveRemoveOrphans(t *testing.T) {
+ tests := []struct {
+ name string
+ gitOpsManaged bool
+ options *projecttypes.DeployOptions
+ want bool
+ }{
+ {"non-gitops, nil options", false, nil, false},
+ {"non-gitops, flag false", false, &projecttypes.DeployOptions{RemoveOrphans: false}, false},
+ {"non-gitops, flag true opts in", false, &projecttypes.DeployOptions{RemoveOrphans: true}, true},
+ {"gitops, nil options stays true", true, nil, true},
+ {"gitops, flag false stays true", true, &projecttypes.DeployOptions{RemoveOrphans: false}, true},
+ {"gitops, flag true stays true", true, &projecttypes.DeployOptions{RemoveOrphans: true}, true},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ require.Equal(t, tt.want, resolveRemoveOrphansInternal(tt.gitOpsManaged, tt.options))
+ })
+ }
}
-func TestProjectService_PrepareServiceBuildRequest_GeneratedImageProviderGuardrails(t *testing.T) {
- svc := &ProjectService{}
- proj := &composetypes.Project{WorkingDir: "/tmp/project", Name: "demo"}
+func TestProjectService_UpdateProject_RenameRollsBackWhenFileRevisionIsStale(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
- serviceCfg := composetypes.ServiceConfig{
- Name: "web",
- Build: &composetypes.BuildConfig{
- Context: ".",
- },
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ configureProjectRuntimeDockerInternal(t, nil)
+
+ originalDirName := "Foo"
+ originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-stale-file-revision"},
+ Name: "Foo",
+ DirName: &originalDirName,
+ Path: originalPath,
+ Status: models.ProjectStatusStopped,
}
+ require.NoError(t, db.Create(project).Error)
- _, _, _, err := svc.prepareServiceBuildRequest(
- context.Background(),
- "project-id",
- proj,
- "web",
- serviceCfg,
- ProjectBuildOptions{Provider: "depot"},
- )
- require.Error(t, err)
- assert.Contains(t, err.Error(), "must define an image when using depot")
+ _, revision, err := projects.ReadProjectFileTree(project.Path, config.Load().ProjectFileTreeMaxDepth, config.Load().ProjectScanSkipDirs, "compose.yaml")
+ require.NoError(t, err)
+ require.NoError(t, os.WriteFile(filepath.Join(project.Path, "external.txt"), []byte("external\n"), 0o644))
+
+ content := "new\n"
+ _, err = svc.UpdateProject(ctx, project.ID, ptr("bar"), nil, nil, &revision, []projecttypes.ProjectFileChange{
+ {Operation: projecttypes.FileOpCreateFile, RelativePath: "notes.txt", Content: &content},
+ }, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
- _, _, _, err = svc.prepareServiceBuildRequest(
- context.Background(),
- "project-id",
- proj,
- "web",
- serviceCfg,
- ProjectBuildOptions{Provider: "local", Push: new(true)},
- )
require.Error(t, err)
- assert.Contains(t, err.Error(), "must define an image when push is enabled")
+ var conflictErr *common.ProjectFileConflictError
+ require.ErrorAs(t, err, &conflictErr)
+ require.DirExists(t, originalPath)
+ require.NoDirExists(t, filepath.Join(projectsDir, "bar"))
+ require.FileExists(t, filepath.Join(originalPath, "external.txt"))
+ require.NoFileExists(t, filepath.Join(originalPath, "notes.txt"))
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "Foo", fromDB.Name)
+ require.Equal(t, originalPath, fromDB.Path)
}
-func TestProjectService_DeployProject_StopsOnBuildPreparationError(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_RollsBackUncommittedDirectoryRename(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
- projectsRoot := t.TempDir()
- projectDir := filepath.Join(projectsRoot, "demo")
- require.NoError(t, os.MkdirAll(projectDir, 0o755))
- composeContent := "services:\n" +
- " web:\n" +
- " pull_policy: build\n" +
- " build:\n" +
- " context: .\n"
- require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte(composeContent), 0o644))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot+":"+projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
- proj := &models.Project{
- BaseModel: models.BaseModel{ID: "p1"},
- Name: "demo",
- Path: projectDir,
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-recovery"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
Status: models.ProjectStatusStopped,
}
- require.NoError(t, db.Create(proj).Error)
+ require.NoError(t, db.Create(project).Error)
- buildSvc := &BuildService{builder: testBuildBuilder{err: errors.New("boom build")}}
- svc := NewProjectService(db, settingsService, nil, nil, nil, buildSvc, config.Load())
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- err = svc.DeployProject(ctx, "p1", models.User{BaseModel: models.BaseModel{ID: "u1"}, Username: "tester"}, nil)
- require.Error(t, err)
- assert.Contains(t, err.Error(), "failed to prepare project images for deploy")
- assert.Contains(t, err.Error(), "boom build")
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- var updated models.Project
- require.NoError(t, db.First(&updated, "id = ?", "p1").Error)
- assert.Equal(t, models.ProjectStatusStopped, updated.Status)
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
}
-func TestProjectService_DeployProject_BuildsGeneratedImageWithoutPull(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_StartedPhaseSkipsVolumeRollback(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
- projectsRoot := t.TempDir()
- projectDir := filepath.Join(projectsRoot, "demo")
- require.NoError(t, os.MkdirAll(projectDir, 0o755))
- composeContent := "services:\n" +
- " caddy:\n" +
- " build:\n" +
- " dockerfile_inline: |\n" +
- " FROM caddy:builder AS builder\n" +
- " RUN xcaddy build --with github.com/caddyserver/replace-response\n" +
- "\n" +
- " FROM caddy:latest\n" +
- " COPY --from=builder /usr/bin/caddy /usr/bin/caddy\n"
- require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte(composeContent), 0o644))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot+":"+projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(oldPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(oldPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
- proj := &models.Project{
- BaseModel: models.BaseModel{ID: "p-generated"},
- Name: "build-test",
- Path: projectDir,
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-started-volume-recovery"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
Status: models.ProjectStatusStopped,
}
- require.NoError(t, db.Create(proj).Error)
-
- buildSvc := &BuildService{builder: testBuildBuilder{err: errors.New("boom build")}}
- svc := NewProjectService(db, settingsService, nil, nil, nil, buildSvc, config.Load())
-
- err = svc.DeployProject(ctx, proj.ID, models.User{BaseModel: models.BaseModel{ID: "u1"}, Username: "tester"}, nil)
- require.Error(t, err)
- assert.Contains(t, err.Error(), "failed to prepare project images for deploy")
- assert.Contains(t, err.Error(), "boom build")
- assert.NotContains(t, err.Error(), "failed to pull image arcane.local/")
- assert.NotContains(t, err.Error(), "failed to resolve reference \"arcane.local/")
-}
+ require.NoError(t, db.Create(project).Error)
-func TestResolveBuildContextInternal_AllowsRemoteGitContext(t *testing.T) {
- svc := composetypes.ServiceConfig{
- Build: &composetypes.BuildConfig{
- Context: "https://github.com/getarcaneapp/arcane.git#main:docker/app",
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseStartedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
},
}
-
- contextDir, err := resolveBuildContextInternal("/projects/demo", svc, "web")
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- assert.Equal(t, "https://github.com/getarcaneapp/arcane.git#main:docker/app", contextDir)
-}
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
-func TestResolveBuildContextInternal_AllowsRemoteGitContextWithoutGitSuffix(t *testing.T) {
- svc := composetypes.ServiceConfig{
- Build: &composetypes.BuildConfig{
- Context: "https://git.sr.ht/~jordanreger/nws-alerts#main:docker/app",
- },
- }
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- contextDir, err := resolveBuildContextInternal("/projects/demo", svc, "web")
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Equal(t, "https://git.sr.ht/~jordanreger/nws-alerts#main:docker/app", contextDir)
+ require.False(t, ok)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
}
-func TestProjectService_SyncProjectsFromFileSystem_IgnoresSymlinkedProjectDirsWhenDisabled(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_RelocatesTargetWhenBothPathsExist(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(oldPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(oldPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, "regular")
- linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
- require.NoError(t, os.Symlink(linkTarget, filepath.Join(projectsRoot, "linked")))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-both-paths"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseStartedInternal,
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- items, err := svc.ListAllProjects(ctx)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- require.Len(t, items, 1)
- assert.Equal(t, "regular", items[0].Name)
- assert.Equal(t, filepath.Join(projectsRoot, "regular"), items[0].Path)
+ require.False(t, ok)
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
+
+ conflictPaths, err := filepath.Glob(filepath.Join(projectsDir, ".web.rename-conflict-*"))
+ require.NoError(t, err)
+ require.Len(t, conflictPaths, 1)
+ require.FileExists(t, filepath.Join(conflictPaths[0], "compose.yaml"))
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
+
+ newName := "web"
+ require.NoError(t, svc.applyProjectRenameIfNeeded(&fromDB, &newName, projectsDir))
+ require.Equal(t, "web", fromDB.Name)
+ require.Equal(t, newPath, fromDB.Path)
+ require.DirExists(t, newPath)
}
-func TestProjectService_SyncProjectsFromFileSystem_DetectsSymlinkedProjectDirsWhenEnabled(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsStartedJournalWhenDirectoryPathsMissing(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
- linkPath := filepath.Join(projectsRoot, "linked")
- require.NoError(t, os.Symlink(linkTarget, linkPath))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-missing-paths"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseStartedInternal,
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- items, err := svc.ListAllProjects(ctx)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- require.Len(t, items, 1)
- assert.Equal(t, "linked", items[0].Name)
- assert.Equal(t, linkPath, items[0].Path)
+ require.False(t, ok)
+ require.NoDirExists(t, oldPath)
+ require.NoDirExists(t, newPath)
}
-func TestProjectService_CountProjectFolders_RespectsFollowProjectSymlinks(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsPreservedTargetJournalWhenPathExists(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, "regular")
- linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
- require.NoError(t, os.Symlink(linkTarget, filepath.Join(projectsRoot, "linked")))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(oldPath, 0o755))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-preserved-target"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ var targetRemoved bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved = true
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
- count, err := svc.countProjectFolders(ctx)
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, &DockerClientService{client: newTestDockerClient(t, server)}, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- assert.Equal(t, 1, count)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
- count, err = svc.countProjectFolders(ctx)
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Equal(t, 2, count)
+ require.False(t, ok)
+ require.False(t, targetRemoved, "preserved target volume should remain for manual inspection")
+ require.DirExists(t, oldPath)
}
-func TestProjectService_SyncProjectsFromFileSystem_DiscoversNestedProjectsAndRelativePaths(t *testing.T) {
+func TestProjectRenameJournalTargetsCopiedInternal(t *testing.T) {
+ require.False(t, projectRenameJournalTargetsCopiedInternal(projectRenameJournalPhaseStartedInternal))
+ require.False(t, projectRenameJournalTargetsCopiedInternal(projectRenameJournalPhaseProjectStateRolledBackInternal))
+ require.True(t, projectRenameJournalTargetsCopiedInternal(projectRenameJournalPhaseSourceCleanupPendingInternal))
+ require.True(t, projectRenameJournalTargetsCopiedInternal(projectRenameJournalPhaseTargetsCopiedInternal))
+ require.True(t, projectRenameJournalTargetsCopiedInternal(projectRenameJournalPhaseOldVolumesRemovedInternal))
+ require.True(t, projectRenameJournalTargetsCopiedInternal(projectRenameJournalPhaseProjectStateCommittedInternal))
+}
+
+func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournal(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- nestedPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
- topLevelPath := createComposeProjectDir(t, projectsRoot, "project2")
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-committed"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
- SortParams: pagination.SortParams{Sort: "path", Order: pagination.SortAsc},
- Params: pagination.Params{Limit: -1},
- })
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseOldVolumesRemovedInternal,
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- require.EqualValues(t, 2, page.TotalItems)
- require.Len(t, items, 2)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- assert.Equal(t, "main-project/sub-project1", items[0].RelativePath)
- assert.Equal(t, nestedPath, items[0].Path)
- assert.Equal(t, "sub-project1", items[0].DirName)
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- assert.Equal(t, "project2", items[1].RelativePath)
- assert.Equal(t, topLevelPath, items[1].Path)
- assert.Equal(t, "project2", items[1].DirName)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
+ require.DirExists(t, newPath)
}
-func TestProjectService_SyncProjectsFromFileSystem_RespectsConfiguredScanMaxDepth(t *testing.T) {
+func TestProjectService_FinalizeProjectRenameAfterCommit_ClearsJournalAfterSourceCleanup(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
+ oldDir := "nginx"
+ newDir := "web"
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-old-volumes-removed"},
+ Name: "web",
+ DirName: &newDir,
+ Path: filepath.Join(t.TempDir(), newDir),
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := &projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: filepath.Join(t.TempDir(), oldDir),
+ NewPath: project.Path,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ }
+ require.NoError(t, svc.writeProjectRenameJournalInternal(ctx, journal, projectRenameJournalPhaseTargetsCopiedInternal))
+
+ migration := &fakeProjectVolumeRenameMigrationInternal{}
+ journalActive := true
+ svc.finalizeProjectRenameAfterCommitInternal(ctx, project.ID, migration, journal, &journalActive)
+ require.True(t, migration.commitCalled)
+ require.False(t, journalActive)
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
+ require.False(t, ok)
+}
- projectsRoot := t.TempDir()
- topLevelPath := createComposeProjectDir(t, projectsRoot, "project1")
- createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
+func TestProjectService_FinalizeProjectRenameAfterCommit_KeepsJournalWhenSourceCleanupFails(t *testing.T) {
+ db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
+ ctx := context.Background()
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
+ oldDir := "nginx"
+ newDir := "web"
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-cleanup-failure"},
+ Name: "web",
+ DirName: &newDir,
+ Path: filepath.Join(t.TempDir(), newDir),
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := &projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: filepath.Join(t.TempDir(), oldDir),
+ NewPath: project.Path,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ }
+ require.NoError(t, svc.writeProjectRenameJournalInternal(ctx, journal, projectRenameJournalPhaseTargetsCopiedInternal))
- items, err := svc.ListAllProjects(ctx)
- require.NoError(t, err)
- require.Len(t, items, 1)
- assert.Equal(t, "project1", items[0].Name)
- assert.Equal(t, topLevelPath, items[0].Path)
+ migration := &fakeProjectVolumeRenameMigrationInternal{
+ commitErr: volumes.NewSourceCleanupError("nginx_data", errors.New("source cleanup failed")),
+ }
+ journalActive := true
+ svc.finalizeProjectRenameAfterCommitInternal(ctx, project.ID, migration, journal, &journalActive)
+ require.True(t, migration.commitCalled)
+ require.True(t, journalActive)
+
+ raw, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.True(t, ok)
+
+ var updatedJournal projectRenameJournalInternal
+ require.NoError(t, json.Unmarshal([]byte(raw), &updatedJournal))
+ require.Equal(t, projectRenameJournalPhaseSourceCleanupPendingInternal, updatedJournal.Phase)
}
-func TestProjectService_ListProjects_LoadsProjectIconFromGlobalEnvInIncludedMetadata(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_KeepsJournalWhenDirectoryRollbackFails(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ var targetRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ if targetRemoved.Load() {
+ http.NotFound(w, r)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- projectsRoot := t.TempDir()
- projectPath := filepath.Join(projectsRoot, "demo")
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, "missing-parent", oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
- require.NoError(t, os.WriteFile(
- filepath.Join(projectsRoot, projects.GlobalEnvFileName),
- []byte("ICON_CDN_URL=https://cdn.jsdelivr.net/gh/selfhst/icons@main\n"),
- 0o600,
- ))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-directory-rollback-fails"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(`include:
- - metadata.yaml
-services:
- watchtower:
- image: nickfedor/watchtower:latest
-`), 0o600))
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "metadata.yaml"), []byte(`x-watchtower-icon-light: &watchtower-icon "${ICON_CDN_URL:+${ICON_CDN_URL}/svg/watchtower.svg}"
-x-arcane:
- icon-light: *watchtower-icon
- icon-dark: *watchtower-icon
-services:
- watchtower:
- labels:
- com.getarcaneapp.arcane.icon-light: *watchtower-icon
- com.getarcaneapp.arcane.icon-dark: *watchtower-icon
-`), 0o600))
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "rollback project directory rename")
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.True(t, ok)
+ require.True(t, targetRemoved.Load(), "target volume rollback should still run after directory rollback fails")
+ require.FileExists(t, filepath.Join(newPath, "compose.yaml"), "failed directory rollback leaves the target path for retry")
+ require.NoDirExists(t, oldPath)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
- items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
- SortParams: pagination.SortParams{Sort: "path", Order: pagination.SortAsc},
- Params: pagination.Params{Limit: -1},
- })
+ require.NoError(t, os.MkdirAll(filepath.Dir(oldPath), 0o755))
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
+
+ _, ok, err = kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- require.EqualValues(t, 1, page.TotalItems)
- require.Len(t, items, 1)
- assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconLightURL)
- assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconDarkURL)
+ require.False(t, ok)
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
}
-func TestProjectService_CountProjectFolders_RecursivelyCountsNestedProjects(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_CompletesCommittedVolumeJournalWithoutHelperImage(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ var imageInspectCalled atomic.Bool
+ var oldVolumeRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ oldVolumeRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case strings.Contains(r.URL.Path, "/images/"):
+ imageInspectCalled.Store(true)
+ http.NotFound(w, r)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- projectsRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
- createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project2"))
- createComposeProjectDir(t, projectsRoot, "project2")
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-committed-with-volumes"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseOldVolumesRemovedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- count, err := svc.countProjectFolders(ctx)
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Equal(t, 3, count)
+ require.False(t, ok)
+ require.True(t, oldVolumeRemoved.Load(), "expected committed recovery to remove source volume")
+ require.False(t, imageInspectCalled.Load(), "completion recovery should not inspect or pull the copy helper image")
}
-func TestProjectService_CountProjectFolders_RespectsConfiguredScanMaxDepth(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_RollsBackCommittedJournalWhenTargetMissingAndSourceExists(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ var oldVolumeRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ oldVolumeRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- projectsRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, "project1")
- createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-missing-target-preserve-source"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseOldVolumesRemovedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- count, err := svc.countProjectFolders(ctx)
+ err = svc.RecoverProjectRenameJournals(ctx)
require.NoError(t, err)
- assert.Equal(t, 1, count)
+ require.False(t, oldVolumeRemoved.Load(), "source volume is the only remaining copy and must not be deleted")
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
+ require.DirExists(t, oldPath)
+ require.NoDirExists(t, newPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
}
-func TestProjectService_SyncProjectsFromFileSystem_RemovesDeletedNestedProject(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsJournalAfterDBRestoreWhenVolumeRollbackFails(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ var targetRemoveAttempts atomic.Int32
+ var targetExists atomic.Bool
+ var allowTargetRemove atomic.Bool
+ targetExists.Store(true)
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ if !targetExists.Load() {
+ http.NotFound(w, r)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ targetRemoveAttempts.Add(1)
+ if allowTargetRemove.Load() {
+ targetExists.Store(false)
+ w.WriteHeader(http.StatusNoContent)
+ return
+ }
+ http.Error(w, "volume busy", http.StatusInternalServerError)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- projectsRoot := t.TempDir()
- projectPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-rollback-volume-fail"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseProjectStateCommittedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ {
+ Key: "cache",
+ OldName: "nginx_cache",
+ NewName: "web_cache",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- items, err := svc.ListAllProjects(ctx)
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.Error(t, err)
+ require.ErrorContains(t, err, "remove rollback target volume web_cache")
+
+ require.Positive(t, targetRemoveAttempts.Load())
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- require.Len(t, items, 1)
+ require.False(t, ok, "project-state journal should clear after database rollback succeeds")
+ _, ok, err = kvService.Get(ctx, projectRenameRollbackCleanupKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.True(t, ok, "target cleanup should keep retry state when removal fails")
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
- require.NoError(t, os.Remove(filepath.Join(projectPath, "compose.yaml")))
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
- items, err = svc.ListAllProjects(ctx)
+ allowTargetRemove.Store(true)
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
+
+ _, ok, err = kvService.Get(ctx, projectRenameRollbackCleanupKeyInternal(project.ID))
require.NoError(t, err)
- assert.Empty(t, items)
+ require.False(t, ok)
+ require.False(t, targetExists.Load())
}
-func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectsWhenDirectoryEmptyOrUnmounted(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_KeepsRollbackCleanupWhenDockerUnavailable(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ require.NoError(t, os.MkdirAll(oldPath, 0o755))
- // An existing-but-empty projects directory simulates a mis-mapped or unmounted
- // projects volume: GetProjectsDirectory resolves (and MkdirAll's) it, discovery
- // finds nothing, and every stored project path is now missing on disk.
- projectsRoot := t.TempDir()
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-rollback-cleanup-docker-unavailable"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- // Seed a small deployment's worth of filesystem-managed projects whose
- // directories do not exist. Each would individually be pruned as "directory no
- // longer exists"; together they would wipe the table — exactly what the
- // mass-wipe guard must prevent, even for deployments with only a handful of
- // projects (the guard must not give small installs a free pass).
- const seeded = 3
- for i := range seeded {
- require.NoError(t, db.WithContext(ctx).Create(&models.Project{
- Name: fmt.Sprintf("project-%d", i),
- Path: filepath.Join(projectsRoot, fmt.Sprintf("project-%d", i)),
- Status: models.ProjectStatusStopped,
- }).Error)
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ cleanup := projectRenameRollbackCleanupInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ OldPath: oldPath,
+ NewName: "web",
+ NewPath: filepath.Join(projectsDir, "web"),
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
}
+ payload, err := json.Marshal(cleanup)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameRollbackCleanupKeyInternal(project.ID), string(payload)))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.Error(t, err)
+ require.ErrorContains(t, err, "docker service unavailable")
- items, err := svc.ListAllProjects(ctx)
+ _, ok, err := kvService.Get(ctx, projectRenameRollbackCleanupKeyInternal(project.ID))
require.NoError(t, err)
- assert.Len(t, items, seeded, "an empty/mis-mapped projects directory must not wipe existing project records")
+ require.True(t, ok)
}
-func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectWithAmbiguousCustomCompose(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournalWhenSourceAndTargetMissing(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- projectPath := createComposeProjectDir(t, projectsRoot, "ambiguous-project")
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-missing-both-volumes"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- items, err := svc.ListAllProjects(ctx)
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseProjectStateCommittedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- require.Len(t, items, 1)
-
- // Replace the standard compose.yaml with two custom-named compose files. The
- // directory still holds compose content, but DetectComposeFile can't pick one
- // and returns common.AmbiguousComposeFileError. The reconcile must NOT delete the
- // record: the project's files are intact on disk and it may be deployable.
- require.NoError(t, os.Remove(filepath.Join(projectPath, "compose.yaml")))
- composeBody := []byte("services:\n app:\n image: nginx:alpine\n")
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "app.yaml"), composeBody, 0o644))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "extra.yaml"), composeBody, 0o644))
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.NoError(t, err)
- items, err = svc.ListAllProjects(ctx)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Len(t, items, 1, "project with ambiguous compose files must not be deleted")
- assert.Equal(t, projectPath, items[0].Path)
+ require.False(t, ok)
+ require.DirExists(t, newPath)
+ require.NoDirExists(t, oldPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "web", fromDB.Name)
+ require.Equal(t, newPath, fromDB.Path)
}
-func TestProjectService_SyncProjectsFromFileSystem_RemovesProjectsBeyondReducedScanMaxDepth(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournalAndCleansRemainingSourcesWhenSomeVolumesExternallyRemoved(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- topLevelPath := createComposeProjectDir(t, projectsRoot, "project1")
- nestedPath := createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))
+ var cacheSourceRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_cache"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ cacheSourceRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- // Initial sync at the default scan depth discovers both the top-level and
- // the nested project, persisting them to the database.
- defaultSvc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, defaultSvc.SyncProjectsFromFileSystem(ctx))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-mixed-missing-volumes"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- items, err := defaultSvc.ListAllProjects(ctx)
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseProjectStateCommittedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ {
+ Key: "cache",
+ OldName: "nginx_cache",
+ NewName: "web_cache",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- require.Len(t, items, 2)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- // Lowering the scan depth must prune the nested project from the database on
- // the next sync, even though its compose file still exists on disk.
- t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
- depthLimitedSvc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, depthLimitedSvc.SyncProjectsFromFileSystem(ctx))
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.NoError(t, err)
- items, err = depthLimitedSvc.ListAllProjects(ctx)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- require.Len(t, items, 1)
- assert.Equal(t, "project1", items[0].Name)
- assert.Equal(t, topLevelPath, items[0].Path)
+ require.False(t, ok)
+ require.True(t, cacheSourceRemoved.Load(), "source volume should still be cleaned up when the target exists")
+ require.DirExists(t, newPath)
+ require.NoDirExists(t, oldPath)
- // The pruned project's files must remain untouched on disk so raising the
- // depth again re-discovers it.
- assert.FileExists(t, filepath.Join(nestedPath, "compose.yaml"))
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "web", fromDB.Name)
+ require.Equal(t, newPath, fromDB.Path)
}
-func TestProjectService_SyncProjectsFromFileSystem_PreservesDBRecordsWhenDirectoryUnreadable(t *testing.T) {
- if runtime.GOOS == "windows" {
- t.Skip("POSIX permission-denied behavior is not portable to Windows")
- }
- if os.Geteuid() == 0 {
- t.Skip("test requires a non-root UID to trigger permission-denied on ReadDir")
- }
-
+func TestProjectService_RecoverProjectRenameJournals_MarksSourceCleanupPendingWhenCommittedCleanupFails(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- createComposeProjectDir(t, projectsRoot, "project1")
+ var sourceRemoveAttempts atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ sourceRemoveAttempts.Add(1)
+ http.Error(w, "volume busy", http.StatusInternalServerError)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-source-cleanup-fail"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- before, err := svc.ListAllProjects(ctx)
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseProjectStateCommittedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- require.Len(t, before, 1)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- unreadable := t.TempDir()
- require.NoError(t, os.Chmod(unreadable, 0))
- t.Cleanup(func() { _ = os.Chmod(unreadable, 0o700) })
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.Error(t, err)
+ var cleanupErr *volumes.SourceCleanupError
+ require.ErrorAs(t, err, &cleanupErr)
+ require.Equal(t, "nginx_data", cleanupErr.SourceVolume)
+ require.Positive(t, sourceRemoveAttempts.Load())
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", unreadable))
+ raw, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.True(t, ok)
- syncErr := svc.SyncProjectsFromFileSystem(ctx)
- require.Error(t, syncErr, "sync should propagate the permission-denied error")
+ var updatedJournal projectRenameJournalInternal
+ require.NoError(t, json.Unmarshal([]byte(raw), &updatedJournal))
+ require.Equal(t, projectRenameJournalPhaseSourceCleanupPendingInternal, updatedJournal.Phase)
+ require.DirExists(t, newPath)
+ require.NoDirExists(t, oldPath)
- after, err := svc.ListAllProjects(ctx)
- require.NoError(t, err)
- assert.Len(t, after, 1, "DB records must not be wiped when discovery fails")
- assert.Equal(t, before[0].Path, after[0].Path)
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "web", fromDB.Name)
+ require.Equal(t, newPath, fromDB.Path)
}
-func TestProjectService_SyncProjectsFromFileSystem_AllowsDuplicateLeafDirectoriesInDifferentParents(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsSourceCleanupPendingJournalAfterCleanup(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ var sourceRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ sourceRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- projectsRoot := t.TempDir()
- firstPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project1", "app"))
- secondPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project2", "app"))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-source-cleanup-pending-clear"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseSourceCleanupPendingInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- var items []models.Project
- require.NoError(t, db.WithContext(ctx).Order("path asc").Find(&items).Error)
- require.Len(t, items, 2)
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.NoError(t, err)
- require.NotNil(t, items[0].DirName)
- require.NotNil(t, items[1].DirName)
- assert.Equal(t, "app", *items[0].DirName)
- assert.Equal(t, "app", *items[1].DirName)
- assert.Equal(t, firstPath, items[0].Path)
- assert.Equal(t, secondPath, items[1].Path)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
+ require.True(t, sourceRemoved.Load())
+ require.DirExists(t, newPath)
+ require.NoDirExists(t, oldPath)
}
-func TestProjectService_SyncProjectsFromFileSystem_DetectsNestedSymlinkedProjectDirsWhenEnabled(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_RollsBackSourceCleanupPendingWhenTargetMissing(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
+ var dataSourceRemoved atomic.Bool
+ var dataTargetRemoved atomic.Bool
+ var cacheTargetRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ dataSourceRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ dataTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ cacheTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- targetPath := createComposeProjectDir(t, targetRoot, filepath.Join("main-project", "sub-project1"))
- linkPath := filepath.Join(projectsRoot, "linked-root")
- require.NoError(t, os.Symlink(filepath.Join(targetRoot, "main-project"), linkPath))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-source-cleanup-target-missing"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseSourceCleanupPendingInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ {
+ Key: "cache",
+ OldName: "nginx_cache",
+ NewName: "web_cache",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
- SortParams: pagination.SortParams{Sort: "path", Order: pagination.SortAsc},
- Params: pagination.Params{Limit: -1},
- })
+ err = svc.RecoverProjectRenameJournals(ctx)
require.NoError(t, err)
- require.EqualValues(t, 1, page.TotalItems)
- require.Len(t, items, 1)
- assert.Equal(t, filepath.Join(linkPath, "sub-project1"), items[0].Path)
- assert.Equal(t, "linked-root/sub-project1", items[0].RelativePath)
- assert.Equal(t, targetPath, filepath.Join(targetRoot, "main-project", "sub-project1"))
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
+ _, ok, err = kvService.Get(ctx, projectRenameRollbackCleanupKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
+ require.False(t, dataSourceRemoved.Load(), "source volume is the remaining data copy and must not be removed")
+ require.False(t, dataTargetRemoved.Load(), "missing target should not be removed")
+ require.True(t, cacheTargetRemoved.Load(), "safe target volume should still be cleaned during rollback")
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
+ require.NotNil(t, fromDB.DirName)
+ require.Equal(t, oldDir, *fromDB.DirName)
}
-func TestProjectService_SyncProjectsFromFileSystem_RemovesSymlinkedProjectsWhenDisabled(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_KeepsSourceCleanupPendingJournalWhenCleanupFails(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
- linkPath := filepath.Join(projectsRoot, "linked")
- require.NoError(t, os.Symlink(linkTarget, linkPath))
+ var sourceRemoveAttempts atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ sourceRemoveAttempts.Add(1)
+ http.Error(w, "volume busy", http.StatusInternalServerError)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-source-cleanup-pending-fail"},
+ Name: "web",
+ DirName: &newDir,
+ Path: newPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- items, err := svc.ListAllProjects(ctx)
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseSourceCleanupPendingInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- require.Len(t, items, 1)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.Error(t, err)
+ var cleanupErr *volumes.SourceCleanupError
+ require.ErrorAs(t, err, &cleanupErr)
+ require.Equal(t, "nginx_data", cleanupErr.SourceVolume)
+ require.Positive(t, sourceRemoveAttempts.Load())
- items, err = svc.ListAllProjects(ctx)
+ raw, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Empty(t, items)
+ require.True(t, ok)
- _, statErr := os.Lstat(linkPath)
- require.NoError(t, statErr)
+ var updatedJournal projectRenameJournalInternal
+ require.NoError(t, json.Unmarshal([]byte(raw), &updatedJournal))
+ require.Equal(t, projectRenameJournalPhaseSourceCleanupPendingInternal, updatedJournal.Phase)
+ require.DirExists(t, newPath)
+ require.NoDirExists(t, oldPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "web", fromDB.Name)
+ require.Equal(t, newPath, fromDB.Path)
}
-func TestProjectService_SyncProjectsFromFileSystem_RefreshesServiceCountOnComposeChange(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsStartedJournalWhenDirectoriesAreMissing(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- projectPath := createComposeProjectDir(t, projectsRoot, "demo")
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-missing-directories"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- var project models.Project
- require.NoError(t, db.WithContext(ctx).Where("path = ?", projectPath).First(&project).Error)
- assert.Equal(t, 1, project.ServiceCount)
+ kvService := NewKVService(db)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseStartedInternal,
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- updatedCompose := "services:\n app:\n image: nginx:alpine\n worker:\n image: busybox:latest\n"
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(updatedCompose), 0o644))
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
- require.NoError(t, db.WithContext(ctx).Where("id = ?", project.ID).First(&project).Error)
- assert.Equal(t, 2, project.ServiceCount)
+ require.NoDirExists(t, oldPath)
+ require.NoDirExists(t, newPath)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok)
}
-func TestProjectService_SyncProjectsFromFileSystem_PreservesGitOpsProjectWithCustomComposeFilename(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsMissingPathJournalWhenTargetPreserved(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- require.NoError(t, db.AutoMigrate(&models.GitOpsSync{}))
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- projectDir := filepath.Join(projectsRoot, "Radarr-3")
- require.NoError(t, os.MkdirAll(projectDir, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))
+ var targetRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- syncProjectID := "proj-custom-compose"
- syncID := "sync-custom-compose"
- sync := &models.GitOpsSync{
- BaseModel: models.BaseModel{ID: syncID},
- Name: "Radarr Sync",
- EnvironmentID: "0",
- RepositoryID: "repo-1",
- ComposePath: "apps/media/radarr.yaml",
- ProjectName: "Radarr",
- ProjectID: &syncProjectID,
- SyncDirectory: true,
- }
- require.NoError(t, db.Create(sync).Error)
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
project := &models.Project{
- BaseModel: models.BaseModel{ID: syncProjectID},
- Name: "Radarr",
- DirName: ptr("Radarr-3"),
- Path: projectDir,
- Status: models.ProjectStatusStopped,
- GitOpsManagedBy: &syncID,
+ BaseModel: models.BaseModel{ID: "proj-rename-missing-path-preserved-target"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
- require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- items, err := svc.ListAllProjects(ctx)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- require.Len(t, items, 1)
- assert.Equal(t, syncProjectID, items[0].ID)
- assert.Equal(t, projectDir, items[0].Path)
- assert.Equal(t, syncID, *items[0].GitOpsManagedBy)
+ require.False(t, ok)
+ require.False(t, targetRemoved.Load(), "target volume may be the only complete copy and must stay when source restore fails")
+ require.NoDirExists(t, oldPath)
+ require.NoDirExists(t, newPath)
+
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
}
-func TestProjectService_GetProjectDetails_UsesGitOpsCustomComposeFilename(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenRollbackSourceInspectFails(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- require.NoError(t, db.AutoMigrate(&models.GitOpsSync{}))
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- projectDir := filepath.Join(projectsRoot, "Radarr-3")
- composeContent := "services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"
- require.NoError(t, os.MkdirAll(projectDir, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte(composeContent), 0o644))
- require.NoError(t, os.WriteFile(filepath.Join(projectDir, ".env"), []byte("TZ=UTC\n"), 0o644))
+ var targetRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.Error(w, "temporary docker error", http.StatusInternalServerError)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- syncProjectID := "proj-custom-compose-details"
- syncID := "sync-custom-compose-details"
- require.NoError(t, db.Create(&models.GitOpsSync{
- BaseModel: models.BaseModel{ID: syncID},
- Name: "Radarr Sync",
- EnvironmentID: "0",
- RepositoryID: "repo-1",
- ComposePath: "apps/media/radarr.yaml",
- ProjectName: "Radarr",
- ProjectID: &syncProjectID,
- SyncDirectory: true,
- }).Error)
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(oldPath, 0o755))
- require.NoError(t, db.Create(&models.Project{
- BaseModel: models.BaseModel{ID: syncProjectID},
- Name: "Radarr",
- DirName: ptr("Radarr-3"),
- Path: projectDir,
- Status: models.ProjectStatusStopped,
- GitOpsManagedBy: &syncID,
- }).Error)
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-source-inspect-preserve"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- composeFromContent, envFromContent, err := svc.GetProjectContent(ctx, syncProjectID)
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
require.NoError(t, err)
- assert.Equal(t, composeContent, composeFromContent)
- assert.Equal(t, "TZ=UTC\n", envFromContent)
+ require.False(t, ok, "inspect uncertainty should not permanently block future renames")
+ require.False(t, targetRemoved.Load(), "target volume must not be deleted when source inspection is uncertain")
+ require.DirExists(t, oldPath)
+ require.NoDirExists(t, newPath)
- details, err := svc.GetProjectDetails(ctx, syncProjectID, projecttypes.AllDetails())
- require.NoError(t, err)
- assert.Equal(t, "radarr.yaml", details.ComposeFileName)
- assert.Equal(t, composeContent, details.ComposeContent)
- assert.Equal(t, "TZ=UTC\n", details.EnvContent)
- assert.Equal(t, 1, len(details.Services))
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
}
-func TestProjectService_UpdateProject_WritesThroughSymlinkedProjectPath(t *testing.T) {
+func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenRollbackTargetInspectFails(t *testing.T) {
db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
ctx := context.Background()
- settingsService, err := NewSettingsService(ctx, db)
- require.NoError(t, err)
-
- projectsRoot := t.TempDir()
- targetRoot := t.TempDir()
- targetPath := createComposeProjectDir(t, targetRoot, "demo-target")
- linkPath := filepath.Join(projectsRoot, "demo")
- require.NoError(t, os.Symlink(targetPath, linkPath))
-
- require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
- require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))
+ var targetRemoved atomic.Bool
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.Error(w, "temporary docker error", http.StatusInternalServerError)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
- eventService := NewEventService(db, nil, nil)
- svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(oldPath, 0o755))
project := &models.Project{
- BaseModel: models.BaseModel{ID: "proj-symlink-update"},
- Name: "demo",
- DirName: new("demo"),
- Path: linkPath,
+ BaseModel: models.BaseModel{ID: "proj-rename-target-inspect-preserve"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
Status: models.ProjectStatusStopped,
}
require.NoError(t, db.Create(project).Error)
- updatedCompose := "services:\n app:\n image: nginx:1.27-alpine\n"
- updatedEnv := "FOO=updated\n"
-
- updated, err := svc.UpdateProject(ctx, project.ID, nil, new(updatedCompose), new(updatedEnv), nil, nil, models.User{
- BaseModel: models.BaseModel{ID: "u1"},
- Username: "tester",
- })
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+ payload, err := json.Marshal(journal)
require.NoError(t, err)
- require.NotNil(t, updated)
- assert.Equal(t, linkPath, updated.Path)
-
- composeBytes, readErr := os.ReadFile(filepath.Join(targetPath, "compose.yaml"))
- require.NoError(t, readErr)
- assert.Equal(t, updatedCompose, string(composeBytes))
-
- envBytes, readErr := os.ReadFile(filepath.Join(targetPath, ".env"))
- require.NoError(t, readErr)
- assert.Equal(t, updatedEnv, string(envBytes))
-}
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
-func createComposeProjectDir(t *testing.T, root, name string) string {
- t.Helper()
+ require.NoError(t, svc.RecoverProjectRenameJournals(ctx))
- projectPath := filepath.Join(root, name)
- require.NoError(t, os.MkdirAll(projectPath, 0o755))
- require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok, "inspect uncertainty should not permanently block future renames")
+ require.False(t, targetRemoved.Load(), "target volume must not be deleted when target inspection is uncertain")
+ require.DirExists(t, oldPath)
+ require.NoDirExists(t, newPath)
- return projectPath
+ var fromDB models.Project
+ require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
+ require.Equal(t, "nginx", fromDB.Name)
+ require.Equal(t, oldPath, fromDB.Path)
}
-func newProjectRuntimeDockerServerInternal(t *testing.T, containers []container.Summary) *httptest.Server {
- t.Helper()
+func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenTargetPreservedAndDirectoryRolledBack(t *testing.T) {
+ db := setupProjectTestDB(t)
+ require.NoError(t, db.AutoMigrate(&models.KVEntry{}))
+ ctx := context.Background()
+ var targetRemoved atomic.Bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
- case strings.HasSuffix(r.URL.Path, "/_ping"):
- _, _ = io.WriteString(w, "OK")
- case strings.HasSuffix(r.URL.Path, "/version"):
- w.Header().Set("Content-Type", "application/json")
- _ = json.NewEncoder(w).Encode(map[string]string{
- "ApiVersion": "1.41",
- "MinAPIVersion": "1.24",
- "Version": "24.0.0",
- })
- case strings.HasSuffix(r.URL.Path, "/containers/json"):
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
w.Header().Set("Content-Type", "application/json")
- _ = json.NewEncoder(w).Encode(containers)
- case strings.Contains(r.URL.Path, "/containers/") && strings.HasSuffix(r.URL.Path, "/json"):
- containerID := strings.TrimSuffix(strings.TrimPrefix(r.URL.Path[strings.LastIndex(r.URL.Path, "/containers/"):], "/containers/"), "/json")
- for _, c := range containers {
- if c.ID != containerID {
- continue
- }
- w.Header().Set("Content-Type", "application/json")
- _ = json.NewEncoder(w).Encode(container.InspectResponse{
- ID: c.ID,
- State: &container.State{
- Status: c.State,
- Running: c.State == container.StateRunning,
- },
- })
- return
- }
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
default:
http.NotFound(w, r)
}
}))
t.Cleanup(server.Close)
- return server
-}
-
-func dockerHostFromProjectRuntimeServerURLInternal(t *testing.T, serverURL string) string {
- t.Helper()
-
- parsed, err := url.Parse(serverURL)
- require.NoError(t, err)
- return "tcp://" + parsed.Host
-}
-//go:fix inline
-func ptr(v string) *string {
- return new(v)
-}
+ projectsDir := t.TempDir()
+ oldDir := "nginx"
+ newDir := "web"
+ oldPath := filepath.Join(projectsDir, oldDir)
+ newPath := filepath.Join(projectsDir, newDir)
+ require.NoError(t, os.MkdirAll(newPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
-func TestResolveRemoveOrphans(t *testing.T) {
- tests := []struct {
- name string
- gitOpsManaged bool
- options *projecttypes.DeployOptions
- want bool
- }{
- {"non-gitops, nil options", false, nil, false},
- {"non-gitops, flag false", false, &projecttypes.DeployOptions{RemoveOrphans: false}, false},
- {"non-gitops, flag true opts in", false, &projecttypes.DeployOptions{RemoveOrphans: true}, true},
- {"gitops, nil options stays true", true, nil, true},
- {"gitops, flag false stays true", true, &projecttypes.DeployOptions{RemoveOrphans: false}, true},
- {"gitops, flag true stays true", true, &projecttypes.DeployOptions{RemoveOrphans: true}, true},
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-rename-preserved-target-retry"},
+ Name: "nginx",
+ DirName: &oldDir,
+ Path: oldPath,
+ Status: models.ProjectStatusStopped,
}
+ require.NoError(t, db.Create(project).Error)
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- require.Equal(t, tt.want, resolveRemoveOrphansInternal(tt.gitOpsManaged, tt.options))
- })
+ kvService := NewKVService(db)
+ dockerService := &DockerClientService{client: newTestDockerClient(t, server)}
+ svc := NewProjectService(db, nil, nil, nil, dockerService, nil, config.Load()).WithKVService(kvService)
+ journal := projectRenameJournalInternal{
+ ProjectID: project.ID,
+ OldName: "nginx",
+ NewName: "web",
+ OldPath: oldPath,
+ NewPath: newPath,
+ OldDirName: &oldDir,
+ NewDirName: newDir,
+ Phase: projectRenameJournalPhaseTargetsCopiedInternal,
+ Volumes: []volumes.JournalVolume{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
}
+ payload, err := json.Marshal(journal)
+ require.NoError(t, err)
+ require.NoError(t, kvService.Set(ctx, projectRenameJournalKeyInternal(project.ID), string(payload)))
+
+ err = svc.RecoverProjectRenameJournals(ctx)
+ require.NoError(t, err)
+
+ _, ok, err := kvService.Get(ctx, projectRenameJournalKeyInternal(project.ID))
+ require.NoError(t, err)
+ require.False(t, ok, "preserved target data should not leave the project permanently blocked")
+ require.False(t, targetRemoved.Load(), "target volume may be the only complete copy and must stay when source restore fails")
+ require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
+ require.NoDirExists(t, newPath)
}
diff --git a/backend/internal/services/swarm_service.go b/backend/internal/services/swarm_service.go
index 026146504..54b3b2630 100644
--- a/backend/internal/services/swarm_service.go
+++ b/backend/internal/services/swarm_service.go
@@ -2293,7 +2293,7 @@ func (s *SwarmService) getPathMapperInternal(ctx context.Context) *appfs.PathMap
// directory maps to its own host path instead of a single sources-root prefix.
if s.dockerService != nil {
if dockerCli, derr := s.dockerService.GetClient(ctx); derr == nil {
- if mounts, merr := dockerutil.GetCurrentContainerMounts(ctx, dockerCli); merr == nil && len(mounts) > 0 {
+ if mounts, merr := appfs.GetCurrentContainerMounts(ctx, dockerCli); merr == nil && len(mounts) > 0 {
pm := appfs.NewPathMapperFromMounts(mounts)
if !pm.IsNonMatchingMount() {
return nil
diff --git a/backend/internal/services/system_upgrade_service.go b/backend/internal/services/system_upgrade_service.go
index cab01f8dc..c4108b6ec 100644
--- a/backend/internal/services/system_upgrade_service.go
+++ b/backend/internal/services/system_upgrade_service.go
@@ -19,6 +19,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
vuln "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/remenv"
"github.com/getarcaneapp/arcane/types/v2/version"
containertypes "github.com/moby/moby/api/types/container"
@@ -193,7 +194,7 @@ func (s *SystemUpgradeService) TriggerUpgradeViaCLI(ctx context.Context, user mo
s.dockerService.DockerHost(),
&currentContainer,
func(ctx context.Context, containerPath string) (string, error) {
- return dockerutils.GetHostPathForContainerPath(ctx, dockerClient, containerPath)
+ return projects.GetHostPathForContainerPath(ctx, dockerClient, containerPath)
},
func() bool {
_, err := dockerutils.GetCurrentContainerID()
diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.go
index e6e24aabd..890b8e751 100644
--- a/backend/internal/services/volume_service.go
+++ b/backend/internal/services/volume_service.go
@@ -12,7 +12,6 @@ import (
"net/http"
"os"
"path"
- "runtime"
"strconv"
"strings"
"sync"
@@ -23,6 +22,7 @@ import (
docker "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
"github.com/google/uuid"
@@ -52,7 +52,7 @@ type volumeHelper struct {
lastUsedAt time.Time
}
-const volumeHelperImage = DefaultArcaneToolsImage
+const volumeHelperImage = volumehelper.DefaultToolsImage
type backupStorageMode string
@@ -439,11 +439,14 @@ func (s *VolumeService) DownloadFile(ctx context.Context, volumeName, filePath s
return s.downloadFileFromContainerInternal(ctx, dockerClient, containerID, targetPath, cleanup)
}
-func (s *VolumeService) getHelperImageInternal(ctx context.Context, dockerClient *client.Client) (string, error) {
+func getVolumeHelperImageInternal(ctx context.Context, dockerService *DockerClientService, imageService *ImageService, dockerClient *client.Client) (string, error) {
slog.DebugContext(ctx, "volume service: resolve helper image")
var err error
if dockerClient == nil {
- dockerClient, err = s.dockerService.GetClient(ctx)
+ if dockerService == nil {
+ return "", errors.New("docker service unavailable")
+ }
+ dockerClient, err = dockerService.GetClient(ctx)
if err != nil {
return "", fmt.Errorf("failed to get docker client: %w", err)
}
@@ -455,8 +458,8 @@ func (s *VolumeService) getHelperImageInternal(ctx context.Context, dockerClient
}
var pullErr error
- if s.imageService != nil {
- pullImageErr := s.imageService.PullImage(ctx, volumeHelperImage, io.Discard, systemUser, nil)
+ if imageService != nil {
+ pullImageErr := imageService.PullImage(ctx, volumeHelperImage, io.Discard, systemUser, nil)
if pullImageErr == nil {
slog.InfoContext(ctx, "volume service: helper image strategy selected", "strategy", "tools-pulled", "image", volumeHelperImage)
return volumeHelperImage, nil
@@ -468,35 +471,14 @@ func (s *VolumeService) getHelperImageInternal(ctx context.Context, dockerClient
slog.WarnContext(ctx, "volume service: image service unavailable, attempting arcane fallback")
}
- if fallbackImage, source, ok := s.resolveArcaneHelperImageInternal(ctx, dockerClient); ok {
- slog.InfoContext(ctx, "volume service: helper image strategy selected", "strategy", "arcane-fallback", "source", source, "image", fallbackImage)
- return fallbackImage, nil
+ if fallback, ok := volumehelper.ResolveArcaneRuntimeImage(ctx, dockerClient); ok {
+ slog.InfoContext(ctx, "volume service: helper image strategy selected", "strategy", "arcane-fallback", "source", fallback.Source, "image", fallback.Image)
+ return fallback.Image, nil
}
return "", fmt.Errorf("failed to resolve helper image: tools image unavailable and arcane fallback not found (pull error: %w)", pullErr)
}
-func (s *VolumeService) getArchiveHelperImageInternal(ctx context.Context, dockerClient *client.Client) (string, error) {
- return s.getHelperImageInternal(ctx, dockerClient)
-}
-
-func (s *VolumeService) resolveArcaneHelperImageInternal(ctx context.Context, dockerClient *client.Client) (string, string, bool) {
- hostname, _ := os.Hostname()
- if hostname != "" {
- if inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, hostname, client.ContainerInspectOptions{}); err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {
- return inspect.Container.Config.Image, "hostname", true
- }
- }
-
- filter := make(client.Filters)
- filter = filter.Add("label", "com.getarcaneapp.arcane=true")
- if containers, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{Filters: filter, All: true}); err == nil && len(containers.Items) > 0 && strings.TrimSpace(containers.Items[0].Image) != "" {
- return containers.Items[0].Image, "arcane-label", true
- }
-
- return "", "", false
-}
-
func resolveBackupStorageMountFromMountsInternal(mounts []container.MountPoint, target string, readOnly bool) (backupStorageMountInternal, bool) {
mirroredMount := docker.MountForDestination(mounts, "/backups", target)
if mirroredMount == nil {
@@ -628,7 +610,7 @@ func (s *VolumeService) createBackupTempContainerWithMountInternal(ctx context.C
}
if strings.TrimSpace(helperImage) == "" {
- helperImage, err = s.getHelperImageInternal(ctx, dockerClient)
+ helperImage, err = getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return "", nil, err
}
@@ -638,10 +620,10 @@ func (s *VolumeService) createBackupTempContainerWithMountInternal(ctx context.C
Image: helperImage,
Cmd: []string{"sleep", "infinity"},
NetworkDisabled: true,
- Labels: buildVolumeHelperLabelsInternal(),
+ Labels: volumehelper.Labels(),
}
- hostConfig := s.buildHelperHostConfigInternal(helperImage, nil, []mount.Mount{backupMount})
+ hostConfig := volumehelper.HostConfig(helperImage, nil, []mount.Mount{backupMount})
resp, err := dockerClient.ContainerCreate(ctx, client.ContainerCreateOptions{
Config: config,
@@ -652,12 +634,12 @@ func (s *VolumeService) createBackupTempContainerWithMountInternal(ctx context.C
}
if _, err := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); err != nil {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
return "", nil, fmt.Errorf("failed to start backup temp container: %w", err)
}
cleanup := func() {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
}
return resp.ID, cleanup, nil
@@ -688,16 +670,6 @@ type cleanupReadCloser struct {
cleanup func()
}
-func buildVolumeHelperLabelsInternal() map[string]string {
- return map[string]string{
- libarcane.InternalResourceLabel: "true",
- }
-}
-
-func volumeHelperRemoveOptionsInternal() client.ContainerRemoveOptions {
- return client.ContainerRemoveOptions{Force: true, RemoveVolumes: true}
-}
-
func isLegacyVolumeHelperContainerInternal(c container.Summary) bool {
if !libarcane.IsInternalContainer(c.Labels) {
return false
@@ -718,27 +690,14 @@ func isLegacyVolumeHelperContainerInternal(c container.Summary) bool {
}
func isVolumeHelperContainerInternal(c container.Summary) bool {
- return isLegacyVolumeHelperContainerInternal(c)
-}
-
-func (s *VolumeService) isArcaneFallbackHelperImageInternal(helperImage string) bool {
- return !strings.EqualFold(strings.TrimSpace(helperImage), volumeHelperImage)
-}
-
-func (s *VolumeService) buildHelperHostConfigInternal(helperImage string, binds []string, mounts []mount.Mount) *container.HostConfig {
- hostConfig := &container.HostConfig{
- Binds: binds,
- Mounts: mounts,
- AutoRemove: true,
+ if isLegacyVolumeHelperContainerInternal(c) {
+ return true
}
-
- if runtime.GOOS == "linux" && s.isArcaneFallbackHelperImageInternal(helperImage) {
- hostConfig.Tmpfs = map[string]string{
- "/app/data": "rw,noexec,nosuid,nodev",
- }
+ if !libarcane.IsInternalContainer(c.Labels) {
+ return false
}
- return hostConfig
+ return strings.EqualFold(c.Labels[volumehelper.ContainerLabel], "true")
}
func (c *cleanupReadCloser) Close() error {
@@ -760,7 +719,7 @@ func (s *VolumeService) createTempContainerInternal(ctx context.Context, volumeN
}
}
- helperImage, err := s.getHelperImageInternal(ctx, dockerClient)
+ helperImage, err := getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return "", nil, err
}
@@ -769,10 +728,10 @@ func (s *VolumeService) createTempContainerInternal(ctx context.Context, volumeN
Image: helperImage,
Cmd: []string{"sleep", "infinity"},
NetworkDisabled: true,
- Labels: buildVolumeHelperLabelsInternal(),
+ Labels: volumehelper.Labels(),
}
- hostConfig := s.buildHelperHostConfigInternal(helperImage, []string{
+ hostConfig := volumehelper.HostConfig(helperImage, []string{
fmt.Sprintf("%s:/volume%s", volumeName, func() string {
if readOnly {
return ":ro"
@@ -790,12 +749,12 @@ func (s *VolumeService) createTempContainerInternal(ctx context.Context, volumeN
}
if _, err := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); err != nil {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
return "", nil, fmt.Errorf("failed to start temp container: %w", err)
}
cleanup := func() {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
}
if readOnly {
@@ -857,7 +816,7 @@ func (s *VolumeService) CleanupHelperContainers(ctx context.Context) {
s.helperMu.Unlock()
for _, containerID := range helperIDs {
- if _, err := dockerClient.ContainerRemove(ctx, containerID, volumeHelperRemoveOptionsInternal()); err != nil {
+ if _, err := dockerClient.ContainerRemove(ctx, containerID, volumehelper.RemoveOptions()); err != nil {
slog.WarnContext(ctx, "failed to remove helper container", "container_id", containerID, "error", err.Error())
}
}
@@ -882,7 +841,7 @@ func (s *VolumeService) ReapIdleHelpers(ctx context.Context, idleTimeout time.Du
removed := 0
for _, containerID := range staleIDs {
- if _, err := dockerClient.ContainerRemove(ctx, containerID, volumeHelperRemoveOptionsInternal()); err != nil {
+ if _, err := dockerClient.ContainerRemove(ctx, containerID, volumehelper.RemoveOptions()); err != nil {
slog.WarnContext(ctx, "failed to remove idle helper container", "container_id", containerID, "error", err.Error())
continue
}
@@ -932,7 +891,7 @@ func (s *VolumeService) StopHelper(ctx context.Context, volumeName string) error
return nil
}
- if _, err := dockerClient.ContainerRemove(ctx, containerID, volumeHelperRemoveOptionsInternal()); err != nil {
+ if _, err := dockerClient.ContainerRemove(ctx, containerID, volumehelper.RemoveOptions()); err != nil {
return fmt.Errorf("failed to remove helper container: %w", err)
}
@@ -971,7 +930,7 @@ func (s *VolumeService) CleanupOrphanedVolumeHelpers(ctx context.Context) (int,
continue
}
- if _, err := dockerClient.ContainerRemove(ctx, c.ID, volumeHelperRemoveOptionsInternal()); err != nil {
+ if _, err := dockerClient.ContainerRemove(ctx, c.ID, volumehelper.RemoveOptions()); err != nil {
slog.WarnContext(ctx,
"volume service: failed to remove orphaned volume helper container",
"container_id", c.ID,
@@ -1223,7 +1182,7 @@ func (s *VolumeService) CreateBackup(ctx context.Context, volumeName string, use
return nil, err
}
- helperImage, err := s.getArchiveHelperImageInternal(ctx, dockerClient)
+ helperImage, err := getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return nil, err
}
@@ -1236,10 +1195,10 @@ func (s *VolumeService) CreateBackup(ctx context.Context, volumeName string, use
config := &container.Config{
Image: helperImage,
Cmd: []string{"sh", "-c", fmt.Sprintf("tar -czf /backups/%s -C /volume .", filename)},
- Labels: buildVolumeHelperLabelsInternal(),
+ Labels: volumehelper.Labels(),
}
- hostConfig := s.buildHelperHostConfigInternal(helperImage, []string{
+ hostConfig := volumehelper.HostConfig(helperImage, []string{
volumeName + ":/volume:ro",
}, []mount.Mount{backupStorage.mount})
@@ -1252,7 +1211,7 @@ func (s *VolumeService) CreateBackup(ctx context.Context, volumeName string, use
}
if _, err := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); err != nil {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
return nil, fmt.Errorf("failed to start backup container: %w", err)
}
@@ -1466,7 +1425,7 @@ func (s *VolumeService) RestoreBackup(ctx context.Context, volumeName, backupID
return err
}
- helperImage, err := s.getArchiveHelperImageInternal(ctx, dockerClient)
+ helperImage, err := getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return err
}
@@ -1483,10 +1442,10 @@ func (s *VolumeService) RestoreBackup(ctx context.Context, volumeName, backupID
"-c",
fmt.Sprintf("set -e; tmp=$(mktemp -d /volume/.restore_tmp.XXXXXX); tar -tzf /backups/%s >/dev/null; tar -xzf /backups/%s -C \"$tmp\"; find /volume -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +; find \"$tmp\" -mindepth 1 -maxdepth 1 -exec mv -- {} /volume/ \\;; rmdir \"$tmp\"", filename, filename),
},
- Labels: buildVolumeHelperLabelsInternal(),
+ Labels: volumehelper.Labels(),
}
- hostConfig := s.buildHelperHostConfigInternal(helperImage, []string{
+ hostConfig := volumehelper.HostConfig(helperImage, []string{
volumeName + ":/volume",
}, []mount.Mount{backupStorage.mount})
@@ -1499,7 +1458,7 @@ func (s *VolumeService) RestoreBackup(ctx context.Context, volumeName, backupID
}
if _, err := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); err != nil {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
return fmt.Errorf("failed to start restore container: %w", err)
}
@@ -1611,7 +1570,7 @@ func (s *VolumeService) BackupHasPath(ctx context.Context, backupID string, file
return false, err
}
- helperImage, err := s.getArchiveHelperImageInternal(ctx, dockerClient)
+ helperImage, err := getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return false, err
}
@@ -1668,7 +1627,7 @@ func (s *VolumeService) ListBackupFiles(ctx context.Context, backupID string) ([
return nil, err
}
- helperImage, err := s.getArchiveHelperImageInternal(ctx, dockerClient)
+ helperImage, err := getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return nil, err
}
@@ -1760,7 +1719,7 @@ func (s *VolumeService) RestoreBackupFiles(ctx context.Context, volumeName, back
return err
}
- helperImage, err := s.getArchiveHelperImageInternal(ctx, dockerClient)
+ helperImage, err := getVolumeHelperImageInternal(ctx, s.dockerService, s.imageService, dockerClient)
if err != nil {
return err
}
@@ -1774,10 +1733,10 @@ func (s *VolumeService) RestoreBackupFiles(ctx context.Context, volumeName, back
Image: helperImage,
Cmd: []string{"sleep", "infinity"},
NetworkDisabled: true,
- Labels: buildVolumeHelperLabelsInternal(),
+ Labels: volumehelper.Labels(),
}
- hostConfig := s.buildHelperHostConfigInternal(helperImage, []string{
+ hostConfig := volumehelper.HostConfig(helperImage, []string{
volumeName + ":/volume",
}, []mount.Mount{backupStorage.mount})
@@ -1790,12 +1749,12 @@ func (s *VolumeService) RestoreBackupFiles(ctx context.Context, volumeName, back
}
if _, err := dockerClient.ContainerStart(ctx, resp.ID, client.ContainerStartOptions{}); err != nil {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
return fmt.Errorf("failed to start restore container: %w", err)
}
cleanup := func() {
- _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumeHelperRemoveOptionsInternal())
+ _, _ = dockerClient.ContainerRemove(ctx, resp.ID, volumehelper.RemoveOptions())
}
defer cleanup()
diff --git a/backend/internal/services/volume_service_test.go b/backend/internal/services/volume_service_test.go
index 59b7ec443..6b717d4a8 100644
--- a/backend/internal/services/volume_service_test.go
+++ b/backend/internal/services/volume_service_test.go
@@ -6,6 +6,7 @@ import (
"time"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper"
volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/mount"
@@ -54,11 +55,54 @@ func TestIsLegacyVolumeHelperContainerInternal(t *testing.T) {
}
}
-func TestBuildVolumeHelperLabelsInternal(t *testing.T) {
- labels := buildVolumeHelperLabelsInternal()
+func TestIsVolumeHelperContainerInternal_UsesExplicitHelperLabel(t *testing.T) {
+ tests := []struct {
+ name string
+ summary container.Summary
+ want bool
+ }{
+ {
+ name: "new helper label matches",
+ summary: container.Summary{
+ Labels: map[string]string{
+ libarcane.InternalResourceLabel: "true",
+ volumehelper.ContainerLabel: "true",
+ },
+ },
+ want: true,
+ },
+ {
+ name: "generic internal volume mount does not match",
+ summary: container.Summary{
+ Labels: map[string]string{
+ libarcane.InternalResourceLabel: "true",
+ },
+ Mounts: []container.MountPoint{
+ {Destination: "/volume"},
+ },
+ },
+ want: false,
+ },
+ {
+ name: "legacy helper still matches",
+ summary: container.Summary{
+ Labels: map[string]string{
+ libarcane.InternalResourceLabel: "true",
+ },
+ Command: "sleep infinity",
+ Mounts: []container.MountPoint{
+ {Destination: "/volume"},
+ },
+ },
+ want: true,
+ },
+ }
- require.Equal(t, "true", labels[libarcane.InternalResourceLabel])
- require.Len(t, labels, 1)
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ require.Equal(t, tt.want, isVolumeHelperContainerInternal(tt.summary))
+ })
+ }
}
func TestEnrichVolumesWithUsageDataInternal(t *testing.T) {
diff --git a/backend/internal/services/vulnerability_service.go b/backend/internal/services/vulnerability_service.go
index ab23cfb10..37f9107ed 100644
--- a/backend/internal/services/vulnerability_service.go
+++ b/backend/internal/services/vulnerability_service.go
@@ -28,6 +28,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
vuln "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/vuln"
"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
"github.com/getarcaneapp/arcane/types/v2/vulnerability"
"github.com/moby/moby/api/pkg/stdcopy"
@@ -1986,7 +1987,7 @@ func (s *VulnerabilityService) resolveTrivyRuntimeOptionsInternal(ctx context.Co
ctx,
socketPath,
func(ctx context.Context, containerPath string) (string, error) {
- return dockerutils.GetHostPathForContainerPath(ctx, dockerClient, containerPath)
+ return projects.GetHostPathForContainerPath(ctx, dockerClient, containerPath)
},
func() bool {
_, err := dockerutils.GetCurrentContainerID()
diff --git a/backend/pkg/dockerutil/mount_utils.go b/backend/pkg/dockerutil/mount_utils.go
index e080f601a..e30ea8c6a 100644
--- a/backend/pkg/dockerutil/mount_utils.go
+++ b/backend/pkg/dockerutil/mount_utils.go
@@ -1,90 +1,12 @@
package docker
import (
- "context"
- "os"
"strings"
- "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
- "github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
containertypes "github.com/moby/moby/api/types/container"
mounttypes "github.com/moby/moby/api/types/mount"
- "github.com/moby/moby/client"
)
-// GetCurrentContainerMounts inspects Arcane's own container and returns its bind and
-// named-volume mounts as projects.HostMount entries. It returns no mounts when Arcane is
-// not running in a container (or the daemon is unreachable). This is the basis for
-// Docker-in-Docker host-path resolution.
-func GetCurrentContainerMounts(ctx context.Context, dockerCli *client.Client) ([]projects.HostMount, error) {
- if dockerCli == nil {
- return nil, nil // No docker client, can't discover
- }
-
- // Prefer robust current-container detection and fall back to hostname.
- inspectTarget, err := getCurrentContainerInspectTargetInternal(GetCurrentContainerID, os.Hostname)
- if err != nil {
- return nil, err
- }
-
- inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerCli, inspectTarget, client.ContainerInspectOptions{})
- if err != nil {
- // Not running in a container or can't reach docker daemon
- return nil, err
- }
-
- mounts := make([]projects.HostMount, 0, len(inspect.Container.Mounts))
- for i := range inspect.Container.Mounts {
- m := &inspect.Container.Mounts[i]
- if m.Type != mounttypes.TypeBind && m.Type != mounttypes.TypeVolume {
- continue
- }
- if strings.TrimSpace(m.Source) == "" || strings.TrimSpace(m.Destination) == "" {
- continue
- }
- mounts = append(mounts, projects.HostMount{Destination: m.Destination, Source: m.Source})
- }
- return mounts, nil
-}
-
-// GetHostPathForContainerPath attempts to discover the host-side path for a given container path
-// by inspecting the container itself. This is useful for Docker-in-Docker scenarios
-// where the application needs to know host paths for volume mapping. It returns an empty
-// string when the path is not covered by any of Arcane's mounts.
-func GetHostPathForContainerPath(ctx context.Context, dockerCli *client.Client, containerPath string) (string, error) {
- mounts, err := GetCurrentContainerMounts(ctx, dockerCli)
- if err != nil {
- return "", err
- }
-
- if host, ok := projects.ResolveHostPath(mounts, containerPath); ok {
- return host, nil
- }
-
- return "", nil
-}
-
-func getCurrentContainerInspectTargetInternal(currentContainerID func() (string, error), hostname func() (string, error)) (string, error) {
- if currentContainerID != nil {
- if containerID, err := currentContainerID(); err == nil {
- if containerID = strings.TrimSpace(containerID); containerID != "" {
- return containerID, nil
- }
- }
- }
-
- if hostname == nil {
- hostname = os.Hostname
- }
-
- value, err := hostname()
- if err != nil {
- return "", err
- }
-
- return strings.TrimSpace(value), nil
-}
-
// MountForDestination returns a Mount suitable for container creation that mirrors an
// existing container mount at the given destination.
//
diff --git a/backend/pkg/dockerutil/mount_utils_test.go b/backend/pkg/dockerutil/mount_utils_test.go
index a4eb6a472..2d0cff698 100644
--- a/backend/pkg/dockerutil/mount_utils_test.go
+++ b/backend/pkg/dockerutil/mount_utils_test.go
@@ -1,7 +1,6 @@
package docker
import (
- "errors"
"testing"
containertypes "github.com/moby/moby/api/types/container"
@@ -9,49 +8,6 @@ import (
"github.com/stretchr/testify/require"
)
-func TestGetCurrentContainerInspectTargetInternal(t *testing.T) {
- t.Run("prefers detected container id over hostname", func(t *testing.T) {
- target, err := getCurrentContainerInspectTargetInternal(
- func() (string, error) { return "0123456789ab", nil },
- func() (string, error) { return "rpi4", nil },
- )
-
- require.NoError(t, err)
- require.Equal(t, "0123456789ab", target)
- })
-
- t.Run("falls back to hostname when container id unavailable", func(t *testing.T) {
- target, err := getCurrentContainerInspectTargetInternal(
- func() (string, error) { return "", errors.New("no container id found") },
- func() (string, error) { return "rpi4", nil },
- )
-
- require.NoError(t, err)
- require.Equal(t, "rpi4", target)
- })
-
- t.Run("trims whitespace from detected container id", func(t *testing.T) {
- target, err := getCurrentContainerInspectTargetInternal(
- func() (string, error) { return " 0123456789ab ", nil },
- func() (string, error) { return "rpi4", nil },
- )
-
- require.NoError(t, err)
- require.Equal(t, "0123456789ab", target)
- })
-
- t.Run("returns hostname error when fallback fails", func(t *testing.T) {
- target, err := getCurrentContainerInspectTargetInternal(
- func() (string, error) { return "", errors.New("no container id found") },
- func() (string, error) { return "", errors.New("hostname unavailable") },
- )
-
- require.Error(t, err)
- require.Contains(t, err.Error(), "hostname unavailable")
- require.Equal(t, "", target)
- })
-}
-
func TestMountForDestination(t *testing.T) {
tests := []struct {
name string
diff --git a/backend/pkg/libarcane/volumehelper/helper.go b/backend/pkg/libarcane/volumehelper/helper.go
new file mode 100644
index 000000000..5a580bcac
--- /dev/null
+++ b/backend/pkg/libarcane/volumehelper/helper.go
@@ -0,0 +1,159 @@
+package volumehelper
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "runtime"
+ "strings"
+
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/api/types/mount"
+ "github.com/moby/moby/client"
+)
+
+// RuntimeImage describes the Arcane runtime image that can run internal helper
+// commands from inside temporary containers.
+type RuntimeImage struct {
+ Image string
+ Entrypoint []string
+ Command []string
+ Source string
+}
+
+const (
+ DefaultToolsImage = "ghcr.io/getarcaneapp/tools:latest"
+ ContainerLabel = "com.getarcaneapp.volume-helper"
+)
+
+// Labels returns the labels used for temporary internal volume helper containers.
+func Labels() map[string]string {
+ return map[string]string{
+ libarcane.InternalResourceLabel: "true",
+ ContainerLabel: "true",
+ }
+}
+
+// RemoveOptions returns the container remove options used for volume helpers.
+func RemoveOptions() client.ContainerRemoveOptions {
+ return client.ContainerRemoveOptions{Force: true, RemoveVolumes: true}
+}
+
+// HostConfig builds the host config shared by volume helper containers.
+func HostConfig(helperImage string, binds []string, mounts []mount.Mount) *container.HostConfig {
+ hostConfig := &container.HostConfig{
+ Binds: binds,
+ Mounts: mounts,
+ AutoRemove: true,
+ }
+
+ if runtime.GOOS == "linux" && isArcaneFallbackImageInternal(helperImage) {
+ hostConfig.Tmpfs = map[string]string{
+ "/app/data": "rw,noexec,nosuid,nodev",
+ }
+ }
+
+ return hostConfig
+}
+
+// ResolveHelperImage returns an image suitable for temporary volume helper
+// containers, pulling the tools image when it is not already present.
+func ResolveHelperImage(ctx context.Context, dockerClient *client.Client) (string, error) {
+ if dockerClient == nil {
+ return "", errors.New("docker service unavailable")
+ }
+
+ if _, err := dockerClient.ImageInspect(ctx, DefaultToolsImage); err == nil {
+ return DefaultToolsImage, nil
+ }
+
+ pullReader, pullErr := dockerClient.ImagePull(ctx, DefaultToolsImage, client.ImagePullOptions{})
+ if pullErr == nil {
+ if pullReader == nil {
+ pullErr = errors.New("helper image pull returned no response body")
+ } else {
+ defer func() { _ = pullReader.Close() }()
+ if _, err := io.Copy(io.Discard, pullReader); err != nil {
+ pullErr = fmt.Errorf("read helper image pull response: %w", err)
+ } else {
+ return DefaultToolsImage, nil
+ }
+ }
+ }
+
+ if fallback, ok := ResolveArcaneRuntimeImage(ctx, dockerClient); ok && strings.TrimSpace(fallback.Image) != "" {
+ return fallback.Image, nil
+ }
+
+ return "", fmt.Errorf("failed to resolve helper image: tools image unavailable and arcane fallback not found (pull error: %w)", pullErr)
+}
+
+// ResolveArcaneRuntimeImage resolves the current Arcane or Arcane agent image
+// so internal helper commands can run without pulling an external helper image.
+func ResolveArcaneRuntimeImage(ctx context.Context, dockerClient *client.Client) (RuntimeImage, bool) {
+ hostname, _ := os.Hostname()
+ if hostname != "" {
+ if inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, hostname, client.ContainerInspectOptions{}); err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {
+ return buildRuntimeImageInternal(inspect.Container.Config.Image, inspect.Container.Config.Entrypoint, inspect.Container.Config.Cmd, "hostname"), true
+ }
+ }
+
+ for _, label := range []string{"com.getarcaneapp.arcane=true", "com.getarcaneapp.arcane.agent=true"} {
+ filter := make(client.Filters)
+ filter = filter.Add("label", label)
+ containers, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{Filters: filter, All: true})
+ if err != nil || len(containers.Items) == 0 {
+ continue
+ }
+
+ if resolved, ok := resolveRuntimeImageFromContainersInternal(ctx, dockerClient, containers.Items, label, true); ok {
+ return resolved, true
+ }
+ if resolved, ok := resolveRuntimeImageFromContainersInternal(ctx, dockerClient, containers.Items, label, false); ok {
+ return resolved, true
+ }
+ }
+
+ return RuntimeImage{}, false
+}
+
+func resolveRuntimeImageFromContainersInternal(ctx context.Context, dockerClient *client.Client, containers []container.Summary, label string, runningOnly bool) (RuntimeImage, bool) {
+ source := "arcane-label"
+ if strings.Contains(label, ".agent=") {
+ source = "arcane-agent-label"
+ }
+
+ for _, c := range containers {
+ if runningOnly && c.State != container.StateRunning {
+ continue
+ }
+ if !runningOnly && c.State == container.StateRunning {
+ continue
+ }
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})
+ if err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {
+ return buildRuntimeImageInternal(inspect.Container.Config.Image, inspect.Container.Config.Entrypoint, inspect.Container.Config.Cmd, source), true
+ }
+ if strings.TrimSpace(c.Image) != "" {
+ return buildRuntimeImageInternal(c.Image, nil, nil, source), true
+ }
+ }
+
+ return RuntimeImage{}, false
+}
+
+func buildRuntimeImageInternal(image string, entrypoint []string, command []string, source string) RuntimeImage {
+ return RuntimeImage{
+ Image: strings.TrimSpace(image),
+ Entrypoint: append([]string(nil), entrypoint...),
+ Command: append([]string(nil), command...),
+ Source: source,
+ }
+}
+
+func isArcaneFallbackImageInternal(helperImage string) bool {
+ return !strings.EqualFold(strings.TrimSpace(helperImage), DefaultToolsImage)
+}
diff --git a/backend/pkg/libarcane/volumehelper/helper_test.go b/backend/pkg/libarcane/volumehelper/helper_test.go
new file mode 100644
index 000000000..44feb71ea
--- /dev/null
+++ b/backend/pkg/libarcane/volumehelper/helper_test.go
@@ -0,0 +1,140 @@
+package volumehelper
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "testing"
+
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/client"
+ "github.com/stretchr/testify/require"
+)
+
+func TestLabels(t *testing.T) {
+ labels := Labels()
+
+ require.Equal(t, "true", labels[libarcane.InternalResourceLabel])
+ require.Equal(t, "true", labels[ContainerLabel])
+ require.Len(t, labels, 2)
+}
+
+func TestResolveHelperImage_UsesLocalToolsImage(t *testing.T) {
+ var pullCalls atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Id": "tools-image"}))
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/images/create"):
+ pullCalls.Add(1)
+ http.Error(w, "unexpected pull", http.StatusInternalServerError)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ image, err := ResolveHelperImage(context.Background(), newTestDockerClientInternal(t, server))
+
+ require.NoError(t, err)
+ require.Equal(t, DefaultToolsImage, image)
+ require.Zero(t, pullCalls.Load())
+}
+
+func TestResolveHelperImage_PullsToolsImageWhenMissing(t *testing.T) {
+ var pullCalls atomic.Int32
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/images/create"):
+ pullCalls.Add(1)
+ require.Equal(t, "ghcr.io/getarcaneapp/tools", r.URL.Query().Get("fromImage"))
+ require.Equal(t, "latest", r.URL.Query().Get("tag"))
+ w.Header().Set("Content-Type", "application/json")
+ _, err := w.Write([]byte(`{"status":"pulled"}` + "\n"))
+ require.NoError(t, err)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ image, err := ResolveHelperImage(context.Background(), newTestDockerClientInternal(t, server))
+
+ require.NoError(t, err)
+ require.Equal(t, DefaultToolsImage, image)
+ require.EqualValues(t, 1, pullCalls.Load())
+}
+
+func TestResolveHelperImage_FallsBackToArcaneRuntimeWhenToolsPullFails(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/images/create"):
+ http.Error(w, "pull failed", http.StatusInternalServerError)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{
+ {ID: "arcane-container", Image: "arcane:local", State: container.StateRunning},
+ }))
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/containers/arcane-container/") && strings.HasSuffix(r.URL.Path, "/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(container.InspectResponse{
+ ID: "arcane-container",
+ Config: &container.Config{
+ Image: "arcane:local",
+ },
+ }))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ image, err := ResolveHelperImage(context.Background(), newTestDockerClientInternal(t, server))
+
+ require.NoError(t, err)
+ require.Equal(t, "arcane:local", image)
+}
+
+func TestResolveHelperImage_ReturnsPullErrorWhenNoFallbackExists(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/images/create"):
+ http.Error(w, "pull failed", http.StatusInternalServerError)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ image, err := ResolveHelperImage(context.Background(), newTestDockerClientInternal(t, server))
+
+ require.Error(t, err)
+ require.Empty(t, image)
+ require.ErrorContains(t, err, "failed to resolve helper image")
+ require.ErrorContains(t, err, "pull failed")
+}
+
+func newTestDockerClientInternal(t *testing.T, server *httptest.Server) *client.Client {
+ t.Helper()
+
+ dockerClient, err := client.NewClientWithOpts(
+ client.WithHost(server.URL),
+ client.WithVersion("1.54"),
+ )
+ require.NoError(t, err)
+ return dockerClient
+}
diff --git a/backend/pkg/libarcane/volumes/compose.go b/backend/pkg/libarcane/volumes/compose.go
new file mode 100644
index 000000000..e812fa702
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/compose.go
@@ -0,0 +1,73 @@
+package volumes
+
+import (
+ "errors"
+ "fmt"
+ "os"
+ "strings"
+
+ composetemplate "github.com/compose-spec/compose-go/v2/template"
+ "github.com/goccy/go-yaml"
+)
+
+func composeVolumeKeysWithExplicitNameInternal(composeFiles []string) (map[string]struct{}, error) {
+ explicit := make(map[string]struct{})
+ for _, composeFile := range composeFiles {
+ composeFile = strings.TrimSpace(composeFile)
+ if composeFile == "" {
+ continue
+ }
+ keys, err := composeVolumeKeysWithExplicitNameInFileInternal(composeFile)
+ if err != nil {
+ return nil, err
+ }
+ for key := range keys {
+ explicit[key] = struct{}{}
+ }
+ }
+ return explicit, nil
+}
+
+func composeVolumeKeysWithExplicitNameInFileInternal(path string) (map[string]struct{}, error) {
+ content, err := os.ReadFile(path)
+ if err != nil {
+ return nil, fmt.Errorf("read compose file: %w", err)
+ }
+
+ composeData := map[string]any{}
+ if err := yaml.Unmarshal(content, &composeData); err != nil {
+ return nil, fmt.Errorf("parse compose file: %w", err)
+ }
+
+ rawVolumes, ok := composeData["volumes"]
+ if !ok || rawVolumes == nil {
+ return map[string]struct{}{}, nil
+ }
+
+ volumes, ok := rawVolumes.(map[string]any)
+ if !ok {
+ return nil, errors.New("parse compose file: volumes must be a mapping")
+ }
+
+ explicit := make(map[string]struct{})
+ for key, rawVolume := range volumes {
+ key = strings.TrimSpace(key)
+ if key == "" {
+ continue
+ }
+ volumeConfig, ok := rawVolume.(map[string]any)
+ if !ok {
+ continue
+ }
+ rawName, hasName := volumeConfig["name"]
+ if !hasName {
+ continue
+ }
+ name, ok := rawName.(string)
+ if ok && len(composetemplate.ExtractVariables(map[string]any{"name": name}, nil)) == 0 {
+ explicit[key] = struct{}{}
+ }
+ }
+
+ return explicit, nil
+}
diff --git a/backend/pkg/libarcane/volumes/compose_test.go b/backend/pkg/libarcane/volumes/compose_test.go
new file mode 100644
index 000000000..d5f2049d1
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/compose_test.go
@@ -0,0 +1,74 @@
+package volumes
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestComposeVolumeKeysWithExplicitNameInternal(t *testing.T) {
+ projectPath := t.TempDir()
+ rootCompose := filepath.Join(projectPath, "compose.yaml")
+ includeCompose := filepath.Join(projectPath, "included.yaml")
+
+ require.NoError(t, os.WriteFile(rootCompose, []byte(`
+services:
+ app:
+ image: nginx:alpine
+ volumes:
+ - data:/data
+ - fixed:/fixed
+ - env_named:/env
+ - env_default:/env-default
+ - env_unbraced:/env-unbraced
+ - escaped:/escaped
+ - scalar:/scalar
+ - null_named:/null
+ - numeric_named:/numeric
+volumes:
+ data:
+ driver: local
+ fixed:
+ name: app-data
+ env_named:
+ name: ${APP_VOLUME}
+ env_default:
+ name: ${APP_VOLUME:-app-data}
+ env_unbraced:
+ name: $APP_VOLUME
+ escaped:
+ name: $${APP_VOLUME}
+ scalar:
+ null_named:
+ name: null
+ numeric_named:
+ name: 123
+ inline: {}
+`), 0o644))
+ require.NoError(t, os.WriteFile(includeCompose, []byte(`
+volumes:
+ included:
+ name: included-fixed
+ included_implicit:
+ driver: local
+`), 0o644))
+
+ explicit, err := composeVolumeKeysWithExplicitNameInternal([]string{rootCompose, includeCompose})
+ require.NoError(t, err)
+
+ assert.Contains(t, explicit, "fixed")
+ assert.Contains(t, explicit, "escaped")
+ assert.Contains(t, explicit, "included")
+ assert.NotContains(t, explicit, "data")
+ assert.NotContains(t, explicit, "env_named")
+ assert.NotContains(t, explicit, "env_default")
+ assert.NotContains(t, explicit, "env_unbraced")
+ assert.NotContains(t, explicit, "scalar")
+ assert.NotContains(t, explicit, "null_named")
+ assert.NotContains(t, explicit, "numeric_named")
+ assert.NotContains(t, explicit, "inline")
+ assert.NotContains(t, explicit, "included_implicit")
+}
diff --git a/backend/pkg/libarcane/volumes/volume_rename.go b/backend/pkg/libarcane/volumes/volume_rename.go
new file mode 100644
index 000000000..4f60a86c4
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/volume_rename.go
@@ -0,0 +1,826 @@
+package volumes
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "log/slog"
+ "maps"
+ "slices"
+ "strings"
+ "syscall"
+ "time"
+
+ composetypes "github.com/compose-spec/compose-go/v2/types"
+ cerrdefs "github.com/containerd/errdefs"
+ "github.com/docker/compose/v5/pkg/api"
+ composepkg "github.com/docker/compose/v5/pkg/compose"
+ dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper"
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/api/types/volume"
+ "github.com/moby/moby/client"
+)
+
+type Migration interface {
+ Apply(ctx context.Context) error
+ Rollback(ctx context.Context) error
+}
+
+type Committer interface {
+ Commit(ctx context.Context) error
+}
+
+type JournalSource interface {
+ JournalVolumes() []JournalVolume
+}
+
+type projectVolumeRenameEntryInternal struct {
+ Key string
+ OldName string
+ NewName string
+ OldVolume volume.Volume
+ NewConfig composetypes.VolumeConfig
+}
+
+type dockerProjectVolumeRenameMigrationInternal struct {
+ dockerClient *client.Client
+ entries []projectVolumeRenameEntryInternal
+ createdNew []projectVolumeRenameEntryInternal
+ removedOld []projectVolumeRenameEntryInternal
+ oldComposeName string
+ newComposeName string
+}
+
+type JournalVolume struct {
+ Key string `json:"key"`
+ OldName string `json:"oldName"`
+ NewName string `json:"newName"`
+ Driver string `json:"driver,omitempty"`
+ Options map[string]string `json:"options,omitempty"`
+ Labels map[string]string `json:"labels,omitempty"`
+}
+
+type projectVolumeCopyRuntimeInternal struct {
+ Image string
+}
+
+const (
+ projectVolumeCopyMountPathInternal = "/volume"
+)
+
+func PlanMigration(ctx context.Context, dockerClient *client.Client, composeProject *composetypes.Project, oldComposeName, newComposeName string) (Migration, error) {
+ if dockerClient == nil {
+ return nil, errors.New("docker service unavailable")
+ }
+ if composeProject == nil || len(composeProject.Volumes) == 0 {
+ return nil, nil
+ }
+ if strings.TrimSpace(oldComposeName) == "" || strings.TrimSpace(newComposeName) == "" || oldComposeName == newComposeName {
+ return nil, nil
+ }
+
+ explicitVolumeNames, err := composeVolumeKeysWithExplicitNameInternal(composeProject.ComposeFiles)
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse compose volume names: %w", err)
+ }
+
+ entries, err := collectProjectRenameVolumeEntriesInternal(ctx, dockerClient, composeProject.Volumes, explicitVolumeNames, oldComposeName, newComposeName)
+ if err != nil {
+ return nil, err
+ }
+
+ if len(entries) == 0 {
+ return nil, nil
+ }
+
+ return &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: dockerClient,
+ entries: entries,
+ oldComposeName: oldComposeName,
+ newComposeName: newComposeName,
+ }, nil
+}
+
+func collectProjectRenameVolumeEntriesInternal(ctx context.Context, dockerClient *client.Client, volumes map[string]composetypes.VolumeConfig, explicitVolumeNames map[string]struct{}, oldComposeName, newComposeName string) ([]projectVolumeRenameEntryInternal, error) {
+ entries := make([]projectVolumeRenameEntryInternal, 0, len(volumes))
+ for key, volumeConfig := range volumes {
+ entry, ok, err := inspectProjectRenameVolumeEntryInternal(ctx, dockerClient, key, volumeConfig, explicitVolumeNames, oldComposeName, newComposeName)
+ if err != nil {
+ return nil, err
+ }
+ if ok {
+ entries = append(entries, entry)
+ }
+ }
+ return entries, nil
+}
+
+func inspectProjectRenameVolumeEntryInternal(ctx context.Context, dockerClient *client.Client, key string, volumeConfig composetypes.VolumeConfig, explicitVolumeNames map[string]struct{}, oldComposeName, newComposeName string) (projectVolumeRenameEntryInternal, bool, error) {
+ if _, explicit := explicitVolumeNames[key]; explicit || bool(volumeConfig.External) {
+ return projectVolumeRenameEntryInternal{}, false, nil
+ }
+
+ oldName := oldComposeName + "_" + key
+ newName := newComposeName + "_" + key
+ if oldName == newName || (volumeConfig.Name != oldName && volumeConfig.Name != newName) {
+ return projectVolumeRenameEntryInternal{}, false, nil
+ }
+
+ if err := ensureProjectRenameTargetVolumeAbsentInternal(ctx, dockerClient, newName); err != nil {
+ return projectVolumeRenameEntryInternal{}, false, err
+ }
+
+ oldVolume, err := dockerClient.VolumeInspect(ctx, oldName, client.VolumeInspectOptions{})
+ if err != nil {
+ if cerrdefs.IsNotFound(err) {
+ return projectVolumeRenameEntryInternal{}, false, nil
+ }
+ return projectVolumeRenameEntryInternal{}, false, fmt.Errorf("inspect source volume %s: %w", oldName, err)
+ }
+ if err := ensureProjectRenameSourceVolumeDetachedInternal(ctx, dockerClient, oldName); err != nil {
+ return projectVolumeRenameEntryInternal{}, false, err
+ }
+
+ return projectVolumeRenameEntryInternal{
+ Key: key,
+ OldName: oldName,
+ NewName: newName,
+ OldVolume: oldVolume.Volume,
+ NewConfig: buildProjectRenamedVolumeConfigInternal(volumeConfig, key, newName, newComposeName),
+ }, true, nil
+}
+
+func (m *dockerProjectVolumeRenameMigrationInternal) Apply(ctx context.Context) error {
+ if m == nil || len(m.entries) == 0 {
+ return nil
+ }
+ if m.dockerClient == nil {
+ return errors.New("docker service unavailable")
+ }
+
+ dockerClient := m.dockerClient
+
+ copyRuntime, err := getProjectVolumeCopyRuntimeInternal(ctx, dockerClient)
+ if err != nil {
+ return err
+ }
+
+ for _, entry := range m.entries {
+ if err := createProjectRenamedVolumeInternal(ctx, dockerClient, entry); err != nil {
+ return errors.Join(err, m.rollbackCreatedTargets(ctx, dockerClient))
+ }
+ m.createdNew = append(m.createdNew, entry)
+
+ if err := copyProjectVolumeDataInternal(ctx, dockerClient, copyRuntime, entry.OldName, entry.NewName); err != nil {
+ return errors.Join(
+ fmt.Errorf("copy volume data from %s to %s: %w", entry.OldName, entry.NewName, err),
+ m.rollbackCreatedTargets(ctx, dockerClient),
+ )
+ }
+ }
+
+ dockerutil.InvalidateVolumeUsageCache()
+ slog.InfoContext(ctx, "copied project compose volumes for rename", "oldProject", m.oldComposeName, "newProject", m.newComposeName, "count", len(m.entries))
+ return nil
+}
+
+func (m *dockerProjectVolumeRenameMigrationInternal) Commit(ctx context.Context) error {
+ if m == nil || len(m.entries) == 0 {
+ return nil
+ }
+ if m.dockerClient == nil {
+ return errors.New("docker service unavailable")
+ }
+
+ dockerClient := m.dockerClient
+
+ if err := EnsureTargetsReadyForCleanup(ctx, dockerClient, m.JournalVolumes()); err != nil {
+ return err
+ }
+
+ for _, entry := range m.entries {
+ if err := removeProjectVolumeWithRetryInternal(ctx, dockerClient, entry.OldName, client.VolumeRemoveOptions{Force: false}); err != nil {
+ return NewSourceCleanupError(entry.OldName, err)
+ }
+ m.removedOld = append(m.removedOld, entry)
+ }
+
+ dockerutil.InvalidateVolumeUsageCache()
+ slog.InfoContext(ctx, "renamed project compose volumes", "oldProject", m.oldComposeName, "newProject", m.newComposeName, "count", len(m.entries))
+ return nil
+}
+
+func (m *dockerProjectVolumeRenameMigrationInternal) JournalVolumes() []JournalVolume {
+ if m == nil || len(m.entries) == 0 {
+ return nil
+ }
+
+ volumes := make([]JournalVolume, 0, len(m.entries))
+ for _, entry := range m.entries {
+ volumes = append(volumes, JournalVolume{
+ Key: entry.Key,
+ OldName: entry.OldName,
+ NewName: entry.NewName,
+ Driver: entry.OldVolume.Driver,
+ Options: cloneStringMapInternal(entry.OldVolume.Options),
+ Labels: cloneStringMapInternal(entry.OldVolume.Labels),
+ })
+ }
+ return volumes
+}
+
+func (m *dockerProjectVolumeRenameMigrationInternal) Rollback(ctx context.Context) error {
+ if m == nil || m.dockerClient == nil {
+ return nil
+ }
+
+ dockerClient := m.dockerClient
+
+ preservedTargets := map[string]struct{}{}
+ var rollbackErr error
+ for _, entry := range m.removedOld {
+ if _, preserved := preservedTargets[entry.NewName]; preserved {
+ continue
+ }
+ preservedTargets[entry.NewName] = struct{}{}
+ rollbackErr = errors.Join(rollbackErr, NewTargetPreservedDuringRollbackError(JournalVolume{
+ OldName: entry.OldName,
+ NewName: entry.NewName,
+ }, errors.New("source volume was already removed")))
+ }
+
+ for _, entry := range m.createdNew {
+ if _, preserved := preservedTargets[entry.NewName]; preserved {
+ continue
+ }
+ sourceExists, err := VolumeExists(ctx, dockerClient, entry.OldName)
+ if err != nil {
+ preservedTargets[entry.NewName] = struct{}{}
+ rollbackErr = errors.Join(rollbackErr, NewTargetPreservedDuringRollbackError(JournalVolume{
+ OldName: entry.OldName,
+ NewName: entry.NewName,
+ }, fmt.Errorf("inspect source rollback volume %s: %w", entry.OldName, err)))
+ continue
+ }
+ if sourceExists {
+ continue
+ }
+
+ targetExists, err := VolumeExists(ctx, dockerClient, entry.NewName)
+ if err != nil {
+ preservedTargets[entry.NewName] = struct{}{}
+ rollbackErr = errors.Join(rollbackErr, NewTargetPreservedDuringRollbackError(JournalVolume{
+ OldName: entry.OldName,
+ NewName: entry.NewName,
+ }, fmt.Errorf("inspect target rollback volume %s: %w", entry.NewName, err)))
+ continue
+ }
+ if targetExists {
+ preservedTargets[entry.NewName] = struct{}{}
+ rollbackErr = errors.Join(rollbackErr, NewTargetPreservedDuringRollbackError(JournalVolume{
+ OldName: entry.OldName,
+ NewName: entry.NewName,
+ }, errProjectRenameRollbackSourceMissingInternal))
+ } else {
+ rollbackErr = errors.Join(rollbackErr, fmt.Errorf("source volume %s and target volume %s are missing during rollback", entry.OldName, entry.NewName))
+ }
+ }
+
+ rollbackErr = errors.Join(rollbackErr, m.rollbackCreatedTargetsPreserving(ctx, dockerClient, preservedTargets))
+ if rollbackErr == nil {
+ dockerutil.InvalidateVolumeUsageCache()
+ }
+ return rollbackErr
+}
+
+func (m *dockerProjectVolumeRenameMigrationInternal) rollbackCreatedTargets(ctx context.Context, dockerClient *client.Client) error {
+ return m.rollbackCreatedTargetsPreserving(ctx, dockerClient, nil)
+}
+
+func (m *dockerProjectVolumeRenameMigrationInternal) rollbackCreatedTargetsPreserving(ctx context.Context, dockerClient *client.Client, preservedTargets map[string]struct{}) error {
+ var rollbackErr error
+ remainingCreated := make([]projectVolumeRenameEntryInternal, 0, len(preservedTargets))
+ for _, entry := range slices.Backward(m.createdNew) {
+ if _, preserve := preservedTargets[entry.NewName]; preserve {
+ remainingCreated = append(remainingCreated, entry)
+ continue
+ }
+ if err := removeProjectVolumeHelperContainersInternal(ctx, dockerClient, entry.NewName); err != nil {
+ rollbackErr = errors.Join(rollbackErr, fmt.Errorf("remove helper containers for target volume %s: %w", entry.NewName, err))
+ remainingCreated = append(remainingCreated, entry)
+ continue
+ }
+ if err := removeProjectVolumeWithRetryInternal(ctx, dockerClient, entry.NewName, client.VolumeRemoveOptions{Force: true}); err != nil {
+ rollbackErr = errors.Join(rollbackErr, fmt.Errorf("remove target volume %s: %w", entry.NewName, err))
+ remainingCreated = append(remainingCreated, entry)
+ }
+ }
+ slices.Reverse(remainingCreated)
+ m.createdNew = remainingCreated
+ return rollbackErr
+}
+
+func buildProjectRenamedVolumeConfigInternal(volumeConfig composetypes.VolumeConfig, key, newName, newComposeName string) composetypes.VolumeConfig {
+ newConfig := volumeConfig
+ newConfig.Name = newName
+ newConfig.CustomLabels = composetypes.Labels{
+ api.VolumeLabel: key,
+ api.ProjectLabel: newComposeName,
+ api.VersionLabel: api.ComposeVersion,
+ }
+ return newConfig
+}
+
+func ensureProjectRenameTargetVolumeAbsentInternal(ctx context.Context, dockerClient *client.Client, newName string) error {
+ _, err := dockerClient.VolumeInspect(ctx, newName, client.VolumeInspectOptions{})
+ if err != nil {
+ if cerrdefs.IsNotFound(err) {
+ return nil
+ }
+ return fmt.Errorf("inspect target volume %s: %w", newName, err)
+ }
+ return &ProjectVolumeRenameConflictError{VolumeName: newName}
+}
+
+func ensureProjectRenameSourceVolumeDetachedInternal(ctx context.Context, dockerClient *client.Client, oldName string) error {
+ containerIDs, err := dockerutil.GetContainersUsingVolume(ctx, dockerClient, oldName)
+ if err != nil {
+ return fmt.Errorf("inspect containers using source volume %s: %w", oldName, err)
+ }
+ if len(containerIDs) > 0 {
+ return &ProjectVolumeRenameInUseError{VolumeName: oldName, ContainerIDs: containerIDs}
+ }
+ return nil
+}
+
+func createProjectRenamedVolumeInternal(ctx context.Context, dockerClient *client.Client, entry projectVolumeRenameEntryInternal) error {
+ labels := map[string]string{}
+ maps.Copy(labels, entry.OldVolume.Labels)
+ maps.Copy(labels, entry.NewConfig.Labels)
+ maps.Copy(labels, entry.NewConfig.CustomLabels)
+
+ hash, err := composepkg.VolumeHash(entry.NewConfig)
+ if err != nil {
+ return fmt.Errorf("hash target volume %s: %w", entry.NewName, err)
+ }
+ labels[api.ConfigHashLabel] = hash
+
+ _, err = dockerClient.VolumeCreate(ctx, client.VolumeCreateOptions{
+ Name: entry.NewName,
+ Driver: entry.NewConfig.Driver,
+ DriverOpts: entry.NewConfig.DriverOpts,
+ Labels: labels,
+ })
+ if err != nil {
+ return fmt.Errorf("create target volume %s: %w", entry.NewName, err)
+ }
+ return nil
+}
+
+func removeProjectVolumeHelperContainersInternal(ctx context.Context, dockerClient *client.Client, volumeName string) error {
+ containers, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{All: true})
+ if err != nil {
+ return fmt.Errorf("list containers for helper cleanup: %w", err)
+ }
+
+ var removeErr error
+ for _, c := range containers.Items {
+ if !isProjectVolumeHelperContainerInternal(c) || !containerSummaryMountsVolumeInternal(c, volumeName) {
+ continue
+ }
+ if _, err := dockerClient.ContainerRemove(ctx, c.ID, volumehelper.RemoveOptions()); err != nil && !cerrdefs.IsNotFound(err) {
+ removeErr = errors.Join(removeErr, fmt.Errorf("remove helper container %s: %w", c.ID, err))
+ }
+ }
+ return removeErr
+}
+
+func isProjectVolumeHelperContainerInternal(c container.Summary) bool {
+ if !libarcane.IsInternalContainer(c.Labels) {
+ return false
+ }
+ if strings.EqualFold(c.Labels[volumehelper.ContainerLabel], "true") {
+ return true
+ }
+ command := strings.ToLower(c.Command)
+ return strings.Contains(command, "sleep") && strings.Contains(command, "infinity")
+}
+
+func containerSummaryMountsVolumeInternal(c container.Summary, volumeName string) bool {
+ for _, mount := range c.Mounts {
+ if mount.Name == volumeName || mount.Source == volumeName {
+ return true
+ }
+ }
+ return false
+}
+
+func removeProjectVolumeWithRetryInternal(ctx context.Context, dockerClient *client.Client, volumeName string, options client.VolumeRemoveOptions) error {
+ var err error
+ for attempt := range 3 {
+ _, err = dockerClient.VolumeRemove(ctx, volumeName, options)
+ if err == nil || cerrdefs.IsNotFound(err) {
+ return nil
+ }
+ if attempt == 2 {
+ break
+ }
+ select {
+ case <-ctx.Done():
+ return errors.Join(ctx.Err(), err)
+ case <-time.After(200 * time.Millisecond):
+ }
+ }
+ return err
+}
+
+func copyProjectVolumeDataInternal(ctx context.Context, dockerClient *client.Client, copyRuntime projectVolumeCopyRuntimeInternal, sourceVolume, targetVolume string) error {
+ sourceID, cleanupSource, err := createProjectVolumeCopyHolderContainerInternal(ctx, dockerClient, copyRuntime, sourceVolume, true)
+ if err != nil {
+ return err
+ }
+ defer cleanupSource()
+
+ targetID, cleanupTarget, err := createProjectVolumeCopyHolderContainerInternal(ctx, dockerClient, copyRuntime, targetVolume, false)
+ if err != nil {
+ return err
+ }
+ defer cleanupTarget()
+
+ copyResult, err := dockerClient.CopyFromContainer(ctx, sourceID, client.CopyFromContainerOptions{
+ SourcePath: projectVolumeCopyMountPathInternal + "/.",
+ })
+ if err != nil {
+ return fmt.Errorf("read source volume archive: %w", err)
+ }
+ defer func() { _ = copyResult.Content.Close() }()
+
+ _, err = dockerClient.CopyToContainer(ctx, targetID, client.CopyToContainerOptions{
+ DestinationPath: projectVolumeCopyMountPathInternal,
+ Content: copyResult.Content,
+ })
+ if err != nil {
+ if isProjectVolumeCopyNoSpaceErrorInternal(err) {
+ return &ProjectVolumeRenameInsufficientSpaceError{
+ SourceVolume: sourceVolume,
+ TargetVolume: targetVolume,
+ Detail: err.Error(),
+ }
+ }
+ return fmt.Errorf("write target volume archive: %w", err)
+ }
+
+ return nil
+}
+
+func createProjectVolumeCopyHolderContainerInternal(ctx context.Context, dockerClient *client.Client, copyRuntime projectVolumeCopyRuntimeInternal, volumeName string, readOnly bool) (string, func(), error) {
+ bind := volumeName + ":" + projectVolumeCopyMountPathInternal
+ if readOnly {
+ bind += ":ro"
+ }
+
+ config := &container.Config{
+ Image: copyRuntime.Image,
+ Cmd: []string{"sleep", "infinity"},
+ NetworkDisabled: true,
+ Labels: volumehelper.Labels(),
+ }
+
+ hostConfig := volumehelper.HostConfig(copyRuntime.Image, []string{bind}, nil)
+ hostConfig.AutoRemove = false
+
+ resp, err := dockerClient.ContainerCreate(ctx, client.ContainerCreateOptions{
+ Config: config,
+ HostConfig: hostConfig,
+ })
+ if err != nil {
+ return "", nil, fmt.Errorf("create volume copy holder: %w", err)
+ }
+
+ cleanup := func() {
+ cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
+ defer cancel()
+ if _, err := dockerClient.ContainerRemove(cleanupCtx, resp.ID, volumehelper.RemoveOptions()); err != nil && !cerrdefs.IsNotFound(err) {
+ slog.WarnContext(cleanupCtx, "failed to remove volume copy holder", "containerID", resp.ID, "error", err)
+ }
+ }
+
+ return resp.ID, cleanup, nil
+}
+
+func getProjectVolumeCopyRuntimeInternal(ctx context.Context, dockerClient *client.Client) (projectVolumeCopyRuntimeInternal, error) {
+ if dockerClient == nil {
+ return projectVolumeCopyRuntimeInternal{}, errors.New("docker service unavailable")
+ }
+
+ image, err := volumehelper.ResolveHelperImage(ctx, dockerClient)
+ if err != nil {
+ return projectVolumeCopyRuntimeInternal{}, err
+ }
+
+ return projectVolumeCopyRuntimeInternal{
+ Image: image,
+ }, nil
+}
+
+func isProjectVolumeCopyNoSpaceErrorInternal(err error) bool {
+ if err == nil {
+ return false
+ }
+ if errors.Is(err, syscall.ENOSPC) {
+ return true
+ }
+ return strings.Contains(strings.ToLower(err.Error()), "no space left on device")
+}
+
+func EnsureTargetsReadyForCleanup(ctx context.Context, dockerClient *client.Client, volumes []JournalVolume) error {
+ if len(volumes) == 0 {
+ return nil
+ }
+ if dockerClient == nil {
+ return errors.New("docker service unavailable")
+ }
+
+ var missingWithSource *TargetMissingWithSourceError
+ var externallyRemoved []JournalVolume
+ for _, vol := range volumes {
+ targetExists, err := VolumeExists(ctx, dockerClient, vol.NewName)
+ if err != nil {
+ return err
+ }
+ if targetExists {
+ continue
+ }
+
+ sourceExists, err := VolumeExists(ctx, dockerClient, vol.OldName)
+ if err != nil {
+ return err
+ }
+ if sourceExists {
+ if missingWithSource == nil {
+ missingWithSource = &TargetMissingWithSourceError{
+ SourceVolume: vol.OldName,
+ TargetVolume: vol.NewName,
+ }
+ }
+ continue
+ }
+ externallyRemoved = append(externallyRemoved, vol)
+ }
+ if missingWithSource != nil {
+ return missingWithSource
+ }
+ if len(externallyRemoved) > 0 {
+ return &VolumesExternallyRemovedError{Volumes: externallyRemoved}
+ }
+ return nil
+}
+
+func RemoveSourceVolumes(ctx context.Context, dockerClient *client.Client, volumes []JournalVolume) error {
+ for _, vol := range volumes {
+ if err := removeProjectVolumeWithRetryInternal(ctx, dockerClient, vol.OldName, client.VolumeRemoveOptions{Force: false}); err != nil {
+ return NewSourceCleanupError(vol.OldName, err)
+ }
+ }
+ dockerutil.InvalidateVolumeUsageCache()
+ return nil
+}
+
+func RollbackVolumes(ctx context.Context, dockerClient *client.Client, volumes []JournalVolume) error {
+ var rollbackErr error
+ for _, vol := range slices.Backward(volumes) {
+ if err := RollbackVolume(ctx, dockerClient, vol); err != nil {
+ rollbackErr = errors.Join(rollbackErr, err)
+ }
+ }
+ return rollbackErr
+}
+
+func RollbackVolume(ctx context.Context, dockerClient *client.Client, vol JournalVolume) error {
+ oldExists, err := VolumeExists(ctx, dockerClient, vol.OldName)
+ if err != nil {
+ return NewTargetPreservedDuringRollbackError(vol, fmt.Errorf("inspect source rollback volume %s: %w", vol.OldName, err))
+ }
+ newExists, err := VolumeExists(ctx, dockerClient, vol.NewName)
+ if err != nil {
+ return NewTargetPreservedDuringRollbackError(vol, fmt.Errorf("inspect target rollback volume %s: %w", vol.NewName, err))
+ }
+
+ switch {
+ case oldExists && newExists:
+ return removeProjectRenameJournalTargetVolumeInternal(ctx, dockerClient, vol.NewName, oldExists, newExists)
+ case !oldExists && newExists:
+ return NewTargetPreservedDuringRollbackError(vol, errProjectRenameRollbackSourceMissingInternal)
+ case !oldExists && !newExists:
+ slog.WarnContext(ctx, "project rename source and target volumes are missing during rollback", "sourceVolume", vol.OldName, "targetVolume", vol.NewName)
+ }
+ return nil
+}
+
+func CleanupRollbackTargetVolumes(ctx context.Context, dockerClient *client.Client, volumes []JournalVolume) error {
+ var cleanupErr error
+ for _, vol := range slices.Backward(volumes) {
+ if err := cleanupProjectRenameRollbackTargetVolumeInternal(ctx, dockerClient, vol); err != nil {
+ cleanupErr = errors.Join(cleanupErr, err)
+ }
+ }
+ return cleanupErr
+}
+
+func cleanupProjectRenameRollbackTargetVolumeInternal(ctx context.Context, dockerClient *client.Client, vol JournalVolume) error {
+ oldExists, err := VolumeExists(ctx, dockerClient, vol.OldName)
+ if err != nil {
+ return fmt.Errorf("inspect source cleanup volume %s: %w", vol.OldName, err)
+ }
+ newExists, err := VolumeExists(ctx, dockerClient, vol.NewName)
+ if err != nil {
+ return fmt.Errorf("inspect target cleanup volume %s: %w", vol.NewName, err)
+ }
+
+ switch {
+ case oldExists && newExists:
+ return removeProjectRenameJournalTargetVolumeInternal(ctx, dockerClient, vol.NewName, oldExists, newExists)
+ case !oldExists && newExists:
+ return NewTargetPreservedDuringRollbackError(vol, errProjectRenameRollbackSourceMissingInternal)
+ case !oldExists && !newExists:
+ slog.WarnContext(ctx, "project rename source and target volumes are missing during rollback cleanup", "sourceVolume", vol.OldName, "targetVolume", vol.NewName)
+ }
+ return nil
+}
+
+func removeProjectRenameJournalTargetVolumeInternal(ctx context.Context, dockerClient *client.Client, newName string, oldExists bool, newExists bool) error {
+ if !oldExists || !newExists {
+ return nil
+ }
+
+ if err := removeProjectVolumeHelperContainersInternal(ctx, dockerClient, newName); err != nil {
+ return err
+ }
+ if err := removeProjectVolumeWithRetryInternal(ctx, dockerClient, newName, client.VolumeRemoveOptions{Force: true}); err != nil {
+ return fmt.Errorf("remove rollback target volume %s: %w", newName, err)
+ }
+ return nil
+}
+
+func VolumeExists(ctx context.Context, dockerClient *client.Client, name string) (bool, error) {
+ _, err := dockerClient.VolumeInspect(ctx, name, client.VolumeInspectOptions{})
+ if err == nil {
+ return true, nil
+ }
+ if cerrdefs.IsNotFound(err) {
+ return false, nil
+ }
+ return false, fmt.Errorf("inspect volume %s: %w", name, err)
+}
+
+type ProjectVolumeRenameConflictError struct {
+ VolumeName string
+}
+
+func (e *ProjectVolumeRenameConflictError) Error() string {
+ if strings.TrimSpace(e.VolumeName) == "" {
+ return "target volume already exists"
+ }
+ return "target volume already exists: " + e.VolumeName
+}
+
+type ProjectVolumeRenameInUseError struct {
+ VolumeName string
+ ContainerIDs []string
+}
+
+func (e *ProjectVolumeRenameInUseError) Error() string {
+ if strings.TrimSpace(e.VolumeName) == "" {
+ return "source volume is still attached to containers"
+ }
+ if len(e.ContainerIDs) == 0 {
+ return "source volume is still attached to containers: " + e.VolumeName
+ }
+ return fmt.Sprintf("source volume is still attached to %d container(s): %s", len(e.ContainerIDs), e.VolumeName)
+}
+
+type ProjectVolumeRenameInsufficientSpaceError struct {
+ SourceVolume string
+ TargetVolume string
+ Detail string
+}
+
+func (e *ProjectVolumeRenameInsufficientSpaceError) Error() string {
+ msg := "insufficient disk space to rename project volume"
+ if e.SourceVolume != "" && e.TargetVolume != "" {
+ msg = fmt.Sprintf("insufficient disk space to copy volume %s to %s", e.SourceVolume, e.TargetVolume)
+ }
+ if strings.TrimSpace(e.Detail) != "" {
+ msg += ": " + strings.TrimSpace(e.Detail)
+ }
+ return msg
+}
+
+type TargetMissingWithSourceError struct {
+ SourceVolume string
+ TargetVolume string
+}
+
+func (e *TargetMissingWithSourceError) Error() string {
+ return fmt.Sprintf("committed project rename target volume %s is missing while source volume %s still exists", e.TargetVolume, e.SourceVolume)
+}
+
+type SourceCleanupError struct {
+ SourceVolume string
+ Err error
+}
+
+func NewSourceCleanupError(sourceVolume string, err error) error {
+ return &SourceCleanupError{
+ SourceVolume: sourceVolume,
+ Err: err,
+ }
+}
+
+func (e *SourceCleanupError) Error() string {
+ if e == nil {
+ return "clean up committed project rename source volume"
+ }
+ if strings.TrimSpace(e.SourceVolume) == "" {
+ return fmt.Sprintf("clean up committed project rename source volume: %v", e.Err)
+ }
+ return fmt.Sprintf("clean up committed project rename source volume %s: %v", e.SourceVolume, e.Err)
+}
+
+func (e *SourceCleanupError) Unwrap() error {
+ if e == nil {
+ return nil
+ }
+ return e.Err
+}
+
+type TargetPreservedDuringRollbackError struct {
+ SourceVolume string
+ TargetVolume string
+ Err error
+}
+
+var errProjectRenameRollbackSourceMissingInternal = errors.New("source volume is missing and target volume may contain the only remaining data copy")
+
+func NewTargetPreservedDuringRollbackError(vol JournalVolume, err error) error {
+ return &TargetPreservedDuringRollbackError{
+ SourceVolume: vol.OldName,
+ TargetVolume: vol.NewName,
+ Err: err,
+ }
+}
+
+func (e *TargetPreservedDuringRollbackError) Error() string {
+ return fmt.Sprintf("preserved project rename target volume %s during rollback to avoid data loss; source volume %s was not safe to rely on: %v", e.TargetVolume, e.SourceVolume, e.Err)
+}
+
+func (e *TargetPreservedDuringRollbackError) Unwrap() error {
+ return e.Err
+}
+
+func OnlyPreservedTargetErrors(err error) bool {
+ if err == nil {
+ return false
+ }
+ if joined, ok := err.(interface{ Unwrap() []error }); ok {
+ children := joined.Unwrap()
+ if len(children) == 0 {
+ return false
+ }
+ for _, child := range children {
+ if !OnlyPreservedTargetErrors(child) {
+ return false
+ }
+ }
+ return true
+ }
+
+ var preserved *TargetPreservedDuringRollbackError
+ return errors.As(err, &preserved)
+}
+
+type VolumesExternallyRemovedError struct {
+ Volumes []JournalVolume
+}
+
+func (e *VolumesExternallyRemovedError) Error() string {
+ if e == nil || len(e.Volumes) == 0 {
+ return "committed project rename source and target volumes are both missing"
+ }
+ if len(e.Volumes) == 1 {
+ vol := e.Volumes[0]
+ return fmt.Sprintf("committed project rename target volume %s is missing and source volume %s is also missing", vol.NewName, vol.OldName)
+ }
+ return fmt.Sprintf("committed project rename source and target volumes are both missing for %d volume pairs", len(e.Volumes))
+}
+
+func cloneStringMapInternal(values map[string]string) map[string]string {
+ if len(values) == 0 {
+ return nil
+ }
+ cloned := make(map[string]string, len(values))
+ maps.Copy(cloned, values)
+ return cloned
+}
diff --git a/backend/pkg/libarcane/volumes/volume_rename_followup_test.go b/backend/pkg/libarcane/volumes/volume_rename_followup_test.go
new file mode 100644
index 000000000..d37f2d8d1
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/volume_rename_followup_test.go
@@ -0,0 +1,75 @@
+package volumes
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackExplainsPreservedTargetWhenSourceMissing(t *testing.T) {
+ var targetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {OldName: "nginx_data", NewName: "web_data"},
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.Contains(t, err.Error(), "avoid data loss")
+ require.Contains(t, err.Error(), "only remaining data copy")
+ require.False(t, targetRemoved.Load())
+}
+
+func TestRollbackVolume_ExplainsPreservedTargetWhenSourceMissing(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ err := RollbackVolume(context.Background(), newTestDockerClient(t, server), JournalVolume{
+ OldName: "nginx_data",
+ NewName: "web_data",
+ })
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.Contains(t, err.Error(), "avoid data loss")
+ require.Contains(t, err.Error(), "only remaining data copy")
+}
diff --git a/backend/pkg/libarcane/volumes/volume_rename_runtime_test.go b/backend/pkg/libarcane/volumes/volume_rename_runtime_test.go
new file mode 100644
index 000000000..24c71644d
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/volume_rename_runtime_test.go
@@ -0,0 +1,64 @@
+package volumes
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper"
+ "github.com/stretchr/testify/require"
+)
+
+func TestGetProjectVolumeCopyRuntimeInternal_UsesToolsImageWhenAvailable(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Id": "tools-image"}))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ copyRuntime, err := getProjectVolumeCopyRuntimeInternal(context.Background(), newTestDockerClient(t, server))
+
+ require.NoError(t, err)
+ require.Equal(t, volumehelper.DefaultToolsImage, copyRuntime.Image)
+}
+
+func TestCreateProjectVolumeCopyHolderContainerInternal_UsesPassiveHolderCommand(t *testing.T) {
+ var createBody map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/create"):
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&createBody))
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{
+ "Id": "helper-container",
+ "Warnings": []string{},
+ }))
+ case r.Method == http.MethodDelete && strings.Contains(r.URL.Path, "/containers/helper-container"):
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ _, cleanup, err := createProjectVolumeCopyHolderContainerInternal(
+ context.Background(),
+ newTestDockerClient(t, server),
+ projectVolumeCopyRuntimeInternal{Image: "arcane:local"},
+ "nginx_data",
+ true,
+ )
+ require.NoError(t, err)
+ defer cleanup()
+
+ require.Empty(t, createBody["Entrypoint"])
+ require.Equal(t, []any{"sleep", "infinity"}, createBody["Cmd"])
+}
diff --git a/backend/pkg/libarcane/volumes/volume_rename_safety_test.go b/backend/pkg/libarcane/volumes/volume_rename_safety_test.go
new file mode 100644
index 000000000..64b1ebf85
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/volume_rename_safety_test.go
@@ -0,0 +1,500 @@
+package volumes
+
+import (
+ "context"
+ "encoding/base64"
+ "encoding/json"
+ "errors"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync/atomic"
+ "syscall"
+ "testing"
+
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/api/types/mount"
+ "github.com/stretchr/testify/require"
+)
+
+func TestIsProjectVolumeCopyNoSpaceErrorInternal(t *testing.T) {
+ require.True(t, isProjectVolumeCopyNoSpaceErrorInternal(syscall.ENOSPC))
+ require.True(t, isProjectVolumeCopyNoSpaceErrorInternal(errors.New("write target volume archive: no space left on device")))
+ require.False(t, isProjectVolumeCopyNoSpaceErrorInternal(errors.New("permission denied")))
+}
+
+func TestEnsureProjectRenameTargetVolumeAbsentInternal_ReturnsConflictWhenTargetExists(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if strings.HasSuffix(r.URL.Path, "/volumes/web_data") {
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{
+ "Name": "web_data",
+ }))
+ return
+ }
+ http.NotFound(w, r)
+ }))
+ t.Cleanup(server.Close)
+
+ dockerClient := newTestDockerClient(t, server)
+
+ err := ensureProjectRenameTargetVolumeAbsentInternal(context.Background(), dockerClient, "web_data")
+
+ var conflictErr *ProjectVolumeRenameConflictError
+ require.ErrorAs(t, err, &conflictErr)
+ require.Equal(t, "web_data", conflictErr.VolumeName)
+}
+
+func TestEnsureProjectRenameSourceVolumeDetachedInternal_ReturnsConflictWhenContainerUsesVolume(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if strings.HasSuffix(r.URL.Path, "/containers/json") {
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{
+ {
+ ID: "stopped-container",
+ Mounts: []container.MountPoint{
+ {Type: mount.TypeVolume, Name: "nginx_data"},
+ },
+ },
+ }))
+ return
+ }
+ http.NotFound(w, r)
+ }))
+ t.Cleanup(server.Close)
+
+ dockerClient := newTestDockerClient(t, server)
+
+ err := ensureProjectRenameSourceVolumeDetachedInternal(context.Background(), dockerClient, "nginx_data")
+
+ var inUseErr *ProjectVolumeRenameInUseError
+ require.ErrorAs(t, err, &inUseErr)
+ require.Equal(t, "nginx_data", inUseErr.VolumeName)
+ require.Equal(t, []string{"stopped-container"}, inUseErr.ContainerIDs)
+}
+
+func TestGetProjectVolumeCopyRuntimeInternal_UsesArcaneAgentLabel(t *testing.T) {
+ var listCalls atomic.Int32
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ if listCalls.Add(1) == 1 {
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ return
+ }
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{
+ {
+ ID: "agent-container",
+ Image: "arcane-agent:local",
+ State: container.StateRunning,
+ },
+ }))
+ case strings.Contains(r.URL.Path, "/containers/agent-container/") && strings.HasSuffix(r.URL.Path, "/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(container.InspectResponse{
+ ID: "agent-container",
+ Config: &container.Config{
+ Image: "arcane-agent:local",
+ Cmd: []string{"./arcane-agent"},
+ },
+ }))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ copyRuntime, err := getProjectVolumeCopyRuntimeInternal(context.Background(), newTestDockerClient(t, server))
+
+ require.NoError(t, err)
+ require.Equal(t, "arcane-agent:local", copyRuntime.Image)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackPreservesTargetWhenSourceMissing(t *testing.T) {
+ var targetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {OldName: "nginx_data", NewName: "web_data"},
+ },
+ removedOld: []projectVolumeRenameEntryInternal{
+ {
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.False(t, targetRemoved.Load(), "target volume may be the only complete copy and must stay when source restore fails")
+ require.Len(t, migration.createdNew, 1)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackCleansSafeTargetsWhenSourceMissing(t *testing.T) {
+ var preservedTargetRemoved atomic.Bool
+ var safeTargetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "nginx_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ preservedTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ safeTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {OldName: "nginx_data", NewName: "web_data"},
+ {OldName: "nginx_cache", NewName: "web_cache"},
+ },
+ removedOld: []projectVolumeRenameEntryInternal{
+ {
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.False(t, preservedTargetRemoved.Load(), "target volume may be the only complete copy and must stay when source restore fails")
+ require.True(t, safeTargetRemoved.Load(), "targets without removed sources should still be cleaned up")
+ require.Equal(t, []projectVolumeRenameEntryInternal{{OldName: "nginx_data", NewName: "web_data"}}, migration.createdNew)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackPreservesTargetWhenSourceInspectFails(t *testing.T) {
+ var preservedTargetRemoved atomic.Bool
+ var safeTargetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.Error(w, "temporary docker error", http.StatusInternalServerError)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "nginx_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ preservedTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ safeTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {OldName: "nginx_data", NewName: "web_data"},
+ {OldName: "nginx_cache", NewName: "web_cache"},
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.False(t, preservedTargetRemoved.Load(), "target volume must not be deleted when source inspection is uncertain")
+ require.True(t, safeTargetRemoved.Load(), "targets without rollback uncertainty should still be cleaned up")
+ require.Equal(t, []projectVolumeRenameEntryInternal{{OldName: "nginx_data", NewName: "web_data"}}, migration.createdNew)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackPreservesTargetWhenTargetInspectFails(t *testing.T) {
+ var preservedTargetRemoved atomic.Bool
+ var safeTargetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ http.Error(w, "temporary docker error", http.StatusInternalServerError)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "nginx_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ preservedTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ safeTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {OldName: "nginx_data", NewName: "web_data"},
+ {OldName: "nginx_cache", NewName: "web_cache"},
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.False(t, preservedTargetRemoved.Load(), "target volume must not be deleted when target inspection is uncertain")
+ require.True(t, safeTargetRemoved.Load(), "targets without rollback uncertainty should still be cleaned up")
+ require.Equal(t, []projectVolumeRenameEntryInternal{{OldName: "nginx_data", NewName: "web_data"}}, migration.createdNew)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackRemovesTargetsWhenSourcesRemain(t *testing.T) {
+ var targetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "nginx_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.Contains(r.URL.Path, "/containers/copy-holder-"):
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.NoError(t, err)
+ require.True(t, targetRemoved.Load(), "rollback should remove copied targets while sources still exist")
+ require.Empty(t, migration.createdNew)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackPreservesRemovedOldTargetsWithoutRestoreCopy(t *testing.T) {
+ var targetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ targetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ createdNew: []projectVolumeRenameEntryInternal{
+ {NewName: "web_data"},
+ },
+ removedOld: []projectVolumeRenameEntryInternal{
+ {
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ },
+ }
+
+ err := migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.False(t, targetRemoved.Load(), "rollback must not delete target volumes after source cleanup has started")
+ require.Equal(t, []projectVolumeRenameEntryInternal{{OldName: "nginx_data", NewName: "web_data"}}, migration.removedOld)
+ require.Equal(t, []projectVolumeRenameEntryInternal{{NewName: "web_data"}}, migration.createdNew)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_RollbackAfterPartialCommitCleansSafeTargets(t *testing.T) {
+ var firstSourceRemoved atomic.Bool
+ var secondSourceRemoveAttempts atomic.Int32
+ var preservedTargetRemoved atomic.Bool
+ var safeTargetRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "nginx_cache"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode([]container.Summary{}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ firstSourceRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ secondSourceRemoveAttempts.Add(1)
+ http.Error(w, "volume busy", http.StatusInternalServerError)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ preservedTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ safeTargetRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ entries := []projectVolumeRenameEntryInternal{
+ {OldName: "nginx_data", NewName: "web_data"},
+ {OldName: "nginx_cache", NewName: "web_cache"},
+ }
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ entries: entries,
+ createdNew: append([]projectVolumeRenameEntryInternal(nil), entries...),
+ }
+
+ err := migration.Commit(context.Background())
+
+ var cleanupErr *SourceCleanupError
+ require.ErrorAs(t, err, &cleanupErr)
+ require.Equal(t, "nginx_cache", cleanupErr.SourceVolume)
+ require.True(t, firstSourceRemoved.Load())
+ require.Positive(t, secondSourceRemoveAttempts.Load())
+ require.Equal(t, []projectVolumeRenameEntryInternal{entries[0]}, migration.removedOld)
+
+ err = migration.Rollback(context.Background())
+
+ require.Error(t, err)
+ var preserved *TargetPreservedDuringRollbackError
+ require.ErrorAs(t, err, &preserved)
+ require.False(t, preservedTargetRemoved.Load(), "target volume may be the only complete copy and must stay when source cleanup has started")
+ require.True(t, safeTargetRemoved.Load(), "targets whose source volumes remain should still be cleaned up")
+ require.Equal(t, []projectVolumeRenameEntryInternal{entries[0]}, migration.createdNew)
+}
+
+func TestDockerProjectVolumeRenameMigrationInternal_CommitPreflightsAllTargetsBeforeRemovingSources(t *testing.T) {
+ var firstSourceRemoved atomic.Bool
+ var secondSourceRemoved atomic.Bool
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"}))
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
+ http.NotFound(w, r)
+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "nginx_cache"}))
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
+ firstSourceRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
+ secondSourceRemoved.Store(true)
+ w.WriteHeader(http.StatusNoContent)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ t.Cleanup(server.Close)
+
+ migration := &dockerProjectVolumeRenameMigrationInternal{
+ dockerClient: newTestDockerClient(t, server),
+ entries: []projectVolumeRenameEntryInternal{
+ {
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ },
+ {
+ Key: "cache",
+ OldName: "nginx_cache",
+ NewName: "web_cache",
+ },
+ },
+ }
+
+ err := migration.Commit(context.Background())
+
+ var missingTarget *TargetMissingWithSourceError
+ require.ErrorAs(t, err, &missingTarget)
+ require.Equal(t, "nginx_cache", missingTarget.SourceVolume)
+ require.Equal(t, "web_cache", missingTarget.TargetVolume)
+ require.False(t, firstSourceRemoved.Load(), "no source volume should be removed until every target is verified")
+ require.False(t, secondSourceRemoved.Load())
+}
+
+func setProjectVolumeCopyArchiveStatHeaderInternal(t *testing.T, w http.ResponseWriter) {
+ t.Helper()
+
+ payload, err := json.Marshal(container.PathStat{Name: "."})
+ require.NoError(t, err)
+ w.Header().Set("X-Docker-Container-Path-Stat", base64.StdEncoding.EncodeToString(payload))
+}
diff --git a/backend/pkg/libarcane/volumes/volume_rename_test.go b/backend/pkg/libarcane/volumes/volume_rename_test.go
new file mode 100644
index 000000000..08f999e2c
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/volume_rename_test.go
@@ -0,0 +1,103 @@
+package volumes
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ composetypes "github.com/compose-spec/compose-go/v2/types"
+ "github.com/docker/compose/v5/pkg/api"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/api/types/volume"
+ "github.com/stretchr/testify/require"
+)
+
+func TestBuildProjectRenamedVolumeConfigInternal(t *testing.T) {
+ source := composetypes.VolumeConfig{
+ Name: "nginx_data",
+ Driver: "local",
+ Labels: composetypes.Labels{
+ "existing": "kept",
+ },
+ CustomLabels: composetypes.Labels{
+ api.ProjectLabel: "nginx",
+ api.VolumeLabel: "data",
+ },
+ }
+
+ got := buildProjectRenamedVolumeConfigInternal(source, "data", "web_data", "web")
+
+ require.Equal(t, "web_data", got.Name)
+ require.Equal(t, "local", got.Driver)
+ require.Equal(t, "kept", got.Labels["existing"])
+ require.Equal(t, "web", got.CustomLabels[api.ProjectLabel])
+ require.Equal(t, "data", got.CustomLabels[api.VolumeLabel])
+ require.Equal(t, api.ComposeVersion, got.CustomLabels[api.VersionLabel])
+}
+
+func TestContainerSummaryMountsVolumeInternal(t *testing.T) {
+ summary := container.Summary{
+ Labels: map[string]string{
+ libarcane.InternalResourceLabel: "true",
+ },
+ Mounts: []container.MountPoint{
+ {Name: "web_data", Source: "/var/lib/docker/volumes/web_data/_data"},
+ {Name: "other", Source: "other"},
+ },
+ }
+
+ require.True(t, libarcane.IsInternalContainer(summary.Labels))
+ require.True(t, containerSummaryMountsVolumeInternal(summary, "web_data"))
+ require.False(t, containerSummaryMountsVolumeInternal(summary, "nginx_data"))
+}
+
+func TestCreateProjectRenamedVolumeInternal_UsesPendingComposeDriverOptions(t *testing.T) {
+ var payload map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/volumes/create") {
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&payload))
+ w.Header().Set("Content-Type", "application/json")
+ require.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"}))
+ return
+ }
+ http.NotFound(w, r)
+ }))
+ t.Cleanup(server.Close)
+
+ entry := projectVolumeRenameEntryInternal{
+ Key: "data",
+ OldName: "nginx_data",
+ NewName: "web_data",
+ OldVolume: volume.Volume{
+ Driver: "old-driver",
+ Options: map[string]string{"old": "true"},
+ Labels: map[string]string{"existing": "kept"},
+ },
+ NewConfig: composetypes.VolumeConfig{
+ Name: "web_data",
+ Driver: "new-driver",
+ DriverOpts: map[string]string{"new": "true"},
+ CustomLabels: composetypes.Labels{
+ api.ProjectLabel: "web",
+ api.VolumeLabel: "data",
+ },
+ },
+ }
+
+ err := createProjectRenamedVolumeInternal(context.Background(), newTestDockerClient(t, server), entry)
+
+ require.NoError(t, err)
+ require.Equal(t, "web_data", payload["Name"])
+ require.Equal(t, "new-driver", payload["Driver"])
+ require.Equal(t, map[string]any{"new": "true"}, payload["DriverOpts"])
+ labels, ok := payload["Labels"].(map[string]any)
+ require.True(t, ok)
+ require.Equal(t, "kept", labels["existing"])
+ require.Equal(t, "web", labels[api.ProjectLabel])
+ require.Equal(t, "data", labels[api.VolumeLabel])
+ require.NotEmpty(t, labels[api.ConfigHashLabel])
+}
diff --git a/backend/pkg/libarcane/volumes/volume_rename_test_helpers_test.go b/backend/pkg/libarcane/volumes/volume_rename_test_helpers_test.go
new file mode 100644
index 000000000..81d0c9426
--- /dev/null
+++ b/backend/pkg/libarcane/volumes/volume_rename_test_helpers_test.go
@@ -0,0 +1,27 @@
+package volumes
+
+import (
+ "net/http/httptest"
+ "testing"
+
+ "github.com/moby/moby/client"
+ "github.com/stretchr/testify/require"
+)
+
+func newTestDockerClient(t *testing.T, server *httptest.Server) *client.Client {
+ t.Helper()
+
+ httpClient := server.Client()
+ cli, err := client.New(
+ client.WithHost(server.URL),
+ client.WithVersion("1.41"),
+ client.WithHTTPClient(httpClient),
+ )
+ require.NoError(t, err)
+
+ t.Cleanup(func() {
+ _ = cli.Close()
+ })
+
+ return cli
+}
diff --git a/backend/pkg/projects/container_mounts.go b/backend/pkg/projects/container_mounts.go
new file mode 100644
index 000000000..f616ca527
--- /dev/null
+++ b/backend/pkg/projects/container_mounts.go
@@ -0,0 +1,85 @@
+package projects
+
+import (
+ "context"
+ "os"
+ "strings"
+
+ dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
+ mounttypes "github.com/moby/moby/api/types/mount"
+ "github.com/moby/moby/client"
+)
+
+// GetCurrentContainerMounts inspects Arcane's own container and returns its bind and
+// named-volume mounts as HostMount entries. It returns no mounts when Arcane is
+// not running in a container (or the daemon is unreachable). This is the basis for
+// Docker-in-Docker host-path resolution.
+func GetCurrentContainerMounts(ctx context.Context, dockerCli *client.Client) ([]HostMount, error) {
+ if dockerCli == nil {
+ return nil, nil // No docker client, can't discover
+ }
+
+ // Prefer robust current-container detection and fall back to hostname.
+ inspectTarget, err := getCurrentContainerInspectTargetInternal(dockerutil.GetCurrentContainerID, os.Hostname)
+ if err != nil {
+ return nil, err
+ }
+
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerCli, inspectTarget, client.ContainerInspectOptions{})
+ if err != nil {
+ // Not running in a container or can't reach docker daemon
+ return nil, err
+ }
+
+ mounts := make([]HostMount, 0, len(inspect.Container.Mounts))
+ for i := range inspect.Container.Mounts {
+ m := &inspect.Container.Mounts[i]
+ if m.Type != mounttypes.TypeBind && m.Type != mounttypes.TypeVolume {
+ continue
+ }
+ if strings.TrimSpace(m.Source) == "" || strings.TrimSpace(m.Destination) == "" {
+ continue
+ }
+ mounts = append(mounts, HostMount{Destination: m.Destination, Source: m.Source})
+ }
+ return mounts, nil
+}
+
+// GetHostPathForContainerPath attempts to discover the host-side path for a given container path
+// by inspecting the container itself. This is useful for Docker-in-Docker scenarios
+// where the application needs to know host paths for volume mapping. It returns an empty
+// string when the path is not covered by any of Arcane's mounts.
+func GetHostPathForContainerPath(ctx context.Context, dockerCli *client.Client, containerPath string) (string, error) {
+ mounts, err := GetCurrentContainerMounts(ctx, dockerCli)
+ if err != nil {
+ return "", err
+ }
+
+ if host, ok := ResolveHostPath(mounts, containerPath); ok {
+ return host, nil
+ }
+
+ return "", nil
+}
+
+func getCurrentContainerInspectTargetInternal(currentContainerID func() (string, error), hostname func() (string, error)) (string, error) {
+ if currentContainerID != nil {
+ if containerID, err := currentContainerID(); err == nil {
+ if containerID = strings.TrimSpace(containerID); containerID != "" {
+ return containerID, nil
+ }
+ }
+ }
+
+ if hostname == nil {
+ hostname = os.Hostname
+ }
+
+ value, err := hostname()
+ if err != nil {
+ return "", err
+ }
+
+ return strings.TrimSpace(value), nil
+}
diff --git a/backend/pkg/projects/container_mounts_test.go b/backend/pkg/projects/container_mounts_test.go
new file mode 100644
index 000000000..047dabc07
--- /dev/null
+++ b/backend/pkg/projects/container_mounts_test.go
@@ -0,0 +1,51 @@
+package projects
+
+import (
+ "errors"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestGetCurrentContainerInspectTargetInternal(t *testing.T) {
+ t.Run("prefers detected container id over hostname", func(t *testing.T) {
+ target, err := getCurrentContainerInspectTargetInternal(
+ func() (string, error) { return "0123456789ab", nil },
+ func() (string, error) { return "rpi4", nil },
+ )
+
+ require.NoError(t, err)
+ require.Equal(t, "0123456789ab", target)
+ })
+
+ t.Run("falls back to hostname when container id unavailable", func(t *testing.T) {
+ target, err := getCurrentContainerInspectTargetInternal(
+ func() (string, error) { return "", errors.New("no container id found") },
+ func() (string, error) { return "rpi4", nil },
+ )
+
+ require.NoError(t, err)
+ require.Equal(t, "rpi4", target)
+ })
+
+ t.Run("trims whitespace from detected container id", func(t *testing.T) {
+ target, err := getCurrentContainerInspectTargetInternal(
+ func() (string, error) { return " 0123456789ab ", nil },
+ func() (string, error) { return "rpi4", nil },
+ )
+
+ require.NoError(t, err)
+ require.Equal(t, "0123456789ab", target)
+ })
+
+ t.Run("returns hostname error when fallback fails", func(t *testing.T) {
+ target, err := getCurrentContainerInspectTargetInternal(
+ func() (string, error) { return "", errors.New("no container id found") },
+ func() (string, error) { return "", errors.New("hostname unavailable") },
+ )
+
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "hostname unavailable")
+ require.Equal(t, "", target)
+ })
+}
diff --git a/backend/pkg/projects/discovery.go b/backend/pkg/projects/discovery.go
index cbf045b5a..c2a95c94a 100644
--- a/backend/pkg/projects/discovery.go
+++ b/backend/pkg/projects/discovery.go
@@ -86,6 +86,10 @@ func DiscoverProjectDirectories(root string, followSymlinks bool, maxDepth int)
}
func walkProjectDirectoriesInternal(path string, isRoot bool, currentDepth int, maxDepth int, followSymlinks bool, ancestors map[string]struct{}, discovered *[]DiscoveredProjectDir) error {
+ if !isRoot && isProjectUpdateTempDirInternal(filepath.Base(path)) {
+ return nil
+ }
+
identity, err := ResolveDirectoryIdentityInternal(path)
if err != nil {
return err
@@ -137,3 +141,8 @@ func walkProjectDirectoriesInternal(path string, isRoot bool, currentDepth int,
return nil
}
+
+func isProjectUpdateTempDirInternal(name string) bool {
+ name = strings.TrimSpace(name)
+ return strings.HasPrefix(name, ".project-update-preview-") || strings.HasPrefix(name, ".project-update-backup-")
+}
diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.go
index b947ee20d..3dbc9af49 100644
--- a/backend/pkg/projects/fs_util.go
+++ b/backend/pkg/projects/fs_util.go
@@ -148,7 +148,7 @@ func ReadProjectDirectoryFiles(projectPath string, shownFiles map[string]bool, m
func readProjectDirectoryFilesInternal(projectPath string, shownFiles map[string]bool, maxDepth int, skipDirectories string, includeContent bool) ([]project.IncludeFile, error) {
if maxDepth <= 0 {
- maxDepth = config.Load().ProjectScanMaxDepth
+ maxDepth = config.LoadProjectFilesConfig().ProjectScanMaxDepth
}
var dirFiles []project.IncludeFile
@@ -166,7 +166,7 @@ func readProjectDirectoryFilesInternal(projectPath string, shownFiles map[string
func projectScanSkipDirectorySetInternal(skipDirectories string) map[string]bool {
if strings.TrimSpace(skipDirectories) == "" {
- skipDirectories = config.Load().ProjectScanSkipDirs
+ skipDirectories = config.LoadProjectFilesConfig().ProjectScanSkipDirs
}
dirs := map[string]bool{}
diff --git a/backend/pkg/projects/project_files.go b/backend/pkg/projects/project_files.go
index a13d65b1b..7c00d78e3 100644
--- a/backend/pkg/projects/project_files.go
+++ b/backend/pkg/projects/project_files.go
@@ -42,7 +42,7 @@ type ProjectFileApplyOptions struct {
func ReadProjectFileTree(projectPath string, maxDepth int, skipDirectories, composeFileName string) ([]project.ProjectFile, string, error) {
if maxDepth == ProjectFileTreeUseScanDepth {
- maxDepth = config.Load().ProjectFileTreeMaxDepth
+ maxDepth = config.LoadProjectFilesConfig().ProjectFileTreeMaxDepth
}
projectAbs, err := filepath.Abs(projectPath)