Skip to content

Modern Docker Management, Designed for Everyone

4.2 KB
Raw Blame
package projects

import (
	"bufio"
	"context"
	"fmt"
	"maps"
	"os"
	"path/filepath"
	"strings"

	"github.com/compose-spec/compose-go/v2/consts"
	"github.com/compose-spec/compose-go/v2/dotenv"
	"github.com/getarcaneapp/arcane/types/v2/env"
)

// BuildValidationEnvironment resolves the env a compose file is validated
// against. It matches the project-visible env sources without inheriting the
// Arcane process environment, which may contain unrelated secrets.
func BuildValidationEnvironment(ctx context.Context, projectsDirectory, projectPath string, effectiveEnvContent *string) (EnvMap, error) {
	fullEnvMap := make(EnvMap)
	if absWorkdir, absErr := filepath.Abs(projectPath); absErr == nil {
		fullEnvMap["PWD"] = absWorkdir
	} else {
		fullEnvMap["PWD"] = projectPath
	}

	globalEnvPath := filepath.Join(projectsDirectory, GlobalEnvFileName)
	globalEnv, err := ParseValidationEnvFile(globalEnvPath, fullEnvMap)
	if err != nil {
		return nil, fmt.Errorf("parse global env file: %w", err)
	}
	maps.Copy(fullEnvMap, globalEnv)

	// Mirror LoadEnvironment's COMPOSE_DISABLE_ENV_FILE / COMPOSE_ENV_FILES
	// handling so the validation env matches the runtime env exactly.
	if !parseComposeBoolInternal(fullEnvMap, consts.ComposeDisableDefaultEnvFile) {
		if effectiveEnvContent != nil {
			projectEnv, parseValidationEnvContentErr := ParseValidationEnvContent(*effectiveEnvContent, fullEnvMap)
			if parseValidationEnvContentErr != nil {
				return nil, fmt.Errorf("parse provided env content: %w", parseValidationEnvContentErr)
			}
			maps.Copy(fullEnvMap, projectEnv)
		} else {
			projectEnv, parseValidationEnvFileErr := ParseValidationEnvFile(filepath.Join(projectPath, ".env"), fullEnvMap)
			if parseValidationEnvFileErr != nil {
				return nil, fmt.Errorf("parse project env file: %w", parseValidationEnvFileErr)
			}
			maps.Copy(fullEnvMap, projectEnv)
		}
	}

	mergeComposeEnvFilesInternal(ctx, projectPath, fullEnvMap, ParseValidationEnvFile, nil)

	return fullEnvMap, nil
}

// ParseValidationEnvFile parses one env file against contextEnv. A missing file
// is not an error.
//
// Stays on os.*: env files may be symlinks resolving outside any confinement
// root (a supported setup), which acfs cannot follow.
func ParseValidationEnvFile(path string, contextEnv EnvMap) (EnvMap, error) {
	info, err := os.Stat(path)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, nil
		}
		return nil, fmt.Errorf("stat file: %w", err)
	}
	if info.IsDir() {
		return nil, nil
	}

	content, err := os.ReadFile(path)
	if err != nil {
		return nil, fmt.Errorf("read file: %w", err)
	}

	return ParseValidationEnvContent(string(content), contextEnv)
}

// ParseValidationEnvContent parses env content, resolving interpolations
// against contextEnv rather than the process environment.
func ParseValidationEnvContent(content string, contextEnv EnvMap) (EnvMap, error) {
	lookupFn := func(key string) (string, bool) {
		value, ok := contextEnv[key]
		return value, ok
	}

	envMap, err := dotenv.ParseWithLookup(strings.NewReader(content), lookupFn)
	if err != nil {
		return nil, fmt.Errorf("parse env: %w", err)
	}

	return envMap, nil
}

// ParseEnvContent parses environment variables from .env file content
func ParseEnvContent(content string) []env.Variable {
	if content == "" {
		return []env.Variable{}
	}

	var vars []env.Variable
	scanner := bufio.NewScanner(strings.NewReader(content))

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		// Skip empty lines and comments
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}

		// Split on first '='
		parts := strings.SplitN(line, "=", 2)
		if len(parts) != 2 {
			continue
		}

		key := strings.TrimSpace(parts[0])
		value := ""
		if len(parts) == 2 {
			value = strings.TrimSpace(parts[1])
		}

		// Strip surrounding quotes and handle escapes
		if len(value) >= 2 {
			if strings.HasPrefix(value, `"`) && strings.HasSuffix(value, `"`) {
				value = value[1 : len(value)-1]
				value = strings.ReplaceAll(value, `\"`, `"`)
			} else if strings.HasPrefix(value, `'`) && strings.HasSuffix(value, `'`) {
				value = value[1 : len(value)-1]
				value = strings.ReplaceAll(value, `\'`, `'`)
			}
		}

		if key != "" {
			vars = append(vars, env.Variable{
				Key:   key,
				Value: value,
			})
		}
	}

	return vars
}