Skip to content

Modern Docker Management, Designed for Everyone

6.3 KB
Raw Blame
package projects

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"time"

	composetypes "github.com/compose-spec/compose-go/v2/types"
	projecttypes "github.com/getarcaneapp/arcane/types/v2/project"
	"github.com/samber/hot"
)

type composeCacheInternal[T any] struct {
	entries *hot.HotCache[string, composeCacheEntryInternal[T]]
	clone   func(T) T
}

type composeCacheEntryInternal[T any] struct {
	fingerprint string
	stamps      map[string]composeCacheStampInternal
	value       T
}

type composeCacheStampInternal struct {
	modTime time.Time
	size    int64
}

// NewComposeCache caches Compose-derived values and their file dependencies.
// clone, when supplied, isolates stored values from mutations by callers.
func NewComposeCache[T any](capacity int, clone func(T) T) projecttypes.ComposeCache[T] {
	return &composeCacheInternal[T]{entries: hot.NewHotCache[string, composeCacheEntryInternal[T]](hot.LRU, capacity).Build(), clone: clone}
}

// NewParsedComposeCache keeps operation-local models separate from cached state.
func NewParsedComposeCache() projecttypes.ComposeCache[*composetypes.Project] {
	return NewComposeCache(2048, cloneComposeProjectInternal)
}

func cloneComposeProjectInternal(project *composetypes.Project) *composetypes.Project {
	if project == nil {
		return nil
	}
	// With no names this compose-go operation deep-copies without disabling services.
	return project.WithServicesDisabled()
}

func (c *composeCacheInternal[T]) Get(projectID, fingerprint string) (T, bool) {
	entry, found := c.entries.Peek(projectID)
	if found && entry.fingerprint == fingerprint && validComposeCacheEntryInternal(entry.stamps) {
		if c.clone != nil {
			return c.clone(entry.value), true
		}
		return entry.value, true
	}
	var zero T
	return zero, false
}

func (c *composeCacheInternal[T]) Set(projectID, fingerprint, projectPath, projectsDirectory, composePath string, composeFiles, envFiles []string, loadedAt time.Time, value T) error {
	if strings.TrimSpace(projectID) == "" {
		return nil
	}
	stamps := make(map[string]composeCacheStampInternal)
	for _, path := range append([]string{composePath}, composeFiles...) {
		if path == "" {
			continue
		}
		info, err := os.Stat(path)
		if err != nil {
			return fmt.Errorf("stat compose file %s: %w", path, err)
		}
		if !info.ModTime().Before(loadedAt) {
			return nil
		}
		stamps[path] = composeCacheStampInternal{modTime: info.ModTime(), size: info.Size()}
	}
	dependencies := append([]string{filepath.Join(projectPath, EffectiveEnvFileName)}, envFiles...)
	if projectsDirectory != "" {
		dependencies = append(dependencies, filepath.Join(projectsDirectory, GlobalEnvFileName))
	}
	// A later standard override must invalidate a model loaded before it existed.
	for _, name := range composeOverrideFileCandidates {
		dependencies = append(dependencies, filepath.Join(filepath.Dir(composePath), name))
	}
	for _, path := range dependencies {
		info, err := os.Stat(path)
		if err == nil {
			if !info.ModTime().Before(loadedAt) {
				return nil
			}
			stamps[path] = composeCacheStampInternal{modTime: info.ModTime(), size: info.Size()}
			continue
		}
		if !os.IsNotExist(err) {
			return fmt.Errorf("stat compose dependency %s: %w", path, err)
		}
		stamps[path] = composeCacheStampInternal{}
	}
	if c.clone != nil {
		value = c.clone(value)
	}
	c.entries.Set(projectID, composeCacheEntryInternal[T]{fingerprint: fingerprint, stamps: stamps, value: value})
	return nil
}

func (c *composeCacheInternal[T]) Invalidate(projectID string) {
	c.entries.Delete(projectID)
}

func validComposeCacheEntryInternal(stamps map[string]composeCacheStampInternal) bool {
	for path, stamp := range stamps {
		info, err := os.Stat(path)
		if err != nil {
			if !os.IsNotExist(err) || !stamp.modTime.IsZero() {
				return false
			}
			continue
		}
		if stamp.modTime.IsZero() || !info.ModTime().Equal(stamp.modTime) || info.Size() != stamp.size {
			return false
		}
		// A chmod does not bump mtime, so confirm the file is still readable.
		file, err := os.Open(path)
		if err != nil {
			return false
		}
		if closeErr := file.Close(); closeErr != nil {
			return false
		}
	}
	return true
}

// LoadCachedComposeProject resolves an executable model with isolated cached state.
func LoadCachedComposeProject(ctx context.Context,
	cache projecttypes.ComposeCache[*composetypes.Project],
	projectID,
	projectPath,
	composePath,
	projectName,
	projectsDirectory string,
	autoInject bool,
	pathMapper *PathMapper) (*composetypes.Project,
	error,
) {
	fingerprint := fmt.Sprintf("%q|%q|%q|%t|%#v", composePath, projectName, projectsDirectory, autoInject, pathMapper)
	if cache != nil {
		if cached, ok := cache.Get(projectID, fingerprint); ok {
			return cached, nil
		}
	}
	dependencies := projecttypes.ComposeDependencies{}
	loadedAt := time.Now()
	model, err := LoadComposeProject(ctx, composePath, projectName, projectsDirectory, autoInject, pathMapper, nil, nil, false, &dependencies, nil, nil)
	if err != nil {
		return nil, err
	}
	if cache == nil {
		return model, nil
	}
	composeFiles, envFiles, ok := ComposeCacheDependencies(ctx, model, dependencies, composePath, projectsDirectory, autoInject)
	if !ok {
		// Metadata discovery failure disables caching; the executable model is valid.
		return model, nil
	}
	if setErr := cache.Set(projectID, fingerprint, projectPath, projectsDirectory, composePath, composeFiles, envFiles, loadedAt, model); setErr != nil {
		return nil, setErr
	}
	return model, nil
}

// ComposeCacheDependencies returns the compose and env files a model loaded
// from composePath depends on. ok is false when they cannot be discovered.
func ComposeCacheDependencies(
	ctx context.Context,
	model *composetypes.Project,
	dependencies projecttypes.ComposeDependencies,
	composePath, projectsDirectory string,
	autoInject bool,
) ([]string, []string, bool) {
	envFiles := dependencies.EnvFiles
	if envOpts, parseErr := ParseComposeEnvOptions(model.WorkingDir, EnvMap(model.Environment)); parseErr == nil {
		envFiles = append(envFiles, envOpts.EnvFiles...)
	}
	// Metadata discovery already follows recursive includes and their interpolation env files.
	meta, err := ParseArcaneComposeMetadata(ctx, composePath, projectsDirectory, autoInject)
	if err != nil {
		return nil, nil, false
	}
	composeFiles := append(append([]string{}, model.ComposeFiles...), meta.ComposeFiles...)
	return composeFiles, append(envFiles, meta.EnvFiles...), true
}