Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: tolerate undefined typed env vars in GitOps sync (#2721)
Kyle Mendellf5bebb097e76
diff --git a/backend/go.mod b/backend/go.modindex 9295ff6b8..152cbdb40 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -19,6 +19,7 @@ require (github.com/depot/depot-go v0.5.2github.com/docker/cli v29.5.2+incompatiblegithub.com/docker/compose/v5 v5.1.4+ github.com/docker/go-units v0.5.0github.com/fsnotify/fsnotify v1.10.1github.com/getarcaneapp/arcane/cli v1.19.1github.com/getarcaneapp/arcane/types v1.19.4@@ -104,7 +105,6 @@ require (github.com/docker/docker v28.5.2+incompatible // indirectgithub.com/docker/docker-credential-helpers v0.9.7 // indirectgithub.com/docker/go-connections v0.7.0 // indirect- github.com/docker/go-units v0.5.0 // indirectgithub.com/dustin/go-humanize v1.0.1 // indirectgithub.com/ebitengine/purego v0.10.0 // indirectgithub.com/eclipse/paho.golang v0.23.0 // indirectdiff --git a/backend/internal/services/gitops_sync_service.go b/backend/internal/services/gitops_sync_service.goindex 16a4d369f..1ed9d5117 100644--- a/backend/internal/services/gitops_sync_service.go+++ b/backend/internal/services/gitops_sync_service.go@@ -1132,6 +1132,9 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync_ = os.RemoveAll(stagePath)return nil, fmt.Errorf("failed to stage current project files: %w", err)}+ } else if err := s.seedStageEnvFromCandidateDirInternal(ctx, sync, projectsDir, stagePath); err != nil {+ _ = os.RemoveAll(stagePath)+ return nil, err}syncedFiles := make([]string, len(syncFiles))@@ -1185,6 +1188,88 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync}, nil}+// seedStageEnvFromCandidateDirInternal copies env files from a pre-existing project+// directory at the conventional path (projectsDir/<sanitized-sync-name>/) into the+// staging directory before initial-sync validation. This lets users pre-seed+// ${VAR} substitutions via a server-side .env when the compose file in git+// expects values that the git repo intentionally does not provide. Only env+// files are touched — other files would conflict with what WriteSyncedDirectory+// is about to lay down from git.+func (s *GitOpsSyncService) seedStageEnvFromCandidateDirInternal(ctx context.Context, sync *models.GitOpsSync, projectsDir, stagePath string) error {+ candidatePath := filepath.Join(projectsDir, projects.SanitizeProjectName(sync.ProjectName))+ info, err := os.Stat(candidatePath)+ if err != nil {+ if errors.Is(err, os.ErrNotExist) {+ return nil+ }+ return fmt.Errorf("inspect pre-existing project directory %s: %w", candidatePath, err)+ }+ if !info.IsDir() {+ return nil+ }++ readOptional := func(name string) (string, bool, error) {+ content, readErr := os.ReadFile(filepath.Join(candidatePath, name))+ if readErr == nil {+ return string(content), true, nil+ }+ if errors.Is(readErr, os.ErrNotExist) {+ return "", false, nil+ }+ return "", false, fmt.Errorf("read %s from %s: %w", name, candidatePath, readErr)+ }++ effective, hasEffective, err := readOptional(projects.EffectiveEnvFileName)+ if err != nil {+ return err+ }+ gitSource, hasGit, err := readOptional(projects.GitSourceEnvFileName)+ if err != nil {+ return err+ }+ override, hasOverride, err := readOptional(projects.OverrideEnvFileName)+ if err != nil {+ return err+ }+ if !hasEffective && !hasGit && !hasOverride {+ return nil+ }++ if hasGit {+ if err := projects.WriteProjectFile(projectsDir, stagePath, projects.GitSourceEnvFileName, gitSource); err != nil {+ return fmt.Errorf("seed stage .env.git: %w", err)+ }+ }+ if hasOverride {+ if err := projects.WriteProjectFile(projectsDir, stagePath, projects.OverrideEnvFileName, override); err != nil {+ return fmt.Errorf("seed stage project.env: %w", err)+ }+ }++ switch {+ case hasEffective:+ if err := projects.WriteEnvFile(projectsDir, stagePath, effective); err != nil {+ return fmt.Errorf("seed stage .env: %w", err)+ }+ case hasGit || hasOverride:+ merged, mergeErr := projects.BuildEffectiveEnvContent(gitSource, override)+ if mergeErr != nil {+ return fmt.Errorf("build effective env from pre-existing project: %w", mergeErr)+ }+ if err := projects.WriteEnvFile(projectsDir, stagePath, merged); err != nil {+ return fmt.Errorf("seed stage .env: %w", err)+ }+ }++ slog.DebugContext(ctx, "Seeded GitOps stage with pre-existing project env files",+ "candidatePath", candidatePath,+ "hasEffective", hasEffective,+ "hasGit", hasGit,+ "hasOverride", hasOverride,+ )+ return nil+}+func (s *GitOpsSyncService) lookupProjectByIDInternal(ctx context.Context, projectID string) (*models.Project, bool, error) {var project models.Projectif err := s.db.WithContext(ctx).Where("id = ?", projectID).First(&project).Error; err != nil {diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.goindex bf636ee42..e90733bdf 100644--- a/backend/pkg/projects/load.go+++ b/backend/pkg/projects/load.go@@ -6,16 +6,20 @@ import ("fmt""log/slog""maps"+ "math""os""path/filepath""slices"+ "strconv""strings"interp "github.com/compose-spec/compose-go/v2/interpolation""github.com/compose-spec/compose-go/v2/loader""github.com/compose-spec/compose-go/v2/template"+ "github.com/compose-spec/compose-go/v2/tree"composetypes "github.com/compose-spec/compose-go/v2/types""github.com/docker/compose/v5/pkg/api"+ units "github.com/docker/go-units")var errComposeFileNotFoundInternal = errors.New("no compose file found")@@ -153,6 +157,64 @@ func LoadComposeProjectLenient(ctx context.Context, composeFile, projectName, prreturn loadComposeProjectInternal(ctx, composeFile, projectName, projectsDirectory, autoInjectEnv, pathMapper, nil, nil, true)}+// wrapTypeCastMappingLenientInternal prepares the interp type-cast mapping for lenient+// loading: every existing cast falls back to "0" when it fails (so the lenient+// placeholder for an undefined variable doesn't abort interpolation), and casts+// are added for typed struct fields that compose-go would otherwise decode at+// the mapstructure stage (NanoCPUs, UnitBytes under deploy.resources). Without+// the added casts, the placeholder string reaches mapstructure and fails to+// parse — handling it at interp time lets us hand mapstructure a typed value+// it accepts directly.+func wrapTypeCastMappingLenientInternal(mapping map[tree.Path]interp.Cast) map[tree.Path]interp.Cast {+ wrapped := make(map[tree.Path]interp.Cast, len(mapping)+4)+ for path, original := range mapping {+ wrapped[path] = wrapCastWithLenientFallbackInternal(original)+ }+ addIfAbsent := func(path tree.Path, cast interp.Cast) {+ if _, exists := wrapped[path]; exists {+ return+ }+ wrapped[path] = wrapCastWithLenientFallbackInternal(cast)+ }+ for _, section := range []string{"limits", "reservations"} {+ addIfAbsent(tree.NewPath("services", tree.PathMatchAll, "deploy", "resources", section, "cpus"), lenientCastFloatInternal)+ addIfAbsent(tree.NewPath("services", tree.PathMatchAll, "deploy", "resources", section, "memory"), lenientCastSizeInternal)+ }+ return wrapped+}++func wrapCastWithLenientFallbackInternal(original interp.Cast) interp.Cast {+ return func(value string) (interface{}, error) {+ result, err := original(value)+ if err == nil {+ return result, nil+ }+ if fallback, fallbackErr := original("0"); fallbackErr == nil {+ return fallback, nil+ }+ return result, err+ }+}++func lenientCastFloatInternal(value string) (interface{}, error) {+ return strconv.ParseFloat(value, 64)+}++func lenientCastSizeInternal(value string) (interface{}, error) {+ n, err := strconv.ParseInt(value, 10, 64)+ if err != nil {+ b, parseErr := units.RAMInBytes(value)+ if parseErr != nil {+ return nil, parseErr+ }+ n = b+ }+ if n > math.MaxInt || n < math.MinInt {+ return nil, fmt.Errorf("size %d out of range for platform int", n)+ }+ return int(n), nil+}+func loadComposeProjectInternal(ctx context.Context,composeFile string,@@ -210,13 +272,15 @@ func loadComposeProjectInternal(opts.SetProjectName(projectName, true)}if lenient {+ opts.SkipValidation = true+ opts.SkipConsistencyCheck = trueif opts.Interpolate == nil {slog.WarnContext(ctx, "compose loader did not initialize Interpolate options; lenient variable substitution will not apply", "compose_file", composeFile)} else {realLookup := opts.Interpolate.LookupValueopts.Interpolate = &interp.Options{Substitute: template.Substitute,- TypeCastMapping: opts.Interpolate.TypeCastMapping,+ TypeCastMapping: wrapTypeCastMappingLenientInternal(opts.Interpolate.TypeCastMapping),LookupValue: func(key string) (string, bool) {if val, ok := realLookup(key); ok {return val, truediff --git a/backend/pkg/projects/load_test.go b/backend/pkg/projects/load_test.goindex b3db59e0a..dcd44e8b2 100644--- a/backend/pkg/projects/load_test.go+++ b/backend/pkg/projects/load_test.go@@ -188,6 +188,32 @@ func TestLoadComposeProjectLenient_ToleratesUndefinedVariables(t *testing.T) {assert.Len(t, project.Services, 1)}+func TestLoadComposeProjectLenient_ToleratesUndefinedTypedFieldVariables(t *testing.T) {+ t.Parallel()++ // Same chicken-and-egg problem for typed fields: deploy.resources.limits.cpus+ // is parsed as a float and memory as a size. With no .env the strict loader+ // fails with `strconv.ParseFloat: parsing "": invalid syntax` and+ // `invalid size: ''`. Lenient mode must succeed so the GitOps sync can+ // create the project and let the user supply real values afterward.+ dir := t.TempDir()+ composePath := filepath.Join(dir, "compose.yaml")+ require.NoError(t, os.WriteFile(composePath, []byte(`services:+ chrony:+ image: ${DOCKER_IMAGE}+ deploy:+ resources:+ limits:+ cpus: ${CPU}+ memory: ${MEMORY}+`), 0o600))++ project, err := LoadComposeProjectLenient(context.Background(), composePath, "demo", dir, false, nil)+ require.NoError(t, err)+ require.NotNil(t, project)+ assert.Len(t, project.Services, 1)+}+func TestLoadComposeProject_UsesProjectLevelComposeLabelsForIncludedServices(t *testing.T) {t.Parallel()