gitcaddy-runner/internal/pkg/cleanup/cleanup.go

// Copyright 2026 MarketAlly. All rights reserved.
// SPDX-License-Identifier: MIT

package cleanup

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

	"gitea.com/gitea/act_runner/internal/pkg/config"

	log "github.com/sirupsen/logrus"
)

// CleanupResult contains the results of a cleanup operation
type CleanupResult struct {
	BytesFreed   int64
	FilesDeleted int
	Errors       []error
	Duration     time.Duration
}

// RunCleanup performs cleanup operations to free disk space
func RunCleanup(ctx context.Context, cfg *config.Config) (*CleanupResult, error) {
	start := time.Now()
	result := &CleanupResult{}

	log.Info("Starting runner cleanup...")

	// 1. Clean old cache directories
	cacheDir := filepath.Join(cfg.Cache.Dir, "_cache")
	if cacheDir != "" {
		if bytes, files, err := cleanOldDir(cacheDir, 24*time.Hour); err != nil {
			result.Errors = append(result.Errors, fmt.Errorf("cache cleanup: %w", err))
		} else {
			result.BytesFreed += bytes
			result.FilesDeleted += files
			log.Infof("Cleaned cache: freed %d bytes, deleted %d files", bytes, files)
		}
	}

	// 2. Clean old work directories
	workDir := cfg.Container.WorkdirParent
	if workDir != "" {
		if bytes, files, err := cleanOldWorkDirs(workDir, 48*time.Hour); err != nil {
			result.Errors = append(result.Errors, fmt.Errorf("workdir cleanup: %w", err))
		} else {
			result.BytesFreed += bytes
			result.FilesDeleted += files
			log.Infof("Cleaned work dirs: freed %d bytes, deleted %d files", bytes, files)
		}
	}

	// 3. Clean old artifact staging directories
	artifactDir := cfg.Cache.Dir
	if bytes, files, err := cleanOldArtifacts(artifactDir, 72*time.Hour); err != nil {
		result.Errors = append(result.Errors, fmt.Errorf("artifact cleanup: %w", err))
	} else {
		result.BytesFreed += bytes
		result.FilesDeleted += files
		log.Infof("Cleaned artifacts: freed %d bytes, deleted %d files", bytes, files)
	}

	// 4. Clean system temp files (older than 24h)
	if bytes, files, err := cleanTempDir(24 * time.Hour); err != nil {
		result.Errors = append(result.Errors, fmt.Errorf("temp cleanup: %w", err))
	} else {
		result.BytesFreed += bytes
		result.FilesDeleted += files
		log.Infof("Cleaned temp: freed %d bytes, deleted %d files", bytes, files)
	}

	result.Duration = time.Since(start)
	log.Infof("Cleanup completed: freed %s in %s", formatBytes(result.BytesFreed), result.Duration)

	return result, nil
}

// cleanOldDir removes files older than maxAge from a directory
func cleanOldDir(dir string, maxAge time.Duration) (int64, int, error) {
	if _, err := os.Stat(dir); os.IsNotExist(err) {
		return 0, 0, nil
	}

	var bytesFreed int64
	var filesDeleted int
	cutoff := time.Now().Add(-maxAge)

	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil // Skip errors
		}
		if info.IsDir() {
			return nil
		}
		if info.ModTime().Before(cutoff) {
			size := info.Size()
			if err := os.Remove(path); err == nil {
				bytesFreed += size
				filesDeleted++
			}
		}
		return nil
	})

	return bytesFreed, filesDeleted, err
}

// cleanOldWorkDirs removes work directories older than maxAge
func cleanOldWorkDirs(baseDir string, maxAge time.Duration) (int64, int, error) {
	if _, err := os.Stat(baseDir); os.IsNotExist(err) {
		return 0, 0, nil
	}

	var bytesFreed int64
	var filesDeleted int
	cutoff := time.Now().Add(-maxAge)

	entries, err := os.ReadDir(baseDir)
	if err != nil {
		return 0, 0, err
	}

	for _, entry := range entries {
		if !entry.IsDir() {
			continue
		}
		path := filepath.Join(baseDir, entry.Name())
		info, err := entry.Info()
		if err != nil {
			continue
		}
		if info.ModTime().Before(cutoff) {
			size := dirSize(path)
			if err := os.RemoveAll(path); err == nil {
				bytesFreed += size
				filesDeleted++
				log.Debugf("Removed old work dir: %s", path)
			}
		}
	}

	return bytesFreed, filesDeleted, nil
}

// cleanOldArtifacts removes artifact staging files older than maxAge
func cleanOldArtifacts(baseDir string, maxAge time.Duration) (int64, int, error) {
	if _, err := os.Stat(baseDir); os.IsNotExist(err) {
		return 0, 0, nil
	}

	var bytesFreed int64
	var filesDeleted int
	cutoff := time.Now().Add(-maxAge)

	// Look for artifact staging dirs
	patterns := []string{"artifact-*", "upload-*", "download-*"}
	for _, pattern := range patterns {
		matches, _ := filepath.Glob(filepath.Join(baseDir, pattern))
		for _, path := range matches {
			info, err := os.Stat(path)
			if err != nil {
				continue
			}
			if info.ModTime().Before(cutoff) {
				var size int64
				if info.IsDir() {
					size = dirSize(path)
					err = os.RemoveAll(path)
				} else {
					size = info.Size()
					err = os.Remove(path)
				}
				if err == nil {
					bytesFreed += size
					filesDeleted++
				}
			}
		}
	}

	return bytesFreed, filesDeleted, nil
}

// cleanTempDir removes old files from system temp directory
func cleanTempDir(maxAge time.Duration) (int64, int, error) {
	tmpDir := os.TempDir()
	var bytesFreed int64
	var filesDeleted int
	cutoff := time.Now().Add(-maxAge)

	entries, err := os.ReadDir(tmpDir)
	if err != nil {
		return 0, 0, err
	}

	// Only clean files/dirs that look like runner/act artifacts
	runnerPatterns := []string{"act-", "runner-", "gitea-", "workflow-"}
	for _, entry := range entries {
		name := entry.Name()
		isRunner := false
		for _, p := range runnerPatterns {
			if len(name) >= len(p) && name[:len(p)] == p {
				isRunner = true
				break
			}
		}
		if !isRunner {
			continue
		}

		path := filepath.Join(tmpDir, name)
		info, err := entry.Info()
		if err != nil {
			continue
		}
		if info.ModTime().Before(cutoff) {
			var size int64
			if info.IsDir() {
				size = dirSize(path)
				err = os.RemoveAll(path)
			} else {
				size = info.Size()
				err = os.Remove(path)
			}
			if err == nil {
				bytesFreed += size
				filesDeleted++
			}
		}
	}

	return bytesFreed, filesDeleted, nil
}

// dirSize calculates the total size of a directory
func dirSize(path string) int64 {
	var size int64
	filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		if !info.IsDir() {
			size += info.Size()
		}
		return nil
	})
	return size
}

// formatBytes formats bytes into human readable string
func formatBytes(bytes int64) string {
	const unit = 1024
	if bytes < unit {
		return fmt.Sprintf("%d B", bytes)
	}
	div, exp := int64(unit), 0
	for n := bytes / unit; n >= unit; n /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
}