Skip to content

Modern Docker Management, Designed for Everyone

fix: support custom canonical compose filenames (#2285)

Kyle Mendell8bd1650aeb21
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.go
index 45959d9c5..0f31af339 100644
--- a/backend/internal/bootstrap/bootstrap.go
+++ b/backend/internal/bootstrap/bootstrap.go
@@ -137,6 +137,9 @@ func initializeStartupState(appCtx context.Context, cfg *config.Config, appServi
appServices.GitOpsSync.ListSyncIntervalsRaw,
appServices.GitOpsSync.UpdateSyncIntervalMinutes,
)
+ if err := appServices.GitOpsSync.ReconcileDirectorySyncProjectsOnStartup(appCtx); err != nil {
+ slog.WarnContext(appCtx, "Failed to reconcile directory GitOps projects on startup", "error", err)
+ }
}
if err := appServices.Settings.NormalizeProjectsDirectory(appCtx, cfg.ProjectsDirectory); err != nil {
diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.go
index 9b8873db5..1e8fca548 100644
--- a/backend/internal/common/errors.go
+++ b/backend/internal/common/errors.go
@@ -744,6 +744,14 @@ func (e *ProjectFileNotFoundError) Error() string {
return "Project file not found"
}
+type ProjectComposeFileNotFoundError struct {
+ Err error
+}
+
+func (e *ProjectComposeFileNotFoundError) Error() string {
+ return fmt.Sprintf("Project compose file not found: %v", e.Err)
+}
+
type ProjectRedeploymentError struct {
Err error
}
diff --git a/backend/internal/services/gitops_sync_service.go b/backend/internal/services/gitops_sync_service.go
index 8980febf7..892036e1f 100644
--- a/backend/internal/services/gitops_sync_service.go
+++ b/backend/internal/services/gitops_sync_service.go
@@ -1,7 +1,6 @@
package services
import (
- "bytes"
"context"
"encoding/json"
"errors"
@@ -13,6 +12,7 @@ import (
"strings"
"time"
+ "github.com/getarcaneapp/arcane/backend/internal/common"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
"github.com/getarcaneapp/arcane/backend/pkg/libarcane/startup"
@@ -713,6 +713,37 @@ func (s *GitOpsSyncService) SyncAllEnabled(ctx context.Context) error {
return nil
}
+func (s *GitOpsSyncService) ReconcileDirectorySyncProjectsOnStartup(ctx context.Context) error {
+ var syncs []models.GitOpsSync
+ if err := s.db.WithContext(ctx).
+ Where("sync_directory = ?", true).
+ Find(&syncs).Error; err != nil {
+ return fmt.Errorf("failed to list directory syncs for startup reconciliation: %w", err)
+ }
+
+ for i := range syncs {
+ originalProjectID := ""
+ if syncs[i].ProjectID != nil {
+ originalProjectID = *syncs[i].ProjectID
+ }
+
+ project, err := s.getDirectorySyncProjectInternal(ctx, &syncs[i])
+ if err != nil {
+ slog.WarnContext(ctx, "Failed to reconcile directory GitOps sync on startup", "syncId", syncs[i].ID, "error", err)
+ continue
+ }
+ if project == nil {
+ continue
+ }
+
+ if originalProjectID != project.ID {
+ slog.InfoContext(ctx, "Reconciled directory GitOps sync on startup", "syncId", syncs[i].ID, "projectId", project.ID)
+ }
+ }
+
+ return nil
+}
+
func (s *GitOpsSyncService) BrowseFiles(ctx context.Context, environmentID, id string, path string) (*gitops.BrowseResponse, error) {
browseCtx, cancel := context.WithTimeout(ctx, defaultGitSyncTimeout)
defer cancel()
@@ -849,12 +880,16 @@ func (s *GitOpsSyncService) createProjectForSyncInternal(ctx context.Context, sy
func (s *GitOpsSyncService) getOrCreateProjectInternal(ctx context.Context, sync *models.GitOpsSync, id string, composeContent string, envContent *string, result *gitops.SyncResult, actor models.User) (*models.Project, error) {
var project *models.Project
- var err error
if sync.ProjectID != nil && *sync.ProjectID != "" {
- project, err = s.projectService.GetProjectFromDatabaseByID(ctx, *sync.ProjectID)
- if err != nil {
- slog.WarnContext(ctx, "Existing project not found, will create new one", "projectId", *sync.ProjectID, "error", err)
+ var found bool
+ var lookupErr error
+ project, found, lookupErr = s.lookupProjectByIDInternal(ctx, *sync.ProjectID)
+ if lookupErr != nil {
+ return nil, s.failSync(ctx, id, result, sync, actor, "Failed to load existing project", lookupErr.Error())
+ }
+ if !found {
+ slog.WarnContext(ctx, "Existing project not found, will create new one", "projectId", *sync.ProjectID)
project = nil
}
}
@@ -1022,7 +1057,7 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync
}
if project != nil {
- if err := copyDirectoryContentsInternal(project.Path, stagePath); err != nil {
+ if err := projects.CopyDirectoryContents(project.Path, stagePath); err != nil {
_ = os.RemoveAll(stagePath)
return nil, fmt.Errorf("failed to stage current project files: %w", err)
}
@@ -1042,15 +1077,18 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync
}
composeFileName := filepath.Base(sync.ComposePath)
- if err := removeStaleComposeFilesInternal(stagePath, composeFileName, syncedFiles); err != nil {
+ if err := projects.RemoveStaleComposeFiles(stagePath, composeFileName, syncedFiles); err != nil {
_ = os.RemoveAll(stagePath)
return nil, fmt.Errorf("failed to remove stale compose files: %w", err)
}
- contentsChanged, err := directorySyncContentsChangedInternal(project, syncFiles, oldSyncedFiles, composeFileName)
- if err != nil {
- _ = os.RemoveAll(stagePath)
- return nil, fmt.Errorf("failed to compare staged directory changes: %w", err)
+ contentsChanged := true
+ if project != nil {
+ contentsChanged, err = projects.DirectorySyncContentsChanged(project.Path, syncFiles, oldSyncedFiles, composeFileName)
+ if err != nil {
+ _ = os.RemoveAll(stagePath)
+ return nil, fmt.Errorf("failed to compare staged directory changes: %w", err)
+ }
}
// Write the repo files after cleanup so validation sees the final on-disk
@@ -1076,24 +1114,269 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync
}, nil
}
+func (s *GitOpsSyncService) lookupProjectByIDInternal(ctx context.Context, projectID string) (*models.Project, bool, error) {
+ var project models.Project
+ if err := s.db.WithContext(ctx).Where("id = ?", projectID).First(&project).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, false, nil
+ }
+ return nil, false, fmt.Errorf("failed to get project %s: %w", projectID, err)
+ }
+
+ return &project, true, nil
+}
+
+func (s *GitOpsSyncService) lookupProjectByPathInternal(ctx context.Context, projectPath string) (*models.Project, bool, error) {
+ var project models.Project
+ if err := s.db.WithContext(ctx).Where("path = ?", projectPath).First(&project).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, false, nil
+ }
+ return nil, false, fmt.Errorf("failed to get project by path %s: %w", projectPath, err)
+ }
+
+ return &project, true, nil
+}
+
+func (s *GitOpsSyncService) ensureDirectorySyncProjectLinkedInternal(ctx context.Context, sync *models.GitOpsSync, project *models.Project) error {
+ if sync == nil || project == nil {
+ return nil
+ }
+
+ if project.GitOpsManagedBy != nil && *project.GitOpsManagedBy != "" && *project.GitOpsManagedBy != sync.ID {
+ return fmt.Errorf("project %s is already managed by a different GitOps sync", project.ID)
+ }
+
+ if sync.ProjectID != nil && *sync.ProjectID == project.ID && project.GitOpsManagedBy != nil && *project.GitOpsManagedBy == sync.ID {
+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)
+ return nil
+ }
+
+ updatesSync := map[string]any{}
+ updatesProject := map[string]any{}
+ if sync.ProjectID == nil || *sync.ProjectID != project.ID {
+ updatesSync["project_id"] = project.ID
+ }
+ if project.GitOpsManagedBy == nil || *project.GitOpsManagedBy != sync.ID {
+ updatesProject["gitops_managed_by"] = sync.ID
+ }
+
+ if len(updatesSync) == 0 && len(updatesProject) == 0 {
+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)
+ return nil
+ }
+
+ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if len(updatesSync) > 0 {
+ if err := tx.Model(&models.GitOpsSync{}).Where("id = ?", sync.ID).Updates(updatesSync).Error; err != nil {
+ return fmt.Errorf("failed to relink GitOps sync %s: %w", sync.ID, err)
+ }
+ }
+ if len(updatesProject) > 0 {
+ if err := tx.Model(&models.Project{}).Where("id = ?", project.ID).Updates(updatesProject).Error; err != nil {
+ return fmt.Errorf("failed to relink project %s to GitOps sync %s: %w", project.ID, sync.ID, err)
+ }
+ }
+ return nil
+ }); err != nil {
+ return err
+ }
+
+ sync.ProjectID = &project.ID
+ project.GitOpsManagedBy = &sync.ID
+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)
+
+ return nil
+}
+
+func (s *GitOpsSyncService) findRecoverableManagedProjectInternal(ctx context.Context, sync *models.GitOpsSync) (*models.Project, error) {
+ var managedProjects []models.Project
+ if err := s.db.WithContext(ctx).
+ Where("gitops_managed_by = ?", sync.ID).
+ Find(&managedProjects).Error; err != nil {
+ return nil, fmt.Errorf("failed to list GitOps-managed projects for sync %s: %w", sync.ID, err)
+ }
+
+ matches := make([]models.Project, 0, len(managedProjects))
+ for i := range managedProjects {
+ project := managedProjects[i]
+ if err := s.projectService.ensureProjectPathUnderRoot(ctx, &project, true); err != nil {
+ return nil, err
+ }
+ if _, err := s.projectService.resolveProjectComposeFileInternal(ctx, &project); err != nil {
+ if _, ok := errors.AsType[*common.ProjectComposeFileNotFoundError](err); ok {
+ continue
+ }
+ return nil, err
+ }
+ matches = append(matches, project)
+ }
+
+ switch len(matches) {
+ case 0:
+ return nil, nil
+ case 1:
+ return &matches[0], nil
+ default:
+ return nil, fmt.Errorf("multiple GitOps-managed projects match sync %s; refusing automatic relink", sync.ID)
+ }
+}
+
+func (s *GitOpsSyncService) findUniqueProjectDirectoryCandidateInternal(ctx context.Context, sync *models.GitOpsSync) (string, error) {
+ projectsDir, err := s.projectService.getProjectsDirectoryInternal(ctx)
+ if err != nil {
+ return "", err
+ }
+
+ entries, err := os.ReadDir(projectsDir)
+ if err != nil {
+ return "", fmt.Errorf("failed to list projects directory %s: %w", projectsDir, err)
+ }
+
+ composeFileName := strings.TrimSpace(filepath.Base(sync.ComposePath))
+ if composeFileName == "" || composeFileName == "." {
+ return "", nil
+ }
+
+ prefix := projects.SanitizeProjectName(sync.ProjectName)
+ matches := make([]string, 0, 1)
+ for _, entry := range entries {
+ candidatePath := filepath.Join(projectsDir, entry.Name())
+ if !projects.IsProjectDirectoryEntry(entry, candidatePath, false) {
+ continue
+ }
+ if prefix != "" && entry.Name() != prefix && !strings.HasPrefix(entry.Name(), prefix+"-") {
+ continue
+ }
+
+ composePath := filepath.Join(candidatePath, composeFileName)
+ if info, statErr := os.Stat(composePath); statErr == nil {
+ if !info.IsDir() {
+ matches = append(matches, candidatePath)
+ }
+ } else if !os.IsNotExist(statErr) {
+ return "", fmt.Errorf("failed to inspect recovery candidate %s: %w", composePath, statErr)
+ }
+ }
+
+ switch len(matches) {
+ case 0:
+ return "", nil
+ case 1:
+ return matches[0], nil
+ default:
+ return "", fmt.Errorf("multiple project directories match sync %s; refusing automatic relink", sync.ID)
+ }
+}
+
+func (s *GitOpsSyncService) createRecoveredProjectFromDirectoryInternal(ctx context.Context, sync *models.GitOpsSync, projectPath string) (*models.Project, error) {
+ dirName := filepath.Base(projectPath)
+ reason := "Project recovered from existing GitOps-managed directory"
+ project := &models.Project{
+ Name: sync.ProjectName,
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusUnknown,
+ StatusReason: &reason,
+ ServiceCount: 0,
+ RunningCount: 0,
+ GitOpsManagedBy: &sync.ID,
+ }
+
+ if serviceCount, err := s.projectService.countServicesFromCompose(ctx, *project); err == nil {
+ project.ServiceCount = serviceCount
+ } else {
+ slog.WarnContext(ctx, "Failed to count services while recovering GitOps project", "syncId", sync.ID, "path", projectPath, "error", err)
+ }
+
+ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ if err := tx.Create(project).Error; err != nil {
+ return fmt.Errorf("failed to create recovered project for sync %s: %w", sync.ID, err)
+ }
+
+ if err := tx.Model(&models.GitOpsSync{}).Where("id = ?", sync.ID).Update("project_id", project.ID).Error; err != nil {
+ return fmt.Errorf("failed to relink sync %s to recovered project %s: %w", sync.ID, project.ID, err)
+ }
+
+ return nil
+ }); err != nil {
+ return nil, err
+ }
+
+ sync.ProjectID = &project.ID
+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)
+
+ return project, nil
+}
+
+func (s *GitOpsSyncService) recoverProjectFromDirectoryCandidateInternal(ctx context.Context, sync *models.GitOpsSync) (*models.Project, error) {
+ projectPath, err := s.findUniqueProjectDirectoryCandidateInternal(ctx, sync)
+ if err != nil || projectPath == "" {
+ return nil, err
+ }
+
+ project, found, err := s.lookupProjectByPathInternal(ctx, projectPath)
+ if err != nil {
+ return nil, err
+ }
+ if found {
+ if err := s.projectService.ensureProjectPathUnderRoot(ctx, project, true); err != nil {
+ return nil, err
+ }
+ if err := s.ensureDirectorySyncProjectLinkedInternal(ctx, sync, project); err != nil {
+ return nil, err
+ }
+ return project, nil
+ }
+
+ return s.createRecoveredProjectFromDirectoryInternal(ctx, sync, projectPath)
+}
+
// getDirectorySyncProjectInternal resolves the linked project for a sync when one
// exists, while tolerating deleted/stale project references.
func (s *GitOpsSyncService) getDirectorySyncProjectInternal(ctx context.Context, sync *models.GitOpsSync) (*models.Project, error) {
- if sync.ProjectID == nil || *sync.ProjectID == "" {
+ if sync == nil {
return nil, nil
}
- project, err := s.projectService.GetProjectFromDatabaseByID(ctx, *sync.ProjectID)
+ if sync.ProjectID != nil && *sync.ProjectID != "" {
+ project, found, err := s.lookupProjectByIDInternal(ctx, *sync.ProjectID)
+ if err != nil {
+ return nil, err
+ }
+ if found {
+ if err := s.projectService.ensureProjectPathUnderRoot(ctx, project, true); err != nil {
+ return nil, err
+ }
+ if err := s.ensureDirectorySyncProjectLinkedInternal(ctx, sync, project); err != nil {
+ return nil, err
+ }
+ return project, nil
+ }
+
+ slog.WarnContext(ctx, "Existing project not found, attempting recovery", "projectId", *sync.ProjectID, "syncId", sync.ID)
+ }
+
+ project, err := s.findRecoverableManagedProjectInternal(ctx, sync)
if err != nil {
- slog.WarnContext(ctx, "Existing project not found, will create new one", "projectId", *sync.ProjectID, "error", err)
- return nil, nil
+ return nil, err
+ }
+ if project != nil {
+ if err := s.ensureDirectorySyncProjectLinkedInternal(ctx, sync, project); err != nil {
+ return nil, err
+ }
+ return project, nil
}
- if err := s.projectService.ensureProjectPathUnderRoot(ctx, project, false); err != nil {
+ project, err = s.recoverProjectFromDirectoryCandidateInternal(ctx, sync)
+ if err != nil {
return nil, err
}
+ if project != nil {
+ return project, nil
+ }
- return project, nil
+ return nil, nil
}
// validateDirectorySyncStageInternal loads the staged compose project using the real
@@ -1236,141 +1519,6 @@ func (s *GitOpsSyncService) updateDirectorySyncProjectInternal(ctx context.Conte
return project, nil
}
-// directorySyncContentsChangedInternal compares the currently managed synced files with
-// the newly fetched repo files to decide whether a redeploy is needed.
-func directorySyncContentsChangedInternal(project *models.Project, syncFiles []projects.SyncFile, oldSyncedFiles []string, composeFileName string) (bool, error) {
- if project == nil {
- return true, nil
- }
-
- if info, err := os.Stat(project.Path); err != nil {
- if errors.Is(err, os.ErrNotExist) {
- return true, nil
- }
- return false, err
- } else if !info.IsDir() {
- return false, fmt.Errorf("project path is not a directory: %s", project.Path)
- }
-
- newFileSet := make(map[string]struct{}, len(syncFiles))
- for _, file := range syncFiles {
- newFileSet[file.RelativePath] = struct{}{}
- existingContent, err := os.ReadFile(filepath.Join(project.Path, file.RelativePath))
- if err != nil {
- if errors.Is(err, os.ErrNotExist) {
- return true, nil
- }
- return false, err
- }
- if !bytes.Equal(existingContent, file.Content) {
- return true, nil
- }
- }
-
- for _, oldFile := range oldSyncedFiles {
- if _, exists := newFileSet[oldFile]; exists {
- continue
- }
- if _, err := os.Stat(filepath.Join(project.Path, oldFile)); err == nil {
- return true, nil
- } else if !errors.Is(err, os.ErrNotExist) {
- return false, err
- }
- }
-
- for _, candidate := range projects.ComposeFileCandidates() {
- if candidate == composeFileName {
- continue
- }
- if _, exists := newFileSet[candidate]; exists {
- continue
- }
- if _, err := os.Stat(filepath.Join(project.Path, candidate)); err == nil {
- return true, nil
- } else if !errors.Is(err, os.ErrNotExist) {
- return false, err
- }
- }
-
- return false, nil
-}
-
-// removeStaleComposeFilesInternal drops old canonical compose filenames from the staged
-// project when the repo now uses a different compose filename.
-func removeStaleComposeFilesInternal(projectPath, composeFileName string, syncedFiles []string) error {
- syncedFileSet := make(map[string]struct{}, len(syncedFiles))
- for _, file := range syncedFiles {
- syncedFileSet[file] = struct{}{}
- }
-
- for _, candidate := range projects.ComposeFileCandidates() {
- if candidate == composeFileName {
- continue
- }
- if _, exists := syncedFileSet[candidate]; exists {
- continue
- }
- if err := os.Remove(filepath.Join(projectPath, candidate)); err != nil && !errors.Is(err, os.ErrNotExist) {
- return err
- }
- }
-
- return nil
-}
-
-// copyDirectoryContentsInternal clones the current project tree into the staging
-// directory so directory sync updates can preserve non-synced local files.
-func copyDirectoryContentsInternal(srcDir, destDir string) error {
- srcRoot, err := os.OpenRoot(srcDir)
- if err != nil {
- return err
- }
- defer func() { _ = srcRoot.Close() }()
-
- destRoot, err := os.OpenRoot(destDir)
- if err != nil {
- return err
- }
- defer func() { _ = destRoot.Close() }()
-
- return filepath.WalkDir(srcDir, func(path string, d os.DirEntry, walkErr error) error {
- if walkErr != nil {
- return walkErr
- }
- if path == srcDir {
- return nil
- }
-
- relPath, err := filepath.Rel(srcDir, path)
- if err != nil {
- return err
- }
-
- if d.IsDir() {
- return destRoot.MkdirAll(relPath, 0o755)
- }
- if d.Type()&os.ModeSymlink != 0 {
- return nil
- }
-
- info, err := d.Info()
- if err != nil {
- return err
- }
-
- content, err := srcRoot.ReadFile(relPath)
- if err != nil {
- return err
- }
-
- if err := destRoot.MkdirAll(filepath.Dir(relPath), 0o755); err != nil {
- return err
- }
-
- return destRoot.WriteFile(relPath, content, info.Mode())
- })
-}
-
// updateSyncStatusWithFiles updates sync status including the list of synced files
func (s *GitOpsSyncService) updateSyncStatusWithFiles(ctx context.Context, id, status, errorMsg, commitHash string, syncedFiles []string) {
now := time.Now()
diff --git a/backend/internal/services/gitops_sync_service_test.go b/backend/internal/services/gitops_sync_service_test.go
index 5d1f53f55..dadc27c16 100644
--- a/backend/internal/services/gitops_sync_service_test.go
+++ b/backend/internal/services/gitops_sync_service_test.go
@@ -243,6 +243,140 @@ func TestGitOpsSyncService_CreateDirectorySyncProjectInternal_RollsBackProjectOn
assert.ErrorIs(t, statErr, os.ErrNotExist)
}
+func TestProjectsRemoveStaleComposeFiles_RemovesStaleCustomComposeFiles(t *testing.T) {
+ t.Parallel()
+
+ projectPath := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "sonarr.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "values.yaml"), []byte("replicaCount: 2\nimage:\n tag: latest\n"), 0o644))
+
+ err := projects.RemoveStaleComposeFiles(projectPath, "sonarr.yaml", []string{"sonarr.yaml"})
+ require.NoError(t, err)
+
+ _, statErr := os.Stat(filepath.Join(projectPath, "radarr.yaml"))
+ assert.ErrorIs(t, statErr, os.ErrNotExist)
+
+ _, statErr = os.Stat(filepath.Join(projectPath, "sonarr.yaml"))
+ require.NoError(t, statErr)
+
+ _, statErr = os.Stat(filepath.Join(projectPath, "values.yaml"))
+ require.NoError(t, statErr)
+}
+
+func TestGitOpsSyncService_GetDirectorySyncProjectInternal_RelinksManagedProjectWhenProjectIDStale(t *testing.T) {
+ ctx := context.Background()
+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)
+
+ projectPath := filepath.Join(projectsDir, "Radarr-3")
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))
+
+ sync := &models.GitOpsSync{
+ BaseModel: models.BaseModel{ID: "sync-directory-relink"},
+ Name: "radarr-sync",
+ EnvironmentID: "0",
+ RepositoryID: "repo-1",
+ ComposePath: "apps/media/radarr.yaml",
+ ProjectName: "Radarr",
+ ProjectID: ptr("missing-project"),
+ SyncDirectory: true,
+ }
+ require.NoError(t, db.Create(sync).Error)
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-directory-relink"},
+ Name: "Radarr",
+ DirName: ptr("Radarr-3"),
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ GitOpsManagedBy: &sync.ID,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ recovered, err := svc.getDirectorySyncProjectInternal(ctx, sync)
+ require.NoError(t, err)
+ require.NotNil(t, recovered)
+ assert.Equal(t, project.ID, recovered.ID)
+
+ var storedSync models.GitOpsSync
+ require.NoError(t, db.First(&storedSync, "id = ?", sync.ID).Error)
+ require.NotNil(t, storedSync.ProjectID)
+ assert.Equal(t, project.ID, *storedSync.ProjectID)
+}
+
+func TestGitOpsSyncService_GetDirectorySyncProjectInternal_RecoversUniqueDirectoryCandidate(t *testing.T) {
+ ctx := context.Background()
+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)
+
+ projectPath := filepath.Join(projectsDir, "Radarr-3")
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))
+
+ sync := &models.GitOpsSync{
+ BaseModel: models.BaseModel{ID: "sync-directory-disk-recovery"},
+ Name: "radarr-sync",
+ EnvironmentID: "0",
+ RepositoryID: "repo-1",
+ ComposePath: "apps/media/radarr.yaml",
+ ProjectName: "Radarr",
+ ProjectID: ptr("missing-project"),
+ SyncDirectory: true,
+ }
+ require.NoError(t, db.Create(sync).Error)
+
+ recovered, err := svc.getDirectorySyncProjectInternal(ctx, sync)
+ require.NoError(t, err)
+ require.NotNil(t, recovered)
+ assert.Equal(t, projectPath, recovered.Path)
+ require.NotNil(t, recovered.GitOpsManagedBy)
+ assert.Equal(t, sync.ID, *recovered.GitOpsManagedBy)
+
+ var storedSync models.GitOpsSync
+ require.NoError(t, db.First(&storedSync, "id = ?", sync.ID).Error)
+ require.NotNil(t, storedSync.ProjectID)
+ assert.Equal(t, recovered.ID, *storedSync.ProjectID)
+
+ var storedProject models.Project
+ require.NoError(t, db.First(&storedProject, "id = ?", recovered.ID).Error)
+ assert.Equal(t, projectPath, storedProject.Path)
+ assert.Equal(t, 1, storedProject.ServiceCount)
+}
+
+func TestGitOpsSyncService_ReconcileDirectorySyncProjectsOnStartup_SkipsAmbiguousDuplicates(t *testing.T) {
+ ctx := context.Background()
+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)
+
+ for _, dirName := range []string{"Radarr-3", "Radarr-30"} {
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))
+ }
+
+ sync := &models.GitOpsSync{
+ BaseModel: models.BaseModel{ID: "sync-directory-ambiguous"},
+ Name: "radarr-sync",
+ EnvironmentID: "0",
+ RepositoryID: "repo-1",
+ ComposePath: "apps/media/radarr.yaml",
+ ProjectName: "Radarr",
+ ProjectID: ptr("missing-project"),
+ SyncDirectory: true,
+ }
+ require.NoError(t, db.Create(sync).Error)
+
+ require.NoError(t, svc.ReconcileDirectorySyncProjectsOnStartup(ctx))
+
+ var projectsCount int64
+ require.NoError(t, db.Model(&models.Project{}).Count(&projectsCount).Error)
+ assert.Zero(t, projectsCount)
+
+ var storedSync models.GitOpsSync
+ require.NoError(t, db.First(&storedSync, "id = ?", sync.ID).Error)
+ require.NotNil(t, storedSync.ProjectID)
+ assert.Equal(t, "missing-project", *storedSync.ProjectID)
+}
+
func TestEnvContentChangedInternal(t *testing.T) {
t.Run("ignores formatting-only changes", func(t *testing.T) {
oldEnv := "B=2\nA=1\n# comment\n"
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index c76f7473c..f419d78a0 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -389,22 +389,76 @@ func (s *ProjectService) GetProjectByComposeName(ctx context.Context, name strin
return nil, fmt.Errorf("project not found: %s", name)
}
-func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {
- projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
+func (s *ProjectService) resolveProjectComposeFileInternal(ctx context.Context, proj *models.Project) (string, error) {
+ if proj == nil {
+ return "", fmt.Errorf("project is nil")
+ }
+
+ if proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != "" {
+ var sync models.GitOpsSync
+ if err := s.db.WithContext(ctx).
+ Select("compose_path").
+ Where("id = ?", *proj.GitOpsManagedBy).
+ First(&sync).Error; err == nil {
+ composeFileName := strings.TrimSpace(filepath.Base(sync.ComposePath))
+ if composeFileName != "" && composeFileName != "." {
+ candidate := filepath.Join(proj.Path, composeFileName)
+ if info, statErr := os.Stat(candidate); statErr == nil {
+ if !info.IsDir() {
+ return candidate, nil
+ }
+ } else if !os.IsNotExist(statErr) {
+ return "", fmt.Errorf("failed to inspect GitOps compose file %s: %w", candidate, statErr)
+ }
+ }
+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return "", fmt.Errorf("failed to resolve GitOps compose path for project %s: %w", proj.ID, err)
+ }
+ }
+
+ composeFile, err := projects.DetectComposeFile(proj.Path)
if err != nil {
- return err
+ return "", &common.ProjectComposeFileNotFoundError{Err: err}
}
- // 1. Load project
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
+ return composeFile, nil
+}
+
+func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Context, proj *models.Project) (*composetypes.Project, string, error) {
+ composeFileFullPath, err := s.resolveProjectComposeFileInternal(ctx, proj)
if err != nil {
+ return nil, "", err
+ }
+
+ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
+ projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
+ if pdErr != nil {
+ slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
projectsDirectory = "/app/data/projects"
}
- pathMapper, _ := s.getPathMapper(ctx)
+ pathMapper, pmErr := s.getPathMapper(ctx)
+ if pmErr != nil {
+ slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
+ }
+
autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- compProj, _, err := projects.LoadComposeProjectFromDir(ctx, projectFromDb.Path, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ if loadErr != nil {
+ return nil, "", loadErr
+ }
+
+ return composeProject, composeFileFullPath, nil
+}
+
+func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {
+ projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
+ if err != nil {
+ return err
+ }
+
+ // 1. Load project
+ compProj, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
if err != nil {
return fmt.Errorf("failed to load compose project: %w", err)
}
@@ -502,38 +556,19 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strin
return nil, err
}
- composeFileFullPath, derr := projects.DetectComposeFile(projectFromDb.Path)
+ composeProject, composeFileFullPath, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
if derr != nil {
return []ProjectServiceInfo{}, fmt.Errorf("no compose file found in project directory: %s", projectFromDb.Path)
}
- // Get configured projects directory from settings
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- project, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)
- if loadErr != nil {
- return []ProjectServiceInfo{}, fmt.Errorf("failed to load compose project from %s: %w", projectFromDb.Path, loadErr)
- }
-
meta, metaErr := projects.ParseArcaneComposeMetadata(ctx, composeFileFullPath)
if metaErr != nil {
slog.WarnContext(ctx, "failed to parse Arcane compose metadata", "path", composeFileFullPath, "error", metaErr)
}
- containers, err := projects.ComposePs(ctx, project, nil, true)
+ containers, err := projects.ComposePs(ctx, composeProject, nil, true)
if err != nil {
- slog.Error("compose ps error", "projectName", project.Name, "error", err)
+ slog.Error("compose ps error", "projectName", composeProject.Name, "error", err)
return nil, fmt.Errorf("failed to get compose services status: %w", err)
}
@@ -542,7 +577,7 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strin
// Create a map for quick lookup of service config
serviceConfigs := make(map[string]composetypes.ServiceConfig)
- for _, svc := range project.Services {
+ for _, svc := range composeProject.Services {
serviceConfigs[svc.Name] = svc
}
@@ -571,7 +606,7 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strin
have[c.Service] = true
}
- for _, svc := range project.Services {
+ for _, svc := range composeProject.Services {
if !have[svc.Name] {
services = append(services, ProjectServiceInfo{
Name: svc.Name,
@@ -592,7 +627,13 @@ func (s *ProjectService) GetProjectContent(ctx context.Context, projectID string
if err != nil {
return "", "", err
}
- return projects.ReadProjectFiles(proj.Path)
+
+ composePath, composeErr := s.resolveProjectComposeFileInternal(ctx, proj)
+ if composeErr != nil {
+ composePath = ""
+ }
+
+ return projects.ReadProjectFiles(proj.Path, composePath)
}
func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string) (project.Details, error) {
@@ -626,7 +667,7 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
resp.DirName = utils.DerefString(proj.DirName)
resp.RelativePath = s.getProjectRelativePathInternal(projectsDir, proj.Path)
resp.GitOpsManagedBy = proj.GitOpsManagedBy
- meta := s.getProjectMetadataFromPath(ctx, proj.Path)
+ meta := s.getProjectMetadataForProject(ctx, *proj)
resp.IconURL = meta.ProjectIconURL
resp.URLs = meta.ProjectURLS
@@ -636,16 +677,14 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
resp.Status = string(proj.Status)
// Enrich with details
- s.enrichWithIncludeFiles(ctx, proj.Path, &resp)
- s.enrichWithDirectoryFiles(ctx, proj.Path, &resp)
- s.enrichWithGitOpsInfo(ctx, proj, &resp)
-
- // Load compose project for service definitions
- composeFile, _ := projects.DetectComposeFile(proj.Path)
- if composeFile != "" {
+ composeFile, composeFileErr := s.resolveProjectComposeFileInternal(ctx, proj)
+ if composeFileErr == nil {
resp.ComposeFileName = filepath.Base(composeFile)
+ s.enrichWithIncludeFiles(ctx, composeFile, &resp)
s.enrichWithComposeServiceConfigs(ctx, proj, composeFile, &resp)
}
+ s.enrichWithDirectoryFiles(ctx, proj.Path, &resp)
+ s.enrichWithGitOpsInfo(ctx, proj, &resp)
// Get runtime services and update status/counts
services, serr := s.GetProjectServices(ctx, projectID)
@@ -684,7 +723,7 @@ func (s *ProjectService) GetProjectFileContent(ctx context.Context, projectID, r
return project.IncludeFile{}, &common.ProjectFileBadRequestError{Err: fmt.Errorf("relative path is required")}
}
- composeFile, detectErr := projects.DetectComposeFile(proj.Path)
+ composeFile, detectErr := s.resolveProjectComposeFileInternal(ctx, proj)
if detectErr == nil {
projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
projectsDirectory, _ := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
@@ -751,29 +790,30 @@ func (s *ProjectService) GetProjectFileContent(ctx context.Context, projectID, r
}, nil
}
-func (s *ProjectService) enrichWithIncludeFiles(ctx context.Context, projectPath string, resp *project.Details) {
- composeFile, detectErr := projects.DetectComposeFile(projectPath)
- if detectErr == nil {
- // Load environment variables so that include paths with ${VAR} references are expanded
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, _ := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- envLoader := projects.NewEnvLoader(projectsDirectory, filepath.Dir(composeFile), autoInjectEnv)
- envMap, _, _ := envLoader.LoadEnvironment(ctx)
+func (s *ProjectService) enrichWithIncludeFiles(ctx context.Context, composeFile string, resp *project.Details) {
+ if strings.TrimSpace(composeFile) == "" {
+ return
+ }
- includes, parseErr := projects.ParseIncludes(composeFile, envMap, false)
- if parseErr == nil {
- var includeFiles []project.IncludeFile
- for _, inc := range includes {
- includeFiles = append(includeFiles, project.IncludeFile{
- Path: inc.Path,
- RelativePath: inc.RelativePath,
- })
- }
- resp.IncludeFiles = includeFiles
- } else {
- slog.WarnContext(ctx, "Failed to parse includes", "error", parseErr, "path", projectPath)
+ // Load environment variables so that include paths with ${VAR} references are expanded
+ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
+ projectsDirectory, _ := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
+ autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
+ envLoader := projects.NewEnvLoader(projectsDirectory, filepath.Dir(composeFile), autoInjectEnv)
+ envMap, _, _ := envLoader.LoadEnvironment(ctx)
+
+ includes, parseErr := projects.ParseIncludes(composeFile, envMap, false)
+ if parseErr == nil {
+ var includeFiles []project.IncludeFile
+ for _, inc := range includes {
+ includeFiles = append(includeFiles, project.IncludeFile{
+ Path: inc.Path,
+ RelativePath: inc.RelativePath,
+ })
}
+ resp.IncludeFiles = includeFiles
+ } else {
+ slog.WarnContext(ctx, "Failed to parse includes", "error", parseErr, "path", composeFile)
}
}
@@ -789,6 +829,8 @@ func (s *ProjectService) enrichWithDirectoryFiles(ctx context.Context, projectPa
"compose.yml": true,
"docker-compose.yaml": true,
"docker-compose.yml": true,
+ "podman-compose.yaml": true,
+ "podman-compose.yml": true,
}
for _, inc := range resp.IncludeFiles {
shownFiles[inc.RelativePath] = true
@@ -976,7 +1018,11 @@ func (s *ProjectService) cleanupDBProjects(ctx context.Context, seen map[string]
continue
}
- if _, err := projects.DetectComposeFile(p.Path); err != nil {
+ if _, err := s.resolveProjectComposeFileInternal(ctx, &p); err != nil {
+ if _, ok := errors.AsType[*common.ProjectComposeFileNotFoundError](err); !ok {
+ slog.WarnContext(ctx, "failed to validate project compose file during cleanup", "projectID", p.ID, "path", p.Path, "error", err)
+ continue
+ }
if derr := s.db.WithContext(ctx).Delete(&models.Project{}, "id = ?", p.ID).Error; derr != nil {
slog.WarnContext(ctx, "failed to delete project without compose", "projectID", p.ID, "error", derr)
}
@@ -1136,30 +1182,11 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us
resolvedPullPolicy = "missing"
}
- composeFileFullPath, derr := projects.DetectComposeFile(projectFromDb.Path)
+ project, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
if derr != nil {
return fmt.Errorf("no compose file found in project directory: %s", projectFromDb.Path)
}
- // Get configured projects directory from settings
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- project, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)
- if loadErr != nil {
- return fmt.Errorf("failed to load compose project from %s: %w", projectFromDb.Path, loadErr)
- }
-
if err := s.updateProjectStatusInternal(ctx, projectID, models.ProjectStatusDeploying); err != nil {
return fmt.Errorf("failed to update project status to deploying: %w", err)
}
@@ -1208,21 +1235,7 @@ func (s *ProjectService) DownProject(ctx context.Context, projectID string, user
return err
}
- // Get configured projects directory from settings
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- proj, _, lerr := projects.LoadComposeProjectFromDir(ctx, projectFromDb.Path, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ proj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
if lerr != nil {
_ = s.updateProjectStatusInternal(ctx, projectID, models.ProjectStatusRunning)
return fmt.Errorf("failed to load compose project: %w", lerr)
@@ -1312,21 +1325,7 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, r
}
if removeVolumes {
- // Get configured projects directory from settings
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- if compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper); lerr == nil {
+ if compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj); lerr == nil {
if derr := projects.ComposeDown(ctx, compProj, true); derr != nil {
slog.WarnContext(ctx, "failed to remove volumes", "error", derr)
}
@@ -1382,21 +1381,7 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID string
return err
}
- // Get configured projects directory from settings
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)
if lerr != nil {
return fmt.Errorf("failed to load compose project: %w", lerr)
}
@@ -1437,29 +1422,11 @@ func (s *ProjectService) BuildProjectServices(ctx context.Context, projectID str
return err
}
- composeFileFullPath, derr := projects.DetectComposeFile(projectFromDb.Path)
+ project, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
if derr != nil {
return fmt.Errorf("no compose file found in project directory: %s", projectFromDb.Path)
}
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- project, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)
- if loadErr != nil {
- return fmt.Errorf("failed to load compose project from %s: %w", projectFromDb.Path, loadErr)
- }
-
return s.buildProjectServicesInternal(ctx, projectID, project, options, progressWriter, user)
}
@@ -1474,21 +1441,7 @@ func (s *ProjectService) EnsureProjectImagesPresent(ctx context.Context, project
return err
}
- // Get configured projects directory from settings
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if pdErr != nil {
- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)
- projectsDirectory = "/app/data/projects"
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)
if lerr != nil {
return fmt.Errorf("failed to load compose project: %w", lerr)
}
@@ -2999,7 +2952,7 @@ func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, pro
results[i].DirName = utils.DerefString(p.DirName)
results[i].RelativePath = s.getProjectRelativePathInternal(projectsDir, p.Path)
results[i].GitOpsManagedBy = p.GitOpsManagedBy
- meta := s.getProjectMetadataFromPath(ctx, p.Path)
+ meta := s.getProjectMetadataForProject(ctx, p)
results[i].IconURL = meta.ProjectIconURL
results[i].URLs = meta.ProjectURLS
results[i].Status = string(models.ProjectStatusUnknown)
@@ -3034,7 +2987,7 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir string
resp.DirName = utils.DerefString(p.DirName)
resp.RelativePath = s.getProjectRelativePathInternal(projectsDir, p.Path)
resp.GitOpsManagedBy = p.GitOpsManagedBy
- meta := s.getProjectMetadataFromPath(ctx, p.Path)
+ meta := s.getProjectMetadataForProject(ctx, p)
resp.IconURL = meta.ProjectIconURL
resp.URLs = meta.ProjectURLS
@@ -3137,8 +3090,8 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir string
return resp
}
-func (s *ProjectService) getProjectMetadataFromPath(ctx context.Context, projectPath string) projects.ArcaneComposeMetadata {
- composeFile, err := projects.DetectComposeFile(projectPath)
+func (s *ProjectService) getProjectMetadataForProject(ctx context.Context, p models.Project) projects.ArcaneComposeMetadata {
+ composeFile, err := s.resolveProjectComposeFileInternal(ctx, &p)
if err != nil {
return projects.ArcaneComposeMetadata{ServiceIcons: map[string]string{}}
}
@@ -3155,19 +3108,7 @@ func (s *ProjectService) getProjectMetadataFromPath(ctx context.Context, project
// End Table Functions
func (s *ProjectService) countServicesFromCompose(ctx context.Context, p models.Project) (int, error) {
- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
- projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
- if err != nil {
- return 0, err
- }
-
- pathMapper, pmErr := s.getPathMapper(ctx)
- if pmErr != nil {
- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)
- }
-
- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
- proj, _, err := projects.LoadComposeProjectFromDir(ctx, p.Path, normalizeComposeProjectName(p.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ proj, _, err := s.loadComposeProjectForProjectInternal(ctx, &p)
if err != nil {
return 0, err
}
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index 9306dcfc2..17ea224d2 100644
--- a/backend/internal/services/project_service_test.go
+++ b/backend/internal/services/project_service_test.go
@@ -1954,6 +1954,110 @@ func TestProjectService_SyncProjectsFromFileSystem_RefreshesServiceCountOnCompos
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)
+ 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()
diff --git a/backend/pkg/projects/discovery_test.go b/backend/pkg/projects/discovery_test.go
index 324a2cba7..581fbb1d5 100644
--- a/backend/pkg/projects/discovery_test.go
+++ b/backend/pkg/projects/discovery_test.go
@@ -103,6 +103,19 @@ func TestDiscoverProjectDirectories_NestedStandaloneProject(t *testing.T) {
require.Equal(t, []string{"nested"}, names)
}
+func TestDiscoverProjectDirectories_SupportsCustomComposeFilename(t *testing.T) {
+ root := t.TempDir()
+ projectDir := filepath.Join(root, "Radarr-3")
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte("services: {}\n"), 0o644))
+
+ discovered, err := DiscoverProjectDirectories(root, false)
+ require.NoError(t, err)
+ require.Len(t, discovered, 1)
+ require.Equal(t, "Radarr-3", discovered[0].DirName)
+ require.Equal(t, projectDir, discovered[0].Path)
+}
+
// DiscoveredProjectDirectories_call is a tiny helper so tests can share the
// err-check boilerplate.
func DiscoveredProjectDirectories_call(t *testing.T, root string) []DiscoveredProjectDir {
diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.go
index 7c1894530..858be430a 100644
--- a/backend/pkg/projects/fs_util.go
+++ b/backend/pkg/projects/fs_util.go
@@ -1,6 +1,7 @@
package projects
import (
+ "bytes"
"context"
"fmt"
"log/slog"
@@ -12,6 +13,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/config"
pkgutils "github.com/getarcaneapp/arcane/backend/pkg/utils"
"github.com/getarcaneapp/arcane/types/project"
+ "github.com/goccy/go-yaml"
)
func ResolveConfiguredContainerDirectory(configuredPath, defaultPath string) string {
@@ -93,9 +95,13 @@ func isBackendModuleRoot(path string) bool {
return true
}
-func ReadProjectFiles(projectPath string) (composeContent, envContent string, err error) {
- if composeFile, derr := DetectComposeFile(projectPath); derr == nil && composeFile != "" {
- if content, rerr := os.ReadFile(composeFile); rerr == nil {
+func ReadProjectFiles(projectPath, composePath string) (composeContent, envContent string, err error) {
+ if strings.TrimSpace(composePath) == "" {
+ composePath, _ = DetectComposeFile(projectPath)
+ }
+
+ if strings.TrimSpace(composePath) != "" {
+ if content, rerr := os.ReadFile(composePath); rerr == nil {
composeContent = string(content)
}
}
@@ -108,6 +114,22 @@ func ReadProjectFiles(projectPath string) (composeContent, envContent string, er
return composeContent, envContent, nil
}
+func HasComposeRootKeysInFile(path string) (bool, error) {
+ content, err := os.ReadFile(path)
+ if err != nil {
+ return false, err
+ }
+
+ composeData := map[string]any{}
+ if err := yaml.Unmarshal(content, &composeData); err != nil {
+ return false, err
+ }
+
+ _, hasServices := composeData["services"]
+ _, hasInclude := composeData["include"]
+ return hasServices || hasInclude, nil
+}
+
func GetTemplatesDirectory(ctx context.Context) (string, error) {
templatesDir := filepath.Join("data", "templates")
if _, err := os.Stat(templatesDir); os.IsNotExist(err) {
@@ -236,6 +258,163 @@ func IsBinaryProjectFileContent(content []byte) bool {
return slices.Contains(content[:checkSize], 0)
}
+func DirectorySyncContentsChanged(projectPath string, syncFiles []SyncFile, oldSyncedFiles []string, composeFileName string) (bool, error) {
+ if info, err := os.Stat(projectPath); err != nil {
+ if os.IsNotExist(err) {
+ return true, nil
+ }
+ return false, err
+ } else if !info.IsDir() {
+ return false, fmt.Errorf("project path is not a directory: %s", projectPath)
+ }
+
+ newFileSet := make(map[string]struct{}, len(syncFiles))
+ for _, file := range syncFiles {
+ newFileSet[file.RelativePath] = struct{}{}
+ existingContent, err := os.ReadFile(filepath.Join(projectPath, file.RelativePath))
+ if err != nil {
+ if os.IsNotExist(err) {
+ return true, nil
+ }
+ return false, err
+ }
+ if !bytes.Equal(existingContent, file.Content) {
+ return true, nil
+ }
+ }
+
+ for _, oldFile := range oldSyncedFiles {
+ if _, exists := newFileSet[oldFile]; exists {
+ continue
+ }
+ if _, err := os.Stat(filepath.Join(projectPath, oldFile)); err == nil {
+ return true, nil
+ } else if !os.IsNotExist(err) {
+ return false, err
+ }
+ }
+
+ for _, candidate := range ComposeFileCandidates() {
+ if candidate == composeFileName {
+ continue
+ }
+ if _, exists := newFileSet[candidate]; exists {
+ continue
+ }
+ if _, err := os.Stat(filepath.Join(projectPath, candidate)); err == nil {
+ return true, nil
+ } else if !os.IsNotExist(err) {
+ return false, err
+ }
+ }
+
+ return false, nil
+}
+
+func RemoveStaleComposeFiles(projectPath, composeFileName string, syncedFiles []string) error {
+ syncedFileSet := make(map[string]struct{}, len(syncedFiles))
+ for _, file := range syncedFiles {
+ syncedFileSet[file] = struct{}{}
+ }
+
+ for _, candidate := range ComposeFileCandidates() {
+ if candidate == composeFileName {
+ continue
+ }
+ if _, exists := syncedFileSet[candidate]; exists {
+ continue
+ }
+ if err := os.Remove(filepath.Join(projectPath, candidate)); err != nil && !os.IsNotExist(err) {
+ return err
+ }
+ }
+
+ entries, err := os.ReadDir(projectPath)
+ if err != nil {
+ return err
+ }
+
+ for _, entry := range entries {
+ if entry.IsDir() {
+ continue
+ }
+
+ name := entry.Name()
+ if name == composeFileName {
+ continue
+ }
+ if _, exists := syncedFileSet[name]; exists {
+ continue
+ }
+ if slices.Contains(ComposeFileCandidates(), name) || !IsProjectFile(name) {
+ continue
+ }
+
+ path := filepath.Join(projectPath, name)
+ hasComposeRootKeys, rootKeysErr := HasComposeRootKeysInFile(path)
+ if rootKeysErr != nil || !hasComposeRootKeys {
+ continue
+ }
+
+ if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func CopyDirectoryContents(srcDir, destDir string) error {
+ srcRoot, err := os.OpenRoot(srcDir)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = srcRoot.Close() }()
+
+ destRoot, err := os.OpenRoot(destDir)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = destRoot.Close() }()
+
+ return filepath.WalkDir(srcDir, func(path string, d os.DirEntry, walkErr error) error {
+ if walkErr != nil {
+ return walkErr
+ }
+ if path == srcDir {
+ return nil
+ }
+
+ relPath, err := filepath.Rel(srcDir, path)
+ if err != nil {
+ return err
+ }
+
+ if d.IsDir() {
+ return destRoot.MkdirAll(relPath, 0o755)
+ }
+ if d.Type()&os.ModeSymlink != 0 {
+ return nil
+ }
+
+ info, err := d.Info()
+ if err != nil {
+ return err
+ }
+
+ content, err := srcRoot.ReadFile(relPath)
+ if err != nil {
+ return err
+ }
+
+ if err := destRoot.MkdirAll(filepath.Dir(relPath), 0o755); err != nil {
+ return err
+ }
+
+ return destRoot.WriteFile(relPath, content, info.Mode())
+ })
+}
+
// CreateUniqueDir creates a unique directory within the allowed projectsRoot.
// It validates that the created directory is always within projectsRoot.
func CreateUniqueDir(projectsRoot, basePath, name string, perm os.FileMode) (path, folderName string, err error) {
diff --git a/backend/pkg/projects/fs_util_test.go b/backend/pkg/projects/fs_util_test.go
index 52656bafe..715d39963 100644
--- a/backend/pkg/projects/fs_util_test.go
+++ b/backend/pkg/projects/fs_util_test.go
@@ -65,6 +65,30 @@ func TestResolveConfiguredContainerDirectory(t *testing.T) {
})
}
+func TestReadProjectFiles(t *testing.T) {
+ t.Run("detects compose path when not provided", func(t *testing.T) {
+ projectPath := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TZ=UTC\n"), 0o644))
+
+ composeContent, envContent, err := ReadProjectFiles(projectPath, "")
+ require.NoError(t, err)
+ assert.Contains(t, composeContent, "services:")
+ assert.Equal(t, "TZ=UTC\n", envContent)
+ })
+
+ t.Run("uses explicit compose path when provided", func(t *testing.T) {
+ projectPath := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TZ=UTC\n"), 0o644))
+
+ composeContent, envContent, err := ReadProjectFiles(projectPath, filepath.Join(projectPath, "radarr.yaml"))
+ require.NoError(t, err)
+ assert.Contains(t, composeContent, "radarr")
+ assert.Equal(t, "TZ=UTC\n", envContent)
+ })
+}
+
func TestReadProjectDirectoryFiles_RespectsDepthAndSkipDirectories(t *testing.T) {
projectPath := t.TempDir()
diff --git a/backend/pkg/projects/fs_writer.go b/backend/pkg/projects/fs_writer.go
index c8e66aa43..1cb0dd87a 100644
--- a/backend/pkg/projects/fs_writer.go
+++ b/backend/pkg/projects/fs_writer.go
@@ -26,13 +26,11 @@ func ComposeFileCandidates() []string {
return append([]string(nil), composeFileCandidates...)
}
-// detectExistingComposeFile finds an existing compose file in the directory
-func detectExistingComposeFile(dir string) string {
- for _, filename := range composeFileCandidates {
- fullPath := filepath.Join(dir, filename)
- if info, err := os.Stat(fullPath); err == nil && !info.IsDir() {
- return fullPath
- }
+// detectExistingComposeFileInternal finds an existing compose file in the directory
+func detectExistingComposeFileInternal(dir string) string {
+ composePath, err := DetectComposeFile(dir)
+ if err == nil {
+ return composePath
}
return ""
}
@@ -65,7 +63,7 @@ func WriteComposeFile(projectsRoot, dirPath, content string) error {
}
var composePath string
- if existingFile := detectExistingComposeFile(dirPath); existingFile != "" {
+ if existingFile := detectExistingComposeFileInternal(dirPath); existingFile != "" {
composePath = existingFile
} else {
composePath = filepath.Join(dirPath, "compose.yaml")
diff --git a/backend/pkg/projects/fs_writer_test.go b/backend/pkg/projects/fs_writer_test.go
index f7017c116..ac3763d61 100644
--- a/backend/pkg/projects/fs_writer_test.go
+++ b/backend/pkg/projects/fs_writer_test.go
@@ -136,3 +136,27 @@ func TestWriteComposeFile_PreservesExistingPodmanComposeNames(t *testing.T) {
})
}
}
+
+func TestWriteComposeFile_PreservesExistingCustomComposeNames(t *testing.T) {
+ t.Parallel()
+
+ tmpDir := t.TempDir()
+ projectsRoot := tmpDir
+ projectDir := filepath.Join(tmpDir, "Radarr-3")
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+
+ existingComposePath := filepath.Join(projectDir, "radarr.yaml")
+ require.NoError(t, os.WriteFile(existingComposePath, []byte("services: {}"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "config.yaml"), []byte("x-config: true\n"), 0o600))
+
+ expectedContent := "services:\n app:\n image: nginx:alpine\n"
+ err := WriteComposeFile(projectsRoot, projectDir, expectedContent)
+ require.NoError(t, err)
+
+ actualContent, err := os.ReadFile(existingComposePath)
+ require.NoError(t, err)
+ assert.Equal(t, expectedContent, string(actualContent))
+
+ _, err = os.Stat(filepath.Join(projectDir, "compose.yaml"))
+ assert.True(t, os.IsNotExist(err), "compose.yaml should not be created when an existing custom compose file is present")
+}
diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.go
index 9d9826d4d..6aefce73b 100644
--- a/backend/pkg/projects/load.go
+++ b/backend/pkg/projects/load.go
@@ -25,30 +25,114 @@ var ProjectFileCandidates = []string{
".env",
}
-// IsProjectFile reports whether filename is a Compose file or an environment file.
+// IsProjectFile reports whether filename is a known project file or a plausible
+// custom YAML filename worth watching for compose discovery.
func IsProjectFile(filename string) bool {
- return slices.Contains(ProjectFileCandidates, filename)
+ if slices.Contains(ProjectFileCandidates, filename) {
+ return true
+ }
+
+ ext := strings.ToLower(filepath.Ext(filename))
+ if ext != ".yaml" && ext != ".yml" {
+ return false
+ }
+
+ base := filepath.Base(filename)
+ return base != "" && !strings.HasPrefix(base, ".")
+}
+
+func stripTrailingProjectCounterInternal(name string) string {
+ trimmed := strings.TrimSpace(name)
+ withoutDigits := strings.TrimRight(trimmed, "0123456789")
+ if len(withoutDigits) == len(trimmed) || withoutDigits == "" {
+ return trimmed
+ }
+
+ if last := withoutDigits[len(withoutDigits)-1]; last != '-' && last != '_' {
+ return trimmed
+ }
+
+ return withoutDigits[:len(withoutDigits)-1]
}
-func locateComposeFile(dir string) string {
+func DetectComposeFile(dir string) (string, error) {
for _, filename := range ProjectFileCandidates {
if filename == ".env" {
continue
}
- fullPath := filepath.Join(dir, filename)
- if info, err := os.Stat(fullPath); err == nil && !info.IsDir() {
- return fullPath
+
+ composePath := filepath.Join(dir, filename)
+ if info, err := os.Stat(composePath); err == nil && !info.IsDir() {
+ return composePath, nil
}
}
- return ""
-}
-func DetectComposeFile(dir string) (string, error) {
- compose := locateComposeFile(dir)
- if compose == "" {
+ entries, err := os.ReadDir(dir)
+ if err != nil {
+ return "", err
+ }
+
+ dirBase := filepath.Base(filepath.Clean(dir))
+ normalizedDirBase := loader.NormalizeProjectName(dirBase)
+ normalizedTrimmedDirBase := loader.NormalizeProjectName(stripTrailingProjectCounterInternal(dirBase))
+
+ customCandidates := make([]string, 0)
+ dirMatchedCandidates := make([]string, 0)
+ composeNamedCandidates := make([]string, 0)
+
+ for _, entry := range entries {
+ if entry.IsDir() {
+ continue
+ }
+
+ name := entry.Name()
+ if slices.Contains(ProjectFileCandidates, name) || !IsProjectFile(name) {
+ continue
+ }
+
+ candidatePath := filepath.Join(dir, name)
+
+ stem := strings.TrimSuffix(name, filepath.Ext(name))
+ normalizedStem := loader.NormalizeProjectName(strings.TrimSpace(stem))
+ dirMatched := normalizedStem != "" && (normalizedStem == normalizedDirBase || normalizedStem == normalizedTrimmedDirBase)
+ composeNamed := strings.Contains(strings.ToLower(stem), "compose")
+
+ hasComposeRootKeys, rootKeysErr := HasComposeRootKeysInFile(candidatePath)
+ if rootKeysErr == nil {
+ if !hasComposeRootKeys {
+ continue
+ }
+ } else if !dirMatched && !composeNamed {
+ continue
+ }
+
+ if dirMatched {
+ dirMatchedCandidates = append(dirMatchedCandidates, candidatePath)
+ }
+
+ if composeNamed {
+ composeNamedCandidates = append(composeNamedCandidates, candidatePath)
+ }
+
+ customCandidates = append(customCandidates, candidatePath)
+ }
+
+ switch {
+ case len(dirMatchedCandidates) == 1:
+ return dirMatchedCandidates[0], nil
+ case len(dirMatchedCandidates) > 1:
+ return "", fmt.Errorf("multiple custom compose files found in %q", dir)
+ case len(composeNamedCandidates) == 1:
+ return composeNamedCandidates[0], nil
+ case len(composeNamedCandidates) > 1:
+ return "", fmt.Errorf("multiple custom compose files found in %q", dir)
+ case len(customCandidates) == 1:
+ return customCandidates[0], nil
+ case len(customCandidates) > 1:
+ return "", fmt.Errorf("multiple custom compose files found in %q", dir)
+ default:
return "", fmt.Errorf("no compose file found in %q", dir)
}
- return compose, nil
}
func LoadComposeProject(ctx context.Context, composeFile, projectName, projectsDirectory string, autoInjectEnv bool, pathMapper *PathMapper) (*composetypes.Project, error) {
diff --git a/backend/pkg/projects/load_test.go b/backend/pkg/projects/load_test.go
index 336e96f52..1cf09c098 100644
--- a/backend/pkg/projects/load_test.go
+++ b/backend/pkg/projects/load_test.go
@@ -40,6 +40,56 @@ func TestDetectComposeFile_SupportsPodmanComposeNames(t *testing.T) {
}
}
+func TestDetectComposeFile_SupportsSingleCustomComposeName(t *testing.T) {
+ t.Parallel()
+
+ dir := t.TempDir()
+ expectedPath := filepath.Join(dir, "radarr.yaml")
+ require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+
+ composePath, err := DetectComposeFile(dir)
+ require.NoError(t, err)
+ assert.Equal(t, expectedPath, composePath)
+}
+
+func TestDetectComposeFile_PrefersDirectoryMatchedCustomComposeName(t *testing.T) {
+ t.Parallel()
+
+ root := t.TempDir()
+ dir := filepath.Join(root, "Radarr-3")
+ require.NoError(t, os.MkdirAll(dir, 0o755))
+ expectedPath := filepath.Join(dir, "radarr.yaml")
+ require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("x-extra: true\n"), 0o600))
+
+ composePath, err := DetectComposeFile(dir)
+ require.NoError(t, err)
+ assert.Equal(t, expectedPath, composePath)
+}
+
+func TestDetectComposeFile_ReturnsErrorForAmbiguousCustomComposeNames(t *testing.T) {
+ t.Parallel()
+
+ dir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(dir, "alpha.yaml"), []byte("services:\n a:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(dir, "beta.yml"), []byte("services:\n b:\n image: busybox:latest\n"), 0o600))
+
+ _, err := DetectComposeFile(dir)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "multiple custom compose files")
+}
+
+func TestDetectComposeFile_IgnoresSingleNonComposeYaml(t *testing.T) {
+ t.Parallel()
+
+ dir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(dir, "values.yaml"), []byte("replicaCount: 2\nimage:\n tag: latest\n"), 0o600))
+
+ _, err := DetectComposeFile(dir)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "no compose file found")
+}
+
func TestLoadComposeProjectFromDir_SupportsPodmanComposeNames(t *testing.T) {
composeContent := "services:\n app:\n image: nginx:alpine\n"
@@ -77,6 +127,27 @@ func TestLoadComposeProjectFromDir_SupportsPodmanComposeNames(t *testing.T) {
}
}
+func TestLoadComposeProjectFromDir_SupportsCustomComposeNames(t *testing.T) {
+ t.Parallel()
+
+ dir := t.TempDir()
+ expectedPath := filepath.Join(dir, "radarr.yaml")
+ require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+
+ project, composePath, err := LoadComposeProjectFromDir(
+ context.Background(),
+ dir,
+ "radarr",
+ filepath.Dir(dir),
+ false,
+ nil,
+ )
+ require.NoError(t, err)
+ require.NotNil(t, project)
+ assert.Equal(t, expectedPath, composePath)
+ assert.Equal(t, []string{expectedPath}, project.ComposeFiles)
+}
+
func TestLoadComposeProjectFromDir_EmptyProjectsDirectoryDoesNotCreateParentGlobalEnv(t *testing.T) {
t.Parallel()
diff --git a/go.work.sum b/go.work.sum
index b0b5fab88..70e39a8be 100644
--- a/go.work.sum
+++ b/go.work.sum
@@ -70,6 +70,7 @@ github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp v1.5.3 h1:2afWGsMzkIcN8Qm4mgP
github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp v1.5.3/go.mod h1:dppbR7CwXD4pgtV9t3wD1812RaLDcBjtblcDF5f1vI0=
github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 h1:sBEjpZlNHzK1voKq9695PJSX2o5NEXl7/OL3coiIY0c=
github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0/go.mod h1:P4WPRUkOhJC13W//jWpyfJNDAIpvRbAUIYLX/4jtlE0=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.31.0/go.mod h1:P4WPRUkOhJC13W//jWpyfJNDAIpvRbAUIYLX/4jtlE0=
github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 h1:owcC2UnmsZycprQ5RfRgjydWhuoxg71LUfyiQdijZuM=
github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0/go.mod h1:ZPpqegjbE99EPKsu3iUWV22A04wzGPcAY/ziSIQEEgs=
github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0 h1:Ron4zCA/yk6U7WOBXhTJcDpsUBG9npumK6xw2auFltQ=