ec9b323318
All checks were successful
Release / build (amd64, linux) (push) Successful in 1m15s
CI / build-and-test (push) Successful in 1m7s
Release / build (amd64, windows) (push) Successful in 1m3s
Release / build (amd64, darwin) (push) Successful in 1m8s
Release / build (arm64, darwin) (push) Successful in 46s
Release / build (arm64, linux) (push) Successful in 50s
Release / release (push) Successful in 26s
- Update module path: gitea.com/gitea/act_runner → git.marketally.com/gitcaddy/gitcaddy-runner - Update all import paths across Go source files - Update Makefile LDFLAGS and package references - Update .goreleaser.yaml ldflags and S3 directory path - Add comprehensive README with capacity configuration documentation - Document troubleshooting for capacity feature and Docker detection - Bump version to v1.0.0 for major rebrand - All linting checks passed (fmt-check, go mod tidy, go vet)
380 lines
11 KiB
Go
380 lines
11 KiB
Go
// Copyright 2026 MarketAlly. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package cleanup
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"git.marketally.com/gitcaddy/gitcaddy-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)
|
|
}
|
|
|
|
// 5. Clean build tool caches (older than 7 days)
|
|
// These can grow very large from Go, npm, nuget, gradle, maven builds
|
|
if bytes, files, err := cleanBuildCaches(7 * 24 * time.Hour); err != nil {
|
|
result.Errors = append(result.Errors, fmt.Errorf("build cache cleanup: %w", err))
|
|
} else {
|
|
result.BytesFreed += bytes
|
|
result.FilesDeleted += files
|
|
log.Infof("Cleaned build caches: 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-", "go-build", "go-link", "node-compile-cache", "npm-", "yarn-", "pnpm-"}
|
|
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
|
|
}
|
|
|
|
// cleanBuildCaches removes old build tool caches that accumulate from CI jobs
|
|
// These are cleaned more aggressively (files older than 7 days) since they can grow very large
|
|
func cleanBuildCaches(maxAge time.Duration) (int64, int, error) {
|
|
home := os.Getenv("HOME")
|
|
if home == "" {
|
|
home = os.Getenv("USERPROFILE") // Windows
|
|
}
|
|
if home == "" {
|
|
home = "/root" // fallback for runners typically running as root
|
|
}
|
|
|
|
var totalBytesFreed int64
|
|
var totalFilesDeleted int
|
|
|
|
// Build cache directories to clean
|
|
// Format: {path, description, maxAge (0 = use default)}
|
|
// Go build cache cleaned more aggressively (3 days) as it grows very fast
|
|
goBuildMaxAge := 3 * 24 * time.Hour
|
|
cacheDirs := []struct {
|
|
path string
|
|
desc string
|
|
maxAge time.Duration
|
|
}{
|
|
// Linux paths
|
|
{filepath.Join(home, ".cache", "go-build"), "Go build cache", goBuildMaxAge},
|
|
{filepath.Join(home, ".cache", "golangci-lint"), "golangci-lint cache", 0},
|
|
{filepath.Join(home, ".npm", "_cacache"), "npm cache", 0},
|
|
{filepath.Join(home, ".cache", "pnpm"), "pnpm cache", 0},
|
|
{filepath.Join(home, ".cache", "yarn"), "yarn cache", 0},
|
|
{filepath.Join(home, ".nuget", "packages"), "NuGet cache", 0},
|
|
{filepath.Join(home, ".gradle", "caches"), "Gradle cache", 0},
|
|
{filepath.Join(home, ".m2", "repository"), "Maven cache", 0},
|
|
{filepath.Join(home, ".cache", "pip"), "pip cache", 0},
|
|
{filepath.Join(home, ".cargo", "registry", "cache"), "Cargo cache", 0},
|
|
{filepath.Join(home, ".rustup", "tmp"), "Rustup temp", 0},
|
|
// macOS paths (Library/Caches)
|
|
{filepath.Join(home, "Library", "Caches", "go-build"), "Go build cache (macOS)", goBuildMaxAge},
|
|
{filepath.Join(home, "Library", "Caches", "Yarn"), "Yarn cache (macOS)", 0},
|
|
{filepath.Join(home, "Library", "Caches", "pip"), "pip cache (macOS)", 0},
|
|
{filepath.Join(home, "Library", "Caches", "Homebrew"), "Homebrew cache (macOS)", 0},
|
|
// Windows paths (LOCALAPPDATA)
|
|
{filepath.Join(os.Getenv("LOCALAPPDATA"), "go-build"), "Go build cache (Windows)", goBuildMaxAge},
|
|
{filepath.Join(os.Getenv("LOCALAPPDATA"), "npm-cache"), "npm cache (Windows)", 0},
|
|
{filepath.Join(os.Getenv("LOCALAPPDATA"), "pnpm"), "pnpm cache (Windows)", 0},
|
|
{filepath.Join(os.Getenv("LOCALAPPDATA"), "Yarn", "Cache"), "Yarn cache (Windows)", 0},
|
|
{filepath.Join(os.Getenv("LOCALAPPDATA"), "NuGet", "v3-cache"), "NuGet cache (Windows)", 0},
|
|
{filepath.Join(os.Getenv("LOCALAPPDATA"), "pip", "Cache"), "pip cache (Windows)", 0},
|
|
}
|
|
|
|
for _, cache := range cacheDirs {
|
|
if _, err := os.Stat(cache.path); os.IsNotExist(err) {
|
|
continue
|
|
}
|
|
|
|
// Use cache-specific maxAge if set, otherwise use default
|
|
cacheMaxAge := cache.maxAge
|
|
if cacheMaxAge == 0 {
|
|
cacheMaxAge = maxAge
|
|
}
|
|
cutoff := time.Now().Add(-cacheMaxAge)
|
|
|
|
var bytesFreed int64
|
|
var filesDeleted int
|
|
|
|
err := filepath.Walk(cache.path, 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
|
|
})
|
|
|
|
if err == nil && (bytesFreed > 0 || filesDeleted > 0) {
|
|
log.Infof("Cleaned %s: freed %s, deleted %d files", cache.desc, formatBytes(bytesFreed), filesDeleted)
|
|
totalBytesFreed += bytesFreed
|
|
totalFilesDeleted += filesDeleted
|
|
}
|
|
|
|
// Also remove empty directories
|
|
filepath.Walk(cache.path, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil || !info.IsDir() || path == cache.path {
|
|
return nil
|
|
}
|
|
entries, _ := os.ReadDir(path)
|
|
if len(entries) == 0 {
|
|
os.Remove(path)
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
return totalBytesFreed, totalFilesDeleted, nil
|
|
}
|
|
|
|
// 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])
|
|
}
|