Handle truncated bundles gracefully during restore (#12)

When a bundle was uploaded partially (e.g. the uploader crashed
mid-tar), restoring it would fail with an `unexpected EOF` error. This
change catches that case and logs a warning instead, allowing the
partially extracted cache to still be used.

Author: joshfriend

gradlecache/extract_default.go

@@ -251,6 +251,9 @@ func processEntry(
 				if err != nil {
 					largeChunkPool.Put(buf)
 					close(chunks)
+					// Remove the partially-written file so a truncated
+					// bundle doesn't leave corrupt artifacts on disk.
+					os.Remove(target) //nolint:errcheck
 					return errors.Errorf("read %s: %w", hdr.Name, err)
 				}
 				*buf = (*buf)[:n]

gradlecache/gradlecache_test.go

@@ -5,6 +5,7 @@ import (
 	archive_tar "archive/tar"
 	"bytes"
 	"context"
+	stderrors "errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -487,6 +488,72 @@ func TestExtractZstdDrainsBufferedReaderToEOF(t *testing.T) {
 	})
 }
 
+// ─── Truncated archive test ──────────────────────────────────────────────────
+
+// TestExtractBundleTruncatedArchive verifies that extractBundleZstd returns an
+// io.ErrUnexpectedEOF when the archive is truncated, and that no partially
+// written files are left on disk.
+func TestExtractBundleTruncatedArchive(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("small files", func(t *testing.T) {
+		srcDir := t.TempDir()
+		must(t, os.MkdirAll(filepath.Join(srcDir, "caches"), 0o755))
+		must(t, os.WriteFile(filepath.Join(srcDir, "caches", "first.jar"), bytes.Repeat([]byte("A"), 4096), 0o644))
+		must(t, os.WriteFile(filepath.Join(srcDir, "caches", "second.jar"), bytes.Repeat([]byte("B"), 4096), 0o644))
+
+		var archive bytes.Buffer
+		must(t, CreateDeltaTarZstd(ctx, &archive, srcDir, []string{"caches/first.jar", "caches/second.jar"}))
+
+		truncated := archive.Bytes()[:archive.Len()*60/100]
+		gradleHome := t.TempDir()
+		projectDir := t.TempDir()
+
+		_, err := extractBundleZstd(ctx, bytes.NewReader(truncated), []extractRule{
+			{prefix: "caches/", baseDir: gradleHome},
+		}, projectDir, false)
+
+		if err == nil {
+			t.Fatal("expected an error from truncated archive, got nil")
+		}
+		if !stderrors.Is(err, io.ErrUnexpectedEOF) {
+			t.Fatalf("expected io.ErrUnexpectedEOF in error chain, got: %v", err)
+		}
+	})
+
+	t.Run("large file no partial artifact", func(t *testing.T) {
+		srcDir := t.TempDir()
+		must(t, os.MkdirAll(filepath.Join(srcDir, "caches"), 0o755))
+		// 5 MB file — larger than maxBufferedFileSize so it takes the
+		// streaming large-file path.
+		must(t, os.WriteFile(filepath.Join(srcDir, "caches", "big.jar"), bytes.Repeat([]byte("X"), 5<<20), 0o644))
+
+		var archive bytes.Buffer
+		must(t, CreateDeltaTarZstd(ctx, &archive, srcDir, []string{"caches/big.jar"}))
+
+		// Truncate at ~60% so the large-file read fails mid-stream.
+		truncated := archive.Bytes()[:archive.Len()*60/100]
+		gradleHome := t.TempDir()
+		projectDir := t.TempDir()
+
+		_, err := extractBundleZstd(ctx, bytes.NewReader(truncated), []extractRule{
+			{prefix: "caches/", baseDir: gradleHome},
+		}, projectDir, false)
+
+		if err == nil {
+			t.Fatal("expected an error from truncated archive, got nil")
+		}
+		if !stderrors.Is(err, io.ErrUnexpectedEOF) {
+			t.Fatalf("expected io.ErrUnexpectedEOF in error chain, got: %v", err)
+		}
+
+		// The partially-written large file must not remain on disk.
+		if _, statErr := os.Stat(filepath.Join(gradleHome, "caches", "big.jar")); statErr == nil {
+			t.Fatal("partially-written big.jar should have been removed")
+		}
+	})
+}
+
 // ─── Round-trip archive test ─────────────────────────────────────────────────
 
 // TestTarZstdRoundTrip verifies that CreateTarZstd → extractTarZstd preserves

gradlecache/restore.go

@@ -436,7 +436,15 @@ func Restore(ctx context.Context, cfg RestoreConfig) error {
 	netTiming := &timingReader{r: cb}
 	ps, err := extractBundleZstd(ctx, netTiming, rules, cfg.ProjectDir, !gradleUserHomeEmpty)
 	if err != nil {
-		return errors.Wrap(err, "extract bundle")
+		// A truncated tar archive (e.g. from a crash during upload) produces an
+		// unexpected EOF during extraction. Treat this as a warning rather than
+		// a fatal error: the files extracted before the truncation point are
+		// still usable and better than no cache at all.
+		if errors.Is(err, io.ErrUnexpectedEOF) {
+			log.Warn("bundle appears truncated! using partially extracted cache", "err", err)
+		} else {
+			return errors.Wrap(err, "extract bundle")
+		}
 	}
 
 	totalElapsed := time.Since(dlStart)