Function bodies 16 total

func DiffDirs(lower, upper string) ([]Change, error) {
	var changes []Change
	err := filepath.Walk(upper, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if path == upper || info.IsDir() {
			return nil
		}
		rel, _ := filepath.Rel(upper, path)

		kind := Created
		if _, statErr := os.Stat(filepath.Join(lower, rel)); statErr == nil {
			kind = Modified
		}
		changes = append(changes, Change{
			Path: rel,
			Kind: kind,
			Size: info.Size(),
		})
		return nil
	})
	return changes, err
}

func CommitFiles(upper, lower string, paths []string) error {
	for _, p := range paths {
		src := filepath.Join(upper, p)
		dst := filepath.Join(lower, p)

		data, err := os.ReadFile(src) //nolint:gosec // path from controlled overlay
		if err != nil {
			return fmt.Errorf("mirage: commit read %s: %w", p, err)
		}
		if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
			return fmt.Errorf("mirage: commit mkdir: %w", err)
		}
		info, _ := os.Stat(src) //nolint:gosec // path from controlled overlay
		if err := os.WriteFile(dst, data, info.Mode()); err != nil {
			return fmt.Errorf("mirage: commit write %s: %w", p, err)
		}
	}
	return nil
}

func Create(spec Spec) (Space, error) {
	if err := spec.Validate(); err != nil {
		return nil, err
	}

	slog.Info("mirage: creating space",
		slog.String("workspace", spec.Workspace),
		slog.String("backend", string(spec.Backend)),
	)

	switch spec.Backend {
	case Overlay:
		return createOverlay(spec)
	case Stub:
		return createStub(spec), nil
	case Container:
		return nil, fmt.Errorf("%w: container backend not yet implemented", ErrUnknownBackend)
	case Sandbox:
		return nil, fmt.Errorf("%w: sandbox backend not yet implemented", ErrUnknownBackend)
	default:
		return nil, fmt.Errorf("%w: %s", ErrUnknownBackend, spec.Backend)
	}
}

func NewOverlayBuilder() *OverlayBuilder {
	return &OverlayBuilder{}
}

func createOverlay(spec Spec) (Space, error) {
	b := NewOverlayBuilder()
	return b.Create(spec.Workspace)
}

func (b *OverlayBuilder) Create(workspace string) (Space, error) {
	info, err := os.Stat(workspace)
	if err != nil {
		return nil, fmt.Errorf("mirage: workspace: %w", err)
	}
	if !info.IsDir() {
		return nil, fmt.Errorf("%w: %s", ErrNotDirectory, workspace)
	}

	if _, err := exec.LookPath("fuse-overlayfs"); err != nil {
		return nil, ErrFuseNotAvailable
	}

	tempDir, err := os.MkdirTemp("", "mirage-*")
	if err != nil {
		return nil, fmt.Errorf("mirage: temp dir: %w", err)
	}

	upper := filepath.Join(tempDir, "upper")
	work := filepath.Join(tempDir, "work")
	merged := filepath.Join(tempDir, "merged")

	for _, d := range []string{upper, work, merged} {
		if err := os.MkdirAll(d, 0o755); err != nil {
			os.RemoveAll(tempDir) //nolint:errcheck // best-effort cleanup
			return nil, fmt.Errorf("mirage: mkdir %s: %w", d, err)
		}
	}

	cmd := exec.Command("fuse-overlayfs", //nolint:gosec // paths are controlled
		"-o", fmt.Sprintf("lowerdir=%s,upperdir=%s,workdir=%s", workspace, upper, work),

func (s *overlaySpace) Diff() ([]Change, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	if !s.mounted {
		return nil, ErrNotMounted
	}

	var changes []Change
	err := filepath.Walk(s.upper, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if path == s.upper || info.IsDir() {
			return nil
		}

		rel, _ := filepath.Rel(s.upper, path)

		kind := Created
		if _, statErr := os.Stat(filepath.Join(s.lower, rel)); statErr == nil {
			kind = Modified
		}

		changes = append(changes, Change{
			Path: rel,
			Kind: kind,
			Size: info.Size(),
		})
		return nil
	})
	return changes, err
}

func (s *overlaySpace) Commit(paths []string) error {
	s.mu.Lock()
	defer s.mu.Unlock()

	if !s.mounted {
		return ErrNotMounted
	}

	for _, p := range paths {
		src := filepath.Join(s.upper, p)
		dst := filepath.Join(s.lower, p)

		data, err := os.ReadFile(src) //nolint:gosec // path from controlled overlay
		if err != nil {
			return fmt.Errorf("mirage: commit read %s: %w", p, err)
		}

		if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
			return fmt.Errorf("mirage: commit mkdir: %w", err)
		}

		info, _ := os.Stat(src) //nolint:gosec // path from controlled overlay
		if err := os.WriteFile(dst, data, info.Mode()); err != nil {
			return fmt.Errorf("mirage: commit write %s: %w", p, err)
		}
	}
	return nil
}

func (s *overlaySpace) Reset() error {
	s.mu.Lock()
	defer s.mu.Unlock()

	if !s.mounted {
		return ErrNotMounted
	}

	// Remove all files in upper, recreate the directory.
	if err := os.RemoveAll(s.upper); err != nil {
		return fmt.Errorf("mirage: reset upper: %w", err)
	}
	return os.MkdirAll(s.upper, 0o755)
}

func (s *overlaySpace) Destroy() error {
	s.mu.Lock()
	defer s.mu.Unlock()

	if !s.mounted {
		return nil
	}
	s.mounted = false

	// Unmount fuse-overlayfs.
	if out, err := exec.Command("fusermount3", "-u", s.merged).CombinedOutput(); err != nil { //nolint:gosec // path controlled
		if out2, err2 := exec.Command("fusermount", "-u", s.merged).CombinedOutput(); err2 != nil { //nolint:gosec // path controlled
			return fmt.Errorf("%w: %s / %s", ErrUnmountFailed, out, out2)
		}
	}

	return os.RemoveAll(s.tempDir)
}

func (s Spec) Validate() error {
	if s.Workspace == "" {
		return ErrWorkspaceRequired
	}
	if s.Backend == "" {
		return ErrBackendRequired
	}
	switch s.Backend {
	case Overlay, Container, Sandbox, Stub:
		return nil
	default:
		return ErrUnknownBackend
	}
}

func createStub(spec Spec) *StubSpace {
	// Create a real temp directory so file writes work in contract tests.
	tmpDir, _ := os.MkdirTemp("", "mirage-stub-*")
	return &StubSpace{
		workDir:   tmpDir,
		workspace: spec.Workspace,
	}
}

func (s *StubSpace) Diff() ([]Change, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.DiffCalls++

	// If Changes are pre-configured, return those.
	if len(s.Changes) > 0 {
		return s.Changes, nil
	}

	// Otherwise, scan the temp dir for real files (supports contract tests).
	var changes []Change
	filepath.Walk(s.workDir, func(path string, info os.FileInfo, err error) error { //nolint:errcheck
		if err != nil || info.IsDir() || path == s.workDir {
			return nil
		}
		rel, _ := filepath.Rel(s.workDir, path)
		changes = append(changes, Change{
			Path: rel,
			Kind: Created,
			Size: info.Size(),
		})
		return nil
	})
	return changes, nil
}

func (s *StubSpace) Commit(paths []string) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.CommitCalls++

	// Copy files from temp dir to real workspace.
	for _, p := range paths {
		src := filepath.Join(s.workDir, p)
		dst := filepath.Join(s.workspace, p)
		data, err := os.ReadFile(src) //nolint:gosec
		if err != nil {
			continue
		}
		os.MkdirAll(filepath.Dir(dst), 0o755) //nolint:errcheck
		os.WriteFile(dst, data, 0o644)        //nolint:errcheck,gosec
	}
	return nil
}

func (s *StubSpace) Reset() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.ResetCalls++

	// Remove all files from temp dir.
	entries, _ := os.ReadDir(s.workDir)
	for _, e := range entries {
		os.RemoveAll(filepath.Join(s.workDir, e.Name())) //nolint:errcheck
	}
	return nil
}

func (s *StubSpace) Destroy() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.DestroyCalls++

	if s.destroyed {
		return nil
	}
	s.destroyed = true
	return os.RemoveAll(s.workDir)
}