Skip to content

Modern Docker Management, Designed for Everyone

fix: create missing project bind directories as the runtime user (#4138)

Kyle Mendell8bcb59d538a2
diff --git a/backend/internal/project/project.go b/backend/internal/project/project.go
index b3a8b5358..02d425b7e 100644
--- a/backend/internal/project/project.go
+++ b/backend/internal/project/project.go
@@ -147,7 +147,7 @@ func (s *ProjectService) ValidateComposeDirectory(ctx context.Context, projectNa
pathMapper,
nil,
nil,
- true, nil, nil,
+ true, nil, nil, nil,
)
if err != nil {
return 0, err
@@ -743,7 +743,10 @@ func (s *ProjectService) gitOpsComposePathInternal(ctx context.Context, syncID s
}
}
-func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Context, proj *Project, services ...string) (*composetypes.Project, string, error) {
+// loadComposeProjectForProjectInternal loads the executable compose model for
+// proj. prepare is optional and runs before host path translation; deployment
+// paths use it to create missing bind directories, read paths pass nil.
+func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Context, proj *Project, prepare projects.PrepareProjectFunc, services ...string) (*composetypes.Project, string, error) {
composeFileFullPath, err := s.ResolveProjectComposeFile(ctx, proj)
if err != nil {
return nil, "", err
@@ -754,7 +757,7 @@ func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Contex
pathMapper := s.projectPathMapperInternal(ctx)
- composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, projects.NormalizeProjectName(proj.Name), projectsDirectory, utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false), pathMapper, nil, nil, false, nil, services)
+ composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, projects.NormalizeProjectName(proj.Name), projectsDirectory, utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false), pathMapper, nil, nil, false, nil, services, prepare)
if loadErr != nil {
return nil, "", loadErr
}
diff --git a/backend/internal/project/project_details.go b/backend/internal/project/project_details.go
index b38da9a1e..628424371 100644
--- a/backend/internal/project/project_details.go
+++ b/backend/internal/project/project_details.go
@@ -102,7 +102,7 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strin
return nil, err
}
- composeProject, composeFileFullPath, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
+ composeProject, composeFileFullPath, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, nil)
if errors.Is(derr, common.ErrProjectEnvUnreadable) {
return s.projectServicesFromContainersInternal(ctx, projectFromDb, s.ProjectMetadata(ctx, *projectFromDb, nil))
}
@@ -948,7 +948,7 @@ func (s *ProjectService) StreamProjectLogs(ctx context.Context, projectID string
}
func (s *ProjectService) CountServicesFromCompose(ctx context.Context, p Project) (int, error) {
- proj, _, err := s.loadComposeProjectForProjectInternal(ctx, &p)
+ proj, _, err := s.loadComposeProjectForProjectInternal(ctx, &p, nil)
if err != nil {
return 0, err
}
diff --git a/backend/internal/project/project_lifecycle.go b/backend/internal/project/project_lifecycle.go
index 65c94fe19..8cda5ba01 100644
--- a/backend/internal/project/project_lifecycle.go
+++ b/backend/internal/project/project_lifecycle.go
@@ -6,7 +6,9 @@ import (
"fmt"
"io"
"log/slog"
+ "maps"
"path/filepath"
+ "slices"
"time"
"emperror.dev/errors"
@@ -80,7 +82,7 @@ func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID st
return err
}
if discoverTags {
- effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, servicesToUpdate...)
+ effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, nil, servicesToUpdate...)
if err != nil {
return errors.WrapIf(err, "load project for service image checks")
}
@@ -105,7 +107,7 @@ func (s *ProjectService) updateProjectServicesInternal(ctx context.Context, proj
previousStatus := projectFromDb.Status
// 1. Load project
- compProj, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, servicesToUpdate...)
+ compProj, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, prepareProjectBindDirectoriesInternal(projectFromDb.Path), servicesToUpdate...)
if err != nil {
return errors.WrapIf(err, "failed to load compose project")
}
@@ -156,6 +158,61 @@ func (s *ProjectService) updateProjectServicesInternal(ctx context.Context, proj
return nil
}
+// prepareProjectBindDirectoriesInternal returns the load-time preparation for
+// deployments: missing bind-mount sources inside projectPath are created as
+// Arcane's runtime user before any container is stopped or created. Left to
+// the Docker daemon, those directories would be created as root (#4132).
+//
+// Only bind sources with Compose's automatic host path creation enabled are
+// considered (short syntax, or long syntax without create_host_path: false),
+// mirroring what the daemon would otherwise do. Existing files, directories,
+// and symlinks are left untouched, as are sources outside the project
+// directory, and the root-confined acfs calls reject symlinks escaping it.
+func prepareProjectBindDirectoriesInternal(projectPath string) projects.PrepareProjectFunc {
+ return func(ctx context.Context, project *composetypes.Project) error {
+ for _, serviceName := range slices.Sorted(maps.Keys(project.Services)) {
+ for _, volume := range project.Services[serviceName].Volumes {
+ if volume.Type != composetypes.VolumeTypeBind || volume.Source == "" {
+ continue
+ }
+ if volume.Bind != nil && !bool(volume.Bind.CreateHostPath) {
+ continue
+ }
+ if err := ensureProjectBindDirectoryInternal(ctx, projectPath, volume.Source); err != nil {
+ return errors.WrapIff(err, "bind source %s for service %s", volume.Source, serviceName)
+ }
+ }
+ }
+ return nil
+ }
+}
+
+// ensureProjectBindDirectoryInternal creates source (and missing parents)
+// when it lies inside projectPath and nothing exists there yet.
+func ensureProjectBindDirectoryInternal(ctx context.Context, projectPath, source string) error {
+ logicalPath, err := acfs.LogicalPath(projectPath, source)
+ if err != nil {
+ if errors.Is(err, acfs.ErrOutsideRoot) {
+ return nil
+ }
+ return err
+ }
+ if logicalPath == "/" {
+ return nil
+ }
+
+ exists, err := acfs.Exists(ctx, projectPath, logicalPath)
+ if err != nil || exists {
+ return err
+ }
+
+ if err := acfs.MkdirAll(ctx, projectPath, logicalPath, utils.DirPerm); err != nil {
+ return err
+ }
+ slog.InfoContext(ctx, "created missing bind directory for project deployment", "projectPath", projectPath, "source", source)
+ return nil
+}
+
func ensureProjectMutableInternal(proj *Project) error {
if proj != nil && proj.IsArchived {
return common.Classify(common.ErrProjectArchived, errors.New("project is archived and must be unarchived before this action"))
@@ -263,7 +320,7 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, us
return s.lifecycleService.RunPreDeploy(ctx, projectFromDb, user)
},
Load: func(ctx context.Context) (*composetypes.Project, error) {
- model, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
+ model, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, prepareProjectBindDirectoriesInternal(projectFromDb.Path))
if err == nil {
closeSuppression = s.eventService.BeginComposeSuppressionWindow(model.Name)
}
@@ -298,7 +355,7 @@ func (s *ProjectService) DownProject(ctx context.Context, projectID string, user
return err
}
- proj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
+ proj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, nil)
if lerr != nil {
_ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)
return errors.WrapIf(lerr, "failed to load compose project")
@@ -467,7 +524,7 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, r
}
if removeVolumes {
- if compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj); lerr == nil {
+ if compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil); lerr == nil {
defer s.eventService.BeginComposeSuppressionWindow(compProj.Name)()
if derr := projects.ComposeDown(ctx, compProj, true); derr != nil {
slog.WarnContext(ctx, "failed to remove volumes", "error", derr)
@@ -574,7 +631,7 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID string
return err
}
- compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)
+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
if lerr != nil {
return errors.WrapIf(lerr, "failed to load compose project")
}
@@ -596,7 +653,7 @@ func (s *ProjectService) BuildProjectServices(ctx context.Context, projectID str
return err
}
- projectModel, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)
+ projectModel, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb, nil)
if derr != nil {
return errors.WrapIff(derr, "failed to load compose project in %s", projectFromDb.Path)
}
@@ -617,7 +674,7 @@ func (s *ProjectService) EnsureProjectImagesPresent(ctx context.Context, project
return err
}
- compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)
+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
if lerr != nil {
return errors.WrapIf(lerr, "failed to load compose project")
}
@@ -664,7 +721,7 @@ func (s *ProjectService) RestartProject(ctx context.Context, projectID string, s
return errors.WrapIf(err, "failed to update project status to restarting")
}
- compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)
+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
if lerr != nil {
_ = s.updateProjectStatusInternal(ctx, projectID, ProjectStatusRunning)
return errors.WrapIf(lerr, "failed to load compose project")
diff --git a/backend/internal/project/project_update.go b/backend/internal/project/project_update.go
index 0d885b6cb..98e785e60 100644
--- a/backend/internal/project/project_update.go
+++ b/backend/internal/project/project_update.go
@@ -413,7 +413,7 @@ func (s *ProjectService) prepareProjectRenameVolumeMigrationInternal(ctx context
return nil, nil
}
- composeProject, _, err := s.loadComposeProjectForProjectInternal(ctx, proj)
+ composeProject, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
if err != nil {
if errors.Is(err, common.ErrProjectComposeFileNotFound) {
return nil, nil
@@ -1041,7 +1041,7 @@ func (s *ProjectService) persistProjectImageChangesInternal(ctx context.Context,
if proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != "" {
return nil, errors.New("tag updates cannot edit a GitOps-managed project; update image tags in the source repository")
}
- effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj)
+ effective, _, err := s.loadComposeProjectForProjectInternal(ctx, proj, nil)
if err != nil {
return nil, fmt.Errorf("load project for tag update: %w", err)
}
diff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.go
index bcfac013c..77e609257 100644
--- a/backend/internal/project/service_test.go
+++ b/backend/internal/project/service_test.go
@@ -7764,3 +7764,63 @@ func TestConfiguredProjectAggregatesReplicaAndPreviewChecks(t *testing.T) {
require.Empty(t, summary.UpdateInfoByRef["example:3.1.0"].LatestVersion)
require.Equal(t, "3.2.0", scoped["two"].LatestVersion, "aggregation must not modify shared checks")
}
+
+func TestPrepareProjectBindDirectoriesInternal(t *testing.T) {
+ t.Parallel()
+
+ newProject := func(volumes ...composetypes.ServiceVolumeConfig) *composetypes.Project {
+ return &composetypes.Project{Services: composetypes.Services{
+ "app": {Name: "app", Volumes: volumes},
+ }}
+ }
+ bind := func(source string) composetypes.ServiceVolumeConfig {
+ return composetypes.ServiceVolumeConfig{Type: composetypes.VolumeTypeBind, Source: source, Target: "/t", Bind: &composetypes.ServiceVolumeBind{CreateHostPath: true}}
+ }
+
+ t.Run("creates missing nested directories only", func(t *testing.T) {
+ t.Parallel()
+ projectPath := t.TempDir()
+ outside := t.TempDir()
+ existingFile := filepath.Join(projectPath, "Caddyfile")
+ require.NoError(t, os.WriteFile(existingFile, []byte("x"), 0o600))
+ existingDir := filepath.Join(projectPath, "data")
+ require.NoError(t, os.Mkdir(existingDir, 0o700))
+
+ noCreate := bind(filepath.Join(projectPath, "manual"))
+ noCreate.Bind.CreateHostPath = false
+ project := newProject(
+ bind(filepath.Join(projectPath, "caddy", "conf")),
+ composetypes.ServiceVolumeConfig{Type: composetypes.VolumeTypeBind, Source: filepath.Join(projectPath, "plain"), Target: "/p"},
+ bind(existingFile),
+ bind(existingDir),
+ bind(projectPath),
+ bind(filepath.Join(outside, "elsewhere")),
+ noCreate,
+ composetypes.ServiceVolumeConfig{Type: composetypes.VolumeTypeVolume, Source: "named", Target: "/v"},
+ )
+
+ require.NoError(t, prepareProjectBindDirectoriesInternal(projectPath)(context.Background(), project))
+
+ assert.DirExists(t, filepath.Join(projectPath, "caddy", "conf"))
+ assert.DirExists(t, filepath.Join(projectPath, "plain"), "long syntax without bind block is auto-created like the daemon would")
+ assert.FileExists(t, existingFile)
+ info, err := os.Stat(existingDir)
+ require.NoError(t, err)
+ assert.Equal(t, os.FileMode(0o700), info.Mode().Perm(), "existing directory permissions preserved")
+ assert.NoDirExists(t, filepath.Join(outside, "elsewhere"))
+ assert.NoDirExists(t, filepath.Join(projectPath, "manual"), "create_host_path: false is respected")
+ assert.NoDirExists(t, filepath.Join(projectPath, "named"))
+ })
+
+ t.Run("rejects symlink escaping the project", func(t *testing.T) {
+ t.Parallel()
+ projectPath := t.TempDir()
+ outside := t.TempDir()
+ require.NoError(t, os.Symlink(outside, filepath.Join(projectPath, "link")))
+
+ err := prepareProjectBindDirectoriesInternal(projectPath)(context.Background(), newProject(bind(filepath.Join(projectPath, "link", "conf"))))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "service app")
+ assert.NoDirExists(t, filepath.Join(outside, "conf"))
+ })
+}
diff --git a/backend/internal/project/service_unix_test.go b/backend/internal/project/service_unix_test.go
index d237e82d8..2d044fa08 100644
--- a/backend/internal/project/service_unix_test.go
+++ b/backend/internal/project/service_unix_test.go
@@ -10,6 +10,7 @@ import (
"path/filepath"
"testing"
+ composetypes "github.com/compose-spec/compose-go/v2/types"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/event"
"github.com/stretchr/testify/assert"
@@ -73,3 +74,26 @@ func TestProjectService_ApplyGitSyncProjectFiles_TolerantOfPermissionLockedEnv(t
require.NoError(t, err)
assert.Equal(t, "FOO=locked\n", string(envBytes))
}
+
+func TestPrepareProjectBindDirectoriesInternal_PermissionFailure(t *testing.T) {
+ if os.Geteuid() == 0 {
+ t.Skip("permission bits are ignored when running as root")
+ }
+
+ projectPath := t.TempDir()
+ locked := filepath.Join(projectPath, "locked")
+ require.NoError(t, os.Mkdir(locked, 0o500))
+ t.Cleanup(func() { assert.NoError(t, os.Chmod(locked, 0o755)) })
+
+ project := &composetypes.Project{Services: composetypes.Services{
+ "app": {Name: "app", Volumes: []composetypes.ServiceVolumeConfig{{
+ Type: composetypes.VolumeTypeBind, Source: filepath.Join(locked, "conf"), Target: "/etc/caddy",
+ }}},
+ }}
+
+ err := prepareProjectBindDirectoriesInternal(projectPath)(context.Background(), project)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), filepath.Join(locked, "conf"))
+ assert.Contains(t, err.Error(), "service app")
+ assert.NoDirExists(t, filepath.Join(locked, "conf"))
+}
diff --git a/backend/pkg/projects/cache.go b/backend/pkg/projects/cache.go
index c22a5600e..aab78ace1 100644
--- a/backend/pkg/projects/cache.go
+++ b/backend/pkg/projects/cache.go
@@ -134,7 +134,7 @@ func LoadCachedComposeProject(ctx context.Context, cache projecttypes.ComposeCac
}
}
dependencies := projecttypes.ComposeDependencies{}
- model, err := LoadComposeProject(ctx, composePath, projectName, projectsDirectory, autoInject, pathMapper, nil, nil, false, &dependencies, nil)
+ model, err := LoadComposeProject(ctx, composePath, projectName, projectsDirectory, autoInject, pathMapper, nil, nil, false, &dependencies, nil, nil)
if err != nil {
return nil, err
}
diff --git a/backend/pkg/projects/custom_labels.go b/backend/pkg/projects/custom_labels.go
index 5263b5758..1e21c4e8d 100644
--- a/backend/pkg/projects/custom_labels.go
+++ b/backend/pkg/projects/custom_labels.go
@@ -324,7 +324,7 @@ func loadComposeProjectForMetadataFromFileInternal(ctx context.Context, composeF
opts.SkipValidation = true
opts.SkipConsistencyCheck = true
opts.SkipResolveEnvironment = false
- }, false, nil, nil)
+ }, false, nil, nil, nil)
}
func loadComposeEnvironment(workdir string) map[string]string {
diff --git a/backend/pkg/projects/custom_labels_test.go b/backend/pkg/projects/custom_labels_test.go
index cb5a8fa49..6fefbdb0d 100644
--- a/backend/pkg/projects/custom_labels_test.go
+++ b/backend/pkg/projects/custom_labels_test.go
@@ -233,7 +233,7 @@ services:
dir := t.TempDir()
path := filepath.Join(dir, "compose.yaml")
require.NoError(t, os.WriteFile(path, []byte(content), 0o600))
- disk, err := LoadComposeProject(t.Context(), path, "metadata", dir, false, nil, nil, nil, false, nil, nil)
+ disk, err := LoadComposeProject(t.Context(), path, "metadata", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
memory, err := LoadComposeProjectFromContent(t.Context(), projecttypes.ComposeContentOptions{ComposeContent: content, WorkingDir: dir, ProjectName: "metadata"})
require.NoError(t, err)
@@ -288,7 +288,7 @@ services:
enabled: true
constraint: "=3.20.1"
`), 0o600))
- project, err := LoadComposeProject(t.Context(), filepath.Join(dir, "compose.yaml"), "metadata", dir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(t.Context(), filepath.Join(dir, "compose.yaml"), "metadata", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
require.Equal(t, "3.20.x", project.Services["main"].Labels[updaterlabels.LabelUpdateConstraint])
require.Equal(t, "false", project.Services["main"].Labels[updaterlabels.LabelUpdater])
diff --git a/backend/pkg/projects/image_refs_test.go b/backend/pkg/projects/image_refs_test.go
index b4baed844..822aa4611 100644
--- a/backend/pkg/projects/image_refs_test.go
+++ b/backend/pkg/projects/image_refs_test.go
@@ -54,7 +54,7 @@ func TestBuildImageRefsFromComposeProject_UsesMergedComposeOverrides(t *testing.
build: ./app
`), 0o644))
- project, err := LoadComposeProject(context.Background(), composePath, "override-demo", dir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "override-demo", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
assert.Equal(t, []string{"overridden-app:latest"}, BuildImageRefsFromComposeProject(project))
diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.go
index e48f61c42..8ae7b6fbd 100644
--- a/backend/pkg/projects/load.go
+++ b/backend/pkg/projects/load.go
@@ -221,7 +221,7 @@ func LoadComposeProjectFromContent(ctx context.Context, opts projecttypes.Compos
rawSources = harvestRawSourcesInternal(ctx, configDetails, loaderOptions...)
}
- return finishLoadedProjectInternal(ctx, project, workingDir, opts.PathMapper, false, rawSources)
+ return finishLoadedProjectInternal(ctx, project, workingDir, opts.PathMapper, false, rawSources, nil)
}
// wrapTypeCastMappingLenientInternal prepares the interp type-cast mapping for lenient
@@ -328,8 +328,15 @@ func ApplyLenientLoaderOptions(ctx context.Context, opts *loader.Options, compos
}
}
-// LoadComposeProject loads a compose project from composeFile. envOverride and
-// configureLoader are optional and may be nil. When lenient is true, undefined
+// PrepareProjectFunc runs against a loaded project after service selection,
+// include/override merging, and local path resolution, but before Docker host
+// path translation, so bind sources are still local filesystem paths. It may
+// mutate the filesystem (e.g. create missing bind directories) and a returned
+// error aborts the load.
+type PrepareProjectFunc func(ctx context.Context, project *composetypes.Project) error
+
+// LoadComposeProject loads a compose project from composeFile. envOverride,
+// configureLoader, and prepare are optional and may be nil. When lenient is true, undefined
// ${VAR} references are tolerated: instead of substituting them with an empty
// string (which produces invalid volume/bind specs like ":/path"), they are
// replaced with a placeholder value so structural validation can succeed. This
@@ -346,6 +353,7 @@ func LoadComposeProject(
lenient bool,
dependencies *projecttypes.ComposeDependencies,
services []string,
+ prepare PrepareProjectFunc,
) (project *composetypes.Project, err error) {
defer recoverComposeLoadPanicInternal(ctx, composeFile, &project, &err)
@@ -459,7 +467,7 @@ func LoadComposeProject(
rawSources = harvestRawSourcesInternal(ctx, cfg, loaderOptions...)
}
- project, err = finishLoadedProjectInternal(ctx, project, workdir, pathMapper, true, rawSources)
+ project, err = finishLoadedProjectInternal(ctx, project, workdir, pathMapper, true, rawSources, prepare)
if err != nil {
return nil, err
}
@@ -468,13 +476,21 @@ func LoadComposeProject(
return project, nil
}
-func finishLoadedProjectInternal(ctx context.Context, project *composetypes.Project, workingDir string, pathMapper projecttypes.VolumeSourcePathMapper, translateFileResources bool, rawSources map[string]string) (*composetypes.Project, error) {
+func finishLoadedProjectInternal(ctx context.Context, project *composetypes.Project, workingDir string, pathMapper projecttypes.VolumeSourcePathMapper, translateFileResources bool, rawSources map[string]string, prepare PrepareProjectFunc) (*composetypes.Project, error) {
if err := applyServiceLabelMetadataInternal(project); err != nil {
return nil, err
}
project = project.WithoutUnnecessaryResources()
ResolveRelativeProjectPaths(project, workingDir)
+ // Sources are local absolute paths here; host translation below rewrites
+ // them for the Docker daemon and they would no longer be usable locally.
+ if prepare != nil {
+ if err := prepare(ctx, project); err != nil {
+ return nil, errors.WrapIf(err, "prepare compose project")
+ }
+ }
+
if !isNilVolumeSourcePathMapperInternal(pathMapper) {
if err := pathMapper.TranslateVolumeSources(project, translateFileResources); err != nil {
return nil, errors.WrapIf(err, "failed to translate paths for docker host")
@@ -604,7 +620,7 @@ func LoadComposeProjectFromDir(ctx context.Context, dir, projectName, projectsDi
return nil, "", err
}
- proj, err := LoadComposeProject(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, false, nil, nil)
+ proj, err := LoadComposeProject(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, false, nil, nil, nil)
if err != nil {
return nil, "", err
}
diff --git a/backend/pkg/projects/load_test.go b/backend/pkg/projects/load_test.go
index b918533c3..034448110 100644
--- a/backend/pkg/projects/load_test.go
+++ b/backend/pkg/projects/load_test.go
@@ -2,6 +2,7 @@ package projects
import (
"context"
+ "errors"
"os"
"path/filepath"
"strings"
@@ -181,7 +182,7 @@ func TestLoadComposeProject_ComposeFileEnvSelectsFilesAndSkipsOverride(t *testin
require.NoError(t, os.WriteFile(filepath.Join(dir, "compose.override.yaml"), []byte("services:\n app:\n image: alpine:3\n"), 0o600))
require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_FILE=base.yml:sub/extra.yml\n"), 0o600))
- project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
@@ -229,7 +230,7 @@ func TestLoadComposeProject_ArcaneProcessEnvInterpolation(t *testing.T) {
basePath := filepath.Join(dir, "compose.yaml")
require.NoError(t, os.WriteFile(basePath, []byte(tc.compose), 0o600))
- project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
@@ -250,7 +251,7 @@ func TestLoadComposeProject_DoesNotMergeOverrideForCustomBaseName(t *testing.T)
require.NoError(t, os.WriteFile(basePath, []byte("services:\n app:\n image: nginx:alpine\n environment:\n FROM_BASE: \"1\"\n"), 0o600))
require.NoError(t, os.WriteFile(overridePath, []byte("services:\n app:\n image: busybox:latest\n environment:\n FROM_OVERRIDE: \"1\"\n"), 0o600))
- project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
@@ -353,7 +354,7 @@ func TestLoadComposeProjectLenient_ToleratesUndefinedVariables(t *testing.T) {
- ${CONFIG_FILE}:/etc/app/app.conf
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
assert.Len(t, project.Services, 1)
@@ -379,7 +380,7 @@ func TestLoadComposeProjectLenient_ToleratesUndefinedTypedFieldVariables(t *test
memory: ${MEMORY}
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
assert.Len(t, project.Services, 1)
@@ -404,7 +405,7 @@ func TestLoadComposeProjectLenient_AppliesVariableDefaults(t *testing.T) {
- MAX_FILE_SIZE=${ARCANE_TEST_UNSET_SIZE:-104857600}
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
require.Len(t, project.Services, 1)
@@ -438,7 +439,7 @@ services:
image: busybox:latest
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", projectDir, false, nil, nil, nil, false, nil, []string{"root", "included"})
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", projectDir, false, nil, nil, nil, false, nil, []string{"root", "included"}, nil)
require.NoError(t, err)
require.NotNil(t, project)
@@ -491,7 +492,7 @@ services:
composePath := filepath.Join(projectDir, "compose.yaml")
require.NoError(t, os.WriteFile(composePath, []byte(tt.composeBody), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "aitools", projectDir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "aitools", projectDir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
require.NotNil(t, project)
require.Equal(t, tt.wantName, project.Name)
@@ -514,7 +515,7 @@ func TestResolveRelativeProjectPaths(t *testing.T) {
- ./config.conf:/etc/app/config.conf
`), 0o600))
- project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
ResolveRelativeProjectPaths(project, dir)
@@ -548,7 +549,7 @@ func TestLoadComposeProject_RemapsRelativeBindEscapingProjectsMount(t *testing.T
pathMapper := NewPathMapper(projectsRoot, "/docker/112/arcane/arcane-data/projects")
require.True(t, pathMapper.IsNonMatchingMount())
- project, err := LoadComposeProject(context.Background(), composePath, "goclaw", projectsRoot, false, pathMapper, nil, nil, false, nil, nil)
+ project, err := LoadComposeProject(context.Background(), composePath, "goclaw", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, nil)
require.NoError(t, err)
sources := make(map[string]string)
@@ -564,3 +565,59 @@ func TestLoadComposeProject_RemapsRelativeBindEscapingProjectsMount(t *testing.T
// Absolute host path: must be passed through untouched.
assert.Equal(t, "/mnt/nas/media", sources["/media"])
}
+
+// The prepare callback must observe local, resolved bind sources: after
+// relative paths are anchored to the project directory, but before host path
+// translation rewrites them for the Docker daemon. Read-only loads pass nil
+// and must not touch the filesystem.
+func TestLoadComposeProject_PrepareRunsBeforeHostPathTranslation(t *testing.T) {
+ t.Parallel()
+
+ projectsRoot := t.TempDir()
+ projectDir := filepath.Join(projectsRoot, "caddy")
+ require.NoError(t, os.MkdirAll(projectDir, 0o755))
+
+ composePath := filepath.Join(projectDir, "compose.yaml")
+ require.NoError(t, os.WriteFile(composePath, []byte(`services:
+ caddy:
+ image: caddy:2
+ volumes:
+ - ./conf:/etc/caddy
+ disabled:
+ image: busybox
+ profiles: [extra]
+ volumes:
+ - ./never:/never
+`), 0o600))
+
+ pathMapper := NewPathMapper(projectsRoot, "/host/projects")
+ require.True(t, pathMapper.IsNonMatchingMount())
+
+ var seen []string
+ prepare := func(_ context.Context, project *composetypes.Project) error {
+ for _, service := range project.Services {
+ for _, volume := range service.Volumes {
+ seen = append(seen, volume.Source)
+ }
+ }
+ return os.MkdirAll(filepath.Join(projectDir, "conf"), 0o755)
+ }
+
+ project, err := LoadComposeProject(context.Background(), composePath, "caddy", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, prepare)
+ require.NoError(t, err)
+
+ assert.Equal(t, []string{filepath.Join(projectDir, "conf")}, seen, "prepare sees only active services with local resolved sources")
+ assert.Equal(t, "/host/projects/caddy/conf", project.Services["caddy"].Volumes[0].Source, "host translation still applies after prepare")
+ assert.DirExists(t, filepath.Join(projectDir, "conf"))
+
+ prepareErr := errors.New("boom")
+ _, err = LoadComposeProject(context.Background(), composePath, "caddy", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, func(context.Context, *composetypes.Project) error {
+ return prepareErr
+ })
+ require.ErrorIs(t, err, prepareErr)
+
+ require.NoError(t, os.RemoveAll(filepath.Join(projectDir, "conf")))
+ _, err = LoadComposeProject(context.Background(), composePath, "caddy", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, nil)
+ require.NoError(t, err)
+ assert.NoDirExists(t, filepath.Join(projectDir, "conf"), "nil prepare must not create bind directories")
+}