perf: only copy files from cache when required

Author: damienbutt

internal/cache/artifacts.go

@@ -18,6 +18,8 @@
 package cache
 
 import (
+	"bytes"
+	"crypto/sha256"
 	"fmt"
 	"io"
 	"os"
@@ -35,7 +37,8 @@ func CopyArtifacts(baseDir, destDir string, outputs []string) error {
 		src := filepath.Join(baseDir, output)
 		dst := filepath.Join(destDir, output)
 
-		if err := copyFile(src, dst); err != nil {
+		// Only copy if file doesn't exist or differs (optimization for re-caching)
+		if _, err := copyFileIfNeeded(src, dst); err != nil {
 			return fmt.Errorf("failed to copy %s: %w", output, err)
 		}
 	}
@@ -55,7 +58,8 @@ func RestoreArtifacts(cacheDir, destDir string, outputs []string) error {
 			return fmt.Errorf("failed to create output directory: %w", err)
 		}
 
-		if err := copyFile(src, dst); err != nil {
+		// Only copy if file doesn't exist or differs
+		if _, err := copyFileIfNeeded(src, dst); err != nil {
 			return fmt.Errorf("failed to restore %s: %w", output, err)
 		}
 	}
@@ -250,3 +254,77 @@ func copyFile(src, dst string) error {
 
 	return os.Chmod(dst, srcInfo.Mode())
 }
+
+// filesAreIdentical checks if two files have the same content
+// Uses a fast size check first, then hash comparison if needed
+func filesAreIdentical(file1, file2 string) bool {
+	// Get file info for both files
+	info1, err1 := os.Stat(file1)
+	info2, err2 := os.Stat(file2)
+
+	// If either file doesn't exist or we can't stat it, they're not identical
+	if err1 != nil || err2 != nil {
+		return false
+	}
+
+	// Quick check: if sizes differ, files are different
+	if info1.Size() != info2.Size() {
+		return false
+	}
+
+	// If size is 0, both empty files are identical
+	if info1.Size() == 0 {
+		return true
+	}
+
+	// For small files (< 64KB), compare content directly
+	if info1.Size() < 65536 {
+		content1, err1 := os.ReadFile(file1)
+		content2, err2 := os.ReadFile(file2)
+		if err1 != nil || err2 != nil {
+			return false
+		}
+		return bytes.Equal(content1, content2)
+	}
+
+	// For larger files, use hash comparison
+	hash1, err1 := hashFile(file1)
+	hash2, err2 := hashFile(file2)
+	if err1 != nil || err2 != nil {
+		return false
+	}
+
+	return bytes.Equal(hash1, hash2)
+}
+
+// hashFile computes SHA256 hash of a file
+func hashFile(path string) ([]byte, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	hash := sha256.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return nil, err
+	}
+
+	return hash.Sum(nil), nil
+}
+
+// copyFileIfNeeded copies a file only if destination doesn't exist or differs from source
+// Returns true if file was copied, false if copy was skipped
+func copyFileIfNeeded(src, dst string) (bool, error) {
+	// Check if files are already identical
+	if filesAreIdentical(src, dst) {
+		return false, nil // Skip copy
+	}
+
+	// Files differ or destination doesn't exist, perform copy
+	if err := copyFile(src, dst); err != nil {
+		return false, err
+	}
+
+	return true, nil
+}

internal/cache/cache_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"github.com/Norgate-AV/spc/internal/config"
 	"github.com/stretchr/testify/assert"
@@ -867,3 +868,99 @@ func TestCache_UshFiles_TargetSpecific(t *testing.T) {
 		}
 	}
 }
+
+// TestCache_Restore_SkipsIdenticalFiles verifies that restoration only copies files
+// when necessary, skipping identical files to improve performance
+func TestCache_Restore_SkipsIdenticalFiles(t *testing.T) {
+	cacheDir := t.TempDir()
+	sourceDir := t.TempDir()
+	sourceFile := filepath.Join(sourceDir, "test.usp")
+	splsWorkDir := filepath.Join(sourceDir, "SPlsWork")
+
+	// Create source file
+	err := os.WriteFile(sourceFile, []byte("test source"), 0o644)
+	require.NoError(t, err)
+
+	// Create SPlsWork directory
+	err = os.MkdirAll(splsWorkDir, 0o755)
+	require.NoError(t, err)
+
+	// Create output files
+	outputs := []string{"test.dll", "test.cs"}
+	for _, output := range outputs {
+		path := filepath.Join(splsWorkDir, output)
+		err := os.WriteFile(path, []byte(fmt.Sprintf("content of %s", output)), 0o644)
+		require.NoError(t, err)
+	}
+
+	// Create .ush file
+	ushFile := filepath.Join(sourceDir, "test.ush")
+	err = os.WriteFile(ushFile, []byte("header content"), 0o644)
+	require.NoError(t, err)
+
+	// Create cache and store
+	cache, err := New(cacheDir)
+	require.NoError(t, err)
+	defer cache.Close()
+
+	cfg := &config.Config{Target: "3", UserFolders: []string{}}
+	err = cache.Store(sourceFile, cfg, true)
+	require.NoError(t, err)
+
+	// Get entry
+	entry, err := cache.Get(sourceFile, cfg)
+	require.NoError(t, err)
+	require.NotNil(t, entry)
+
+	// First restoration (files don't exist) - should copy all files
+	restoreDir1 := t.TempDir()
+	err = cache.Restore(entry, restoreDir1)
+	require.NoError(t, err)
+
+	// Verify files were created
+	for _, output := range outputs {
+		assert.FileExists(t, filepath.Join(restoreDir1, "SPlsWork", output))
+	}
+	assert.FileExists(t, filepath.Join(restoreDir1, "test.ush"))
+
+	// Get timestamps of restored files
+	dllPath := filepath.Join(restoreDir1, "SPlsWork", "test.dll")
+	infoBeforeSecondRestore, err := os.Stat(dllPath)
+	require.NoError(t, err)
+
+	// Wait a moment to ensure timestamps would differ if file was rewritten
+	time.Sleep(10 * time.Millisecond)
+
+	// Second restoration (files already exist and are identical) - should skip copying
+	err = cache.Restore(entry, restoreDir1)
+	require.NoError(t, err)
+
+	// Verify file timestamp didn't change (file wasn't copied)
+	infoAfterSecondRestore, err := os.Stat(dllPath)
+	require.NoError(t, err)
+	assert.Equal(t, infoBeforeSecondRestore.ModTime(), infoAfterSecondRestore.ModTime(),
+		"File should not be copied when it's already identical")
+
+	// Now modify a file to make it different
+	err = os.WriteFile(dllPath, []byte("corrupted content"), 0o644)
+	require.NoError(t, err)
+
+	infoAfterModification, err := os.Stat(dllPath)
+	require.NoError(t, err)
+
+	// Third restoration (file exists but differs) - should copy the modified file
+	time.Sleep(10 * time.Millisecond)
+	err = cache.Restore(entry, restoreDir1)
+	require.NoError(t, err)
+
+	// Verify file was restored (timestamp changed and content correct)
+	infoAfterThirdRestore, err := os.Stat(dllPath)
+	require.NoError(t, err)
+	assert.NotEqual(t, infoAfterModification.ModTime(), infoAfterThirdRestore.ModTime(),
+		"File should be copied when it differs from cached version")
+
+	// Verify content was correctly restored
+	content, err := os.ReadFile(dllPath)
+	require.NoError(t, err)
+	assert.Equal(t, "content of test.dll", string(content), "Content should be restored correctly")
+}