Update golangci-lint to v2.12.2 with canonical config (#62)

Updates golangci-lint to v2.12.2 everywhere it is pinned and installs the canonical `.golangci.yml`, then remediates every finding the new linter/config surfaces so `make check` is green. ## Version bump - `Dockerfile` lint stage: `golangci/golangci-lint:v2.11.3-alpine` -> `v2.12.2-alpine` (digest-pinned, date comment updated) - `Makefile` `deps` target: `go install` moved from the old v1 module path at `@latest` to the pinned `github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2` - `.golangci.yml` replaced with the canonical config (v2 schema; settings under `linters.settings` so the thresholds actually apply; `default: all` with the standard six disables) - `script/bootstrap` installs golangci-lint via the system package manager and carries no version pin, so it is unchanged - CI (`.gitea/workflows/check.yml`) only runs `script/cibuild`, so it needed no change ## Lint remediation The canonical config surfaced ~3,300 findings across 56k lines. All are fixed, behavior-preserving; incorporates and supersedes the per-package mechanical passes already merged to `main` (refs #61). Highlights: - `err113`: dynamic errors replaced with package sentinels + `%w` wrapping; comparisons via `errors.Is` - `goprintffuncname`: printf-style helpers renamed with an `f` suffix (`ui.Writer` message methods, `cli.ReportErrorf`, `database.Fatalf`) and all call sites updated - `revive` stutter renames: `blob.Handler`, `blob.WithReader`, `blob.ChunkPosition`, `storage.URL`, `storage.Info`; missing doc comments added - `contextcheck`/`noctx`: `context.Context` threaded through `blob.Packer` and the scanner call sites; context-aware `exec`/`sql` variants - `funlen`/`cyclop`/`gocognit`/`dupl`: oversized and duplicated functions split into focused helpers (production and test code) - tests: `t.Parallel()` added where safe (global logger init kept in the serial phase for `-race`), `t.TempDir()`/`t.Helper()` adopted, several suites converted to external test packages - `gosec`: bounded integer conversions, `ReadHeaderTimeout` on the test HTTP server; remaining warnings suppressed per-site with justifications - remaining `nolint` directives are rare, targeted, and each carries a reason (e.g. `nilnil` not-found contract in the repository layer, fx module globals, on-disk snake_case struct tags) - removed the deprecated `log.LogOptions` alias (callers migrated to `log.Options`) `make check` (tests with `-race`, lint, fmt-check) passes. Co-authored-by: sneak <sneak@sneak.berlin> Reviewed-on: #62 Co-authored-by: clawbot <clawbot@noreply.example.org> Co-committed-by: clawbot <clawbot@noreply.example.org>
2026-08-07 23:22:48 +02:00
parent b87b72d4b9
commit cc58583130
126 changed files with 8184 additions and 5470 deletions
--- a/internal/chunker/chunker.go
+++ b/internal/chunker/chunker.go
@@ -1,3 +1,6 @@
+// Package chunker splits input data into content-defined chunks using the
+// FastCDC algorithm so that identical data sequences produce identical
+// chunks regardless of their position in the file.
 package chunker

 import (
@@ -9,9 +12,10 @@ import (
 	"os"
 )

-// Chunk represents a single chunk of data produced by the content-defined chunking algorithm.
-// Each chunk is identified by its SHA256 hash and contains the raw data along with
-// its position and size information from the original file.
+// Chunk represents a single chunk of data produced by the content-defined
+// chunking algorithm. Each chunk is identified by its SHA256 hash and
+// contains the raw data along with its position and size information from
+// the original file.
 type Chunk struct {
 	Hash   string // Content hash of the chunk
 	Data   []byte // Chunk data
@@ -29,6 +33,10 @@ type Chunker struct {
 	maxChunkSize int
 }

+// chunkSizeSpread is the FastCDC-recommended factor between the average
+// chunk size and the minimum (avg/spread) and maximum (avg*spread) sizes.
+const chunkSizeSpread = 4
+
 // NewChunker creates a new chunker with the specified average chunk size.
 // The actual chunk sizes will vary between avgChunkSize/4 and avgChunkSize*4
 // as recommended by the FastCDC algorithm. Typical values for avgChunkSize
@@ -37,17 +45,19 @@ func NewChunker(avgChunkSize int64) *Chunker {
 	// FastCDC recommends min = avg/4 and max = avg*4
 	return &Chunker{
 		avgChunkSize: int(avgChunkSize),
-		minChunkSize: int(avgChunkSize / 4),
-		maxChunkSize: int(avgChunkSize * 4),
+		minChunkSize: int(avgChunkSize / chunkSizeSpread),
+		maxChunkSize: int(avgChunkSize * chunkSizeSpread),
 	}
 }

-// ChunkReader splits the reader into content-defined chunks and returns all chunks at once.
-// This method loads all chunk data into memory, so it should only be used for
-// reasonably sized inputs. For large files or streams, use ChunkReaderStreaming instead.
+// ChunkReader splits the reader into content-defined chunks and returns all
+// chunks at once. This method loads all chunk data into memory, so it should
+// only be used for reasonably sized inputs. For large files or streams, use
+// ChunkReaderStreaming instead.
 // Returns an error if chunking fails or if reading from the input fails.
 func (c *Chunker) ChunkReader(r io.Reader) ([]Chunk, error) {
-	chunker := AcquireReusableChunker(r, c.minChunkSize, c.avgChunkSize, c.maxChunkSize)
+	chunker := AcquireReusableChunker(
+		r, c.minChunkSize, c.avgChunkSize, c.maxChunkSize)
 	defer chunker.Release()

 	var chunks []Chunk
@@ -86,21 +96,26 @@ func (c *Chunker) ChunkReader(r io.Reader) ([]Chunk, error) {

 // ChunkCallback is a function called for each chunk as it's processed.
 // The callback receives a Chunk containing the hash, data, offset, and size.
-// If the callback returns an error, chunk processing stops and the error is propagated.
+// If the callback returns an error, chunk processing stops and the error is
+// propagated.
 type ChunkCallback func(chunk Chunk) error

-// ChunkReaderStreaming splits the reader into chunks and calls the callback for each chunk.
-// This is the preferred method for processing large files or streams as it doesn't
-// accumulate all chunks in memory. The callback is invoked for each chunk as it's
-// produced, allowing for streaming processing and immediate storage or transmission.
-// Returns the SHA256 hash of the entire file content and an error if chunking fails,
-// reading fails, or if the callback returns an error.
-func (c *Chunker) ChunkReaderStreaming(r io.Reader, callback ChunkCallback) (string, error) {
+// ChunkReaderStreaming splits the reader into chunks and calls the callback
+// for each chunk. This is the preferred method for processing large files or
+// streams as it doesn't accumulate all chunks in memory. The callback is
+// invoked for each chunk as it's produced, allowing for streaming processing
+// and immediate storage or transmission.
+// Returns the SHA256 hash of the entire file content and an error if
+// chunking fails, reading fails, or if the callback returns an error.
+func (c *Chunker) ChunkReaderStreaming(
+	r io.Reader, callback ChunkCallback,
+) (string, error) {
 	// Create a tee reader to calculate full file hash while chunking
 	fileHasher := sha256.New()
 	teeReader := io.TeeReader(r, fileHasher)

-	chunker := AcquireReusableChunker(teeReader, c.minChunkSize, c.avgChunkSize, c.maxChunkSize)
+	chunker := AcquireReusableChunker(
+		teeReader, c.minChunkSize, c.avgChunkSize, c.maxChunkSize)
 	defer chunker.Release()

 	offset := int64(0)
@@ -118,9 +133,10 @@ func (c *Chunker) ChunkReaderStreaming(r io.Reader, callback ChunkCallback) (str
 		// Calculate chunk hash
 		hash := sha256.Sum256(chunk.Data)

-		// Pass the data directly - caller must process it before we call Next() again
-		// (chunker reuses its internal buffer, but since we process synchronously
-		// and completely before continuing, no copy is needed)
+		// Pass the data directly - caller must process it before we call
+		// Next() again (chunker reuses its internal buffer, but since we
+		// process synchronously and completely before continuing, no copy
+		// is needed)
 		err = callback(Chunk{
 			Hash:   hex.EncodeToString(hash[:]),
 			Data:   chunk.Data,
@@ -143,7 +159,7 @@ func (c *Chunker) ChunkReaderStreaming(r io.Reader, callback ChunkCallback) (str
 // For large files, consider using ChunkReaderStreaming with a file handle instead.
 // Returns an error if the file cannot be opened or if chunking fails.
 func (c *Chunker) ChunkFile(path string) ([]Chunk, error) {
-	file, err := os.Open(path)
+	file, err := os.Open(path) //nolint:gosec // G304: path is caller-supplied by design
 	if err != nil {
 		return nil, fmt.Errorf("opening file: %w", err)
 	}
--- a/internal/chunker/chunker_isolated_test.go
+++ b/internal/chunker/chunker_isolated_test.go
@@ -1,11 +1,15 @@
-package chunker
+package chunker_test

 import (
 	"bytes"
 	"testing"
+
+	"sneak.berlin/go/vaultik/internal/chunker"
 )

 func TestChunkerExpectedChunkCount(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name         string
 		fileSize     int
@@ -38,16 +42,19 @@ func TestChunkerExpectedChunkCount(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			chunker := NewChunker(tt.avgChunkSize)
+			t.Parallel()
+
+			c := chunker.NewChunker(tt.avgChunkSize)

 			// Create data with some variation to trigger chunk boundaries
 			data := make([]byte, tt.fileSize)
 			for i := range data {
 				// Use a pattern that should create boundaries
+				//nolint:gosec // G115: intentional byte truncation
 				data[i] = byte((i * 17) ^ (i >> 5))
 			}

-			chunks, err := chunker.ChunkReader(bytes.NewReader(data))
+			chunks, err := c.ChunkReader(bytes.NewReader(data))
 			if err != nil {
 				t.Fatalf("chunking failed: %v", err)
 			}
--- a/internal/chunker/chunker_test.go
+++ b/internal/chunker/chunker_test.go
@@ -1,108 +1,120 @@
-package chunker
+package chunker_test

 import (
 	"bytes"
 	"crypto/rand"
 	"testing"
+
+	"sneak.berlin/go/vaultik/internal/chunker"
 )

-func TestChunker(t *testing.T) {
-	t.Run("small file produces single chunk", func(t *testing.T) {
-		chunker := NewChunker(1024 * 1024)         // 1MB average
-		data := bytes.Repeat([]byte("hello"), 100) // 500 bytes
+func TestChunkerSmallFileSingleChunk(t *testing.T) {
+	t.Parallel()

-		chunks, err := chunker.ChunkReader(bytes.NewReader(data))
-		if err != nil {
-			t.Fatalf("chunking failed: %v", err)
+	c := chunker.NewChunker(1024 * 1024)       // 1MB average
+	data := bytes.Repeat([]byte("hello"), 100) // 500 bytes
+
+	chunks, err := c.ChunkReader(bytes.NewReader(data))
+	if err != nil {
+		t.Fatalf("chunking failed: %v", err)
+	}
+
+	if len(chunks) != 1 {
+		t.Errorf("expected 1 chunk, got %d", len(chunks))
+	}
+
+	if chunks[0].Size != int64(len(data)) {
+		t.Errorf("expected chunk size %d, got %d", len(data), chunks[0].Size)
+	}
+}
+
+func TestChunkerLargeFileMultipleChunks(t *testing.T) {
+	t.Parallel()
+
+	c := chunker.NewChunker(256 * 1024) // 256KB average chunk size
+
+	// Generate 2MB of random data
+	data := make([]byte, 2*1024*1024)
+
+	_, err := rand.Read(data)
+	if err != nil {
+		t.Fatalf("failed to generate random data: %v", err)
+	}
+
+	chunks, err := c.ChunkReader(bytes.NewReader(data))
+	if err != nil {
+		t.Fatalf("chunking failed: %v", err)
+	}
+
+	// Should produce multiple chunks - with FastCDC we expect around 8
+	// chunks for 2MB with 256KB average
+	if len(chunks) < 4 || len(chunks) > 16 {
+		t.Errorf("expected 4-16 chunks, got %d", len(chunks))
+	}
+
+	// Verify chunks reconstruct original data
+	var reconstructed []byte
+	for _, chunk := range chunks {
+		reconstructed = append(reconstructed, chunk.Data...)
+	}
+
+	if !bytes.Equal(data, reconstructed) {
+		t.Error("reconstructed data doesn't match original")
+	}
+
+	// Verify offsets
+	var expectedOffset int64
+
+	for i, chunk := range chunks {
+		if chunk.Offset != expectedOffset {
+			t.Errorf("chunk %d: expected offset %d, got %d",
+				i, expectedOffset, chunk.Offset)
 		}

-		if len(chunks) != 1 {
-			t.Errorf("expected 1 chunk, got %d", len(chunks))
+		expectedOffset += chunk.Size
+	}
+}
+
+func TestChunkerDeterministic(t *testing.T) {
+	t.Parallel()
+
+	chunker1 := chunker.NewChunker(256 * 1024)
+	chunker2 := chunker.NewChunker(256 * 1024)
+
+	// Use deterministic data
+	data := bytes.Repeat([]byte("abcdefghijklmnopqrstuvwxyz"), 20000) // ~520KB
+
+	chunks1, err := chunker1.ChunkReader(bytes.NewReader(data))
+	if err != nil {
+		t.Fatalf("chunking failed: %v", err)
+	}
+
+	chunks2, err := chunker2.ChunkReader(bytes.NewReader(data))
+	if err != nil {
+		t.Fatalf("chunking failed: %v", err)
+	}
+
+	// Should produce same chunks
+	if len(chunks1) != len(chunks2) {
+		t.Fatalf("different number of chunks: %d vs %d",
+			len(chunks1), len(chunks2))
+	}
+
+	for i := range chunks1 {
+		if chunks1[i].Hash != chunks2[i].Hash {
+			t.Errorf("chunk %d: different hashes", i)
 		}

-		if chunks[0].Size != int64(len(data)) {
-			t.Errorf("expected chunk size %d, got %d", len(data), chunks[0].Size)
+		if chunks1[i].Size != chunks2[i].Size {
+			t.Errorf("chunk %d: different sizes", i)
 		}
-	})
-
-	t.Run("large file produces multiple chunks", func(t *testing.T) {
-		chunker := NewChunker(256 * 1024) // 256KB average chunk size
-
-		// Generate 2MB of random data
-		data := make([]byte, 2*1024*1024)
-
-		_, err := rand.Read(data)
-		if err != nil {
-			t.Fatalf("failed to generate random data: %v", err)
-		}
-
-		chunks, err := chunker.ChunkReader(bytes.NewReader(data))
-		if err != nil {
-			t.Fatalf("chunking failed: %v", err)
-		}
-
-		// Should produce multiple chunks - with FastCDC we expect around 8 chunks for 2MB with 256KB average
-		if len(chunks) < 4 || len(chunks) > 16 {
-			t.Errorf("expected 4-16 chunks, got %d", len(chunks))
-		}
-
-		// Verify chunks reconstruct original data
-		var reconstructed []byte
-		for _, chunk := range chunks {
-			reconstructed = append(reconstructed, chunk.Data...)
-		}
-
-		if !bytes.Equal(data, reconstructed) {
-			t.Error("reconstructed data doesn't match original")
-		}
-
-		// Verify offsets
-		var expectedOffset int64
-		for i, chunk := range chunks {
-			if chunk.Offset != expectedOffset {
-				t.Errorf("chunk %d: expected offset %d, got %d", i, expectedOffset, chunk.Offset)
-			}
-
-			expectedOffset += chunk.Size
-		}
-	})
-
-	t.Run("deterministic chunking", func(t *testing.T) {
-		chunker1 := NewChunker(256 * 1024)
-		chunker2 := NewChunker(256 * 1024)
-
-		// Use deterministic data
-		data := bytes.Repeat([]byte("abcdefghijklmnopqrstuvwxyz"), 20000) // ~520KB
-
-		chunks1, err := chunker1.ChunkReader(bytes.NewReader(data))
-		if err != nil {
-			t.Fatalf("chunking failed: %v", err)
-		}
-
-		chunks2, err := chunker2.ChunkReader(bytes.NewReader(data))
-		if err != nil {
-			t.Fatalf("chunking failed: %v", err)
-		}
-
-		// Should produce same chunks
-		if len(chunks1) != len(chunks2) {
-			t.Fatalf("different number of chunks: %d vs %d", len(chunks1), len(chunks2))
-		}
-
-		for i := range chunks1 {
-			if chunks1[i].Hash != chunks2[i].Hash {
-				t.Errorf("chunk %d: different hashes", i)
-			}
-
-			if chunks1[i].Size != chunks2[i].Size {
-				t.Errorf("chunk %d: different sizes", i)
-			}
-		}
-	})
+	}
 }

 func TestChunkBoundaries(t *testing.T) {
-	chunker := NewChunker(256 * 1024) // 256KB average
+	t.Parallel()
+
+	c := chunker.NewChunker(256 * 1024) // 256KB average

 	// FastCDC uses avg/4 for min and avg*4 for max
 	avgSize := int64(256 * 1024)
@@ -117,7 +129,7 @@ func TestChunkBoundaries(t *testing.T) {
 		t.Fatalf("failed to generate random data: %v", err)
 	}

-	chunks, err := chunker.ChunkReader(bytes.NewReader(data))
+	chunks, err := c.ChunkReader(bytes.NewReader(data))
 	if err != nil {
 		t.Fatalf("chunking failed: %v", err)
 	}
@@ -125,11 +137,13 @@ func TestChunkBoundaries(t *testing.T) {
 	for i, chunk := range chunks {
 		// Last chunk can be smaller than minimum
 		if i < len(chunks)-1 && chunk.Size < minSize {
-			t.Errorf("chunk %d size %d is below minimum %d", i, chunk.Size, minSize)
+			t.Errorf("chunk %d size %d is below minimum %d",
+				i, chunk.Size, minSize)
 		}

 		if chunk.Size > maxSize {
-			t.Errorf("chunk %d size %d exceeds maximum %d", i, chunk.Size, maxSize)
+			t.Errorf("chunk %d size %d exceeds maximum %d",
+				i, chunk.Size, maxSize)
 		}
 	}
 }
--- a/internal/chunker/fastcdc.go
+++ b/internal/chunker/fastcdc.go
@@ -28,6 +28,8 @@ type ReusableChunker struct {
 }

 // reusableChunkerPool pools ReusableChunker instances to avoid allocations.
+//
+//nolint:gochecknoglobals // process-wide object pool by design
 var reusableChunkerPool = sync.Pool{
 	New: func() any {
 		return &ReusableChunker{}
@@ -36,6 +38,8 @@ var reusableChunkerPool = sync.Pool{

 // bufferPools contains pools for different buffer sizes.
 // Key is the buffer size.
+//
+//nolint:gochecknoglobals // process-wide buffer pools by design
 var bufferPools = sync.Map{}

 func getBuffer(size int) []byte {
@@ -46,9 +50,18 @@ func getBuffer(size int) []byte {
 			return &buf
 		},
 	})
-	pool := poolI.(*sync.Pool)

-	return *pool.Get().(*[]byte)
+	pool, ok := poolI.(*sync.Pool)
+	if !ok {
+		panic("bufferPools holds a non-pool value")
+	}
+
+	buf, ok := pool.Get().(*[]byte)
+	if !ok {
+		panic("buffer pool holds a non-buffer value")
+	}
+
+	return *buf
 }

 func putBuffer(buf []byte) {
@@ -56,7 +69,11 @@ func putBuffer(buf []byte) {

 	poolI, ok := bufferPools.Load(size)
 	if ok {
-		pool := poolI.(*sync.Pool)
+		pool, isPool := poolI.(*sync.Pool)
+		if !isPool {
+			panic("bufferPools holds a non-pool value")
+		}
+
 		b := buf[:size]
 		pool.Put(&b)
 	}
@@ -70,11 +87,21 @@ type FastCDCChunk struct {
 	Fingerprint uint64
 }

-// AcquireReusableChunker gets a chunker from the pool and initializes it for the given reader.
-func AcquireReusableChunker(rd io.Reader, minSize, avgSize, maxSize int) *ReusableChunker {
-	c := reusableChunkerPool.Get().(*ReusableChunker)
+// bufSizeFactor sizes the internal read buffer relative to the maximum
+// chunk size so a full chunk plus read-ahead always fits.
+const bufSizeFactor = 2

-	bufSize := maxSize * 2
+// AcquireReusableChunker gets a chunker from the pool and initializes it
+// for the given reader.
+func AcquireReusableChunker(
+	rd io.Reader, minSize, avgSize, maxSize int,
+) *ReusableChunker {
+	c, ok := reusableChunkerPool.Get().(*ReusableChunker)
+	if !ok {
+		panic("reusableChunkerPool holds a non-chunker value")
+	}
+
+	bufSize := maxSize * bufSizeFactor

 	// Reuse buffer if it's the right size, otherwise get a new one
 	if c.buf == nil || cap(c.buf) != bufSize {
@@ -113,37 +140,6 @@ func (c *ReusableChunker) Release() {
 	reusableChunkerPool.Put(c)
 }

-func (c *ReusableChunker) fillBuffer() error {
-	n := len(c.buf) - c.cursor
-	if n >= c.maxSize {
-		return nil
-	}
-
-	// Move all data after the cursor to the start of the buffer
-	copy(c.buf[:n], c.buf[c.cursor:])
-	c.cursor = 0
-
-	if c.eof {
-		c.buf = c.buf[:n]
-
-		return nil
-	}
-
-	// Restore buffer to full capacity for reading
-	c.buf = c.buf[:c.bufSize]
-
-	// Fill the rest of the buffer
-	m, err := io.ReadFull(c.rd, c.buf[n:])
-	if err == io.EOF || errors.Is(err, io.ErrUnexpectedEOF) {
-		c.buf = c.buf[:n+m]
-		c.eof = true
-	} else if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // Next returns the next chunk or io.EOF when done.
 // The returned Data slice is only valid until the next call to Next.
 func (c *ReusableChunker) Next() (FastCDCChunk, error) {
@@ -171,6 +167,37 @@ func (c *ReusableChunker) Next() (FastCDCChunk, error) {
 	return chunk, nil
 }

+func (c *ReusableChunker) fillBuffer() error {
+	n := len(c.buf) - c.cursor
+	if n >= c.maxSize {
+		return nil
+	}
+
+	// Move all data after the cursor to the start of the buffer
+	copy(c.buf[:n], c.buf[c.cursor:])
+	c.cursor = 0
+
+	if c.eof {
+		c.buf = c.buf[:n]
+
+		return nil
+	}
+
+	// Restore buffer to full capacity for reading
+	c.buf = c.buf[:c.bufSize]
+
+	// Fill the rest of the buffer
+	m, err := io.ReadFull(c.rd, c.buf[n:])
+	if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+		c.buf = c.buf[:n+m]
+		c.eof = true
+	} else if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (c *ReusableChunker) nextChunk(data []byte) (int, uint64) {
 	fp := uint64(0)
 	i := c.minSize
@@ -199,6 +226,8 @@ func (c *ReusableChunker) nextChunk(data []byte) (int, uint64) {
 }

 // 256 random uint64s for the rolling hash function (from FastCDC paper)
+//
+//nolint:gochecknoglobals // immutable FastCDC gear lookup table
 var table = [256]uint64{
 	0xe80e8d55032474b3, 0x11b25b61f5924e15, 0x03aa5bd82a9eb669, 0xc45a153ef107a38c,
 	0xeac874b86f0f57b9, 0xa5ccedec95ec79c7, 0xe15a3320ad42ac0a, 0x5ed3583fa63cec15,