fix lint

Signed-off-by: Will Murphy <will.murphy@anchore.com>

syft/internal/unionreader/lazy_union_reader.go

@@ -0,0 +1,135 @@
+package unionreader
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"sync"
+)
+
+// lazyUnionReader must implement UnionReader
+var _ UnionReader = (*lazyUnionReader)(nil)
+
+// lazyUnionReader wraps an io.Reader to make it into a logical ReadSeeker
+// The reader maintains a []byte, which is everything that has been read so far.
+// Otherwise, callers needing a ReadSeeker might copy the entire reader into
+// a buffer in order to have a seeker.
+type lazyUnionReader struct {
+	buf    []byte        // the bytes that have been read so far
+	cursor int64         // the current position where Read() will take place
+	rc     io.ReadCloser // the underlying reader
+	mu     sync.Mutex    // exported methods must acquire this lock before changing any field. Unexported methods assume their caller acquired the lock
+}
+
+func (c *lazyUnionReader) Read(p []byte) (n int, err error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	needBytes := int64(len(p))
+	newOffset := c.cursor + needBytes
+	err = c.ensureReadUntil(newOffset)
+	if err != nil && !errors.Is(err, io.EOF) {
+		return 0, err
+	}
+	// stop reading either at cursor + length p, or the end of the underlying reader,
+	// whichever is sooner
+	end := min(c.cursor+int64(len(p)), int64(len(c.buf)))
+	copy(p, c.buf[c.cursor:end])
+	n = int(end - c.cursor)
+	c.cursor = end
+	return n, err
+}
+
+func (c *lazyUnionReader) ReadAt(p []byte, off int64) (n int, err error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	needUntil := int64(len(p)) + off
+	err = c.ensureReadUntil(needUntil)
+	end := min(off+int64(len(p)), int64(len(c.buf)))
+	start := min(off, c.maxRead())
+	if off > start {
+		return 0, io.EOF
+	}
+	copy(p, c.buf[start:end])
+	return int(end - start), err
+}
+
+func (c *lazyUnionReader) Seek(offset int64, whence int) (int64, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var trueOffset int64
+	var err error
+	switch whence {
+	case io.SeekStart:
+		trueOffset = offset
+	case io.SeekCurrent:
+		trueOffset = offset + c.cursor
+		err = c.ensureReadUntil(trueOffset)
+	case io.SeekEnd:
+		err = c.readAll()
+		trueOffset = c.maxRead() + offset
+	}
+	if err != nil {
+		return 0, err
+	}
+	if trueOffset < 0 {
+		return 0, fmt.Errorf("request to read negative offset impossible %v", trueOffset)
+	}
+	trueOffset = min(c.maxRead(), trueOffset)
+	c.cursor = trueOffset
+	return c.cursor, nil
+}
+
+func (c *lazyUnionReader) Close() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.rc.Close()
+}
+
+func (c *lazyUnionReader) readAll() error {
+	buf, err := io.ReadAll(c.rc)
+	switch {
+	case err != nil && errors.Is(err, io.EOF):
+		err = nil
+	case err != nil:
+		return err
+	}
+	c.buf = append(c.buf, buf...)
+	return err
+}
+
+func (c *lazyUnionReader) ensureReadUntil(offset int64) error {
+	readN := offset - c.maxRead()
+	if readN <= 0 {
+		return nil
+	}
+	var buf bytes.Buffer
+	_, err := io.CopyN(&buf, c.rc, readN)
+	if err != nil && !errors.Is(err, io.EOF) {
+		return err
+	}
+	c.buf = append(c.buf, buf.Bytes()...)
+	return err
+}
+
+func (c *lazyUnionReader) maxRead() int64 {
+	return int64(len(c.buf))
+}
+
+func min(ints ...int64) int64 {
+	minSeeen := int64(math.MaxInt64) // really? math.MaxInt64 has type int?
+	for _, n := range ints {
+		if n < minSeeen {
+			minSeeen = n
+		}
+	}
+	return minSeeen
+}
+
+func newLazyUnionReader(readCloser io.ReadCloser) UnionReader {
+	return &lazyUnionReader{
+		rc: readCloser,
+		mu: sync.Mutex{},
+	}
+}

syft/internal/unionreader/lazy_union_reader_test.go

@@ -0,0 +1,212 @@
+package unionreader
+
+import (
+	"bytes"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type spyingCloser struct {
+	closed bool
+	io.Reader
+}
+
+func (s *spyingCloser) Close() error {
+	s.closed = true
+	return nil
+}
+
+func Test_lazyUnionReader_Close(t *testing.T) {
+	r := strings.NewReader("some string")
+	sc := &spyingCloser{
+		false,
+		r,
+	}
+	subject := newLazyUnionReader(sc)
+	require.NoError(t, subject.Close())
+	assert.True(t, sc.closed)
+}
+
+func Test_lazyUnionReader_ReadAll(t *testing.T) {
+	rc := io.NopCloser(strings.NewReader("some data"))
+	subject := newLazyUnionReader(rc)
+
+	b, err := io.ReadAll(subject)
+	require.NoError(t, err)
+	assert.Equal(t, "some data", string(b))
+}
+
+func Test_lazyUnionReader_RepeatedlyRead(t *testing.T) {
+	data := "some data for our reader that we need to read!"
+	rc := io.NopCloser(strings.NewReader(data))
+	subject := newLazyUnionReader(rc)
+	var readErr error
+	var readResult []byte
+	for readErr == nil {
+		buf := make([]byte, 2)
+		var n int
+		n, readErr = subject.Read(buf)
+		readResult = append(readResult, buf[:n]...)
+	}
+	assert.Equal(t, data, string(readResult))
+	assert.ErrorIs(t, readErr, io.EOF)
+}
+
+func Test_lazyUnionReader_ReadAt(t *testing.T) {
+	readStart := make([]byte, 4)
+	readMid := make([]byte, 4)
+	readEnd := make([]byte, 4)
+	tests := []struct {
+		name      string
+		dst       []byte
+		off       int64
+		wantN     int
+		wantBytes []byte
+		wantEOF   bool
+	}{
+		{
+			name:      "read first 4 bytes",
+			dst:       readStart,
+			off:       0,
+			wantN:     4,
+			wantBytes: []byte("0123"),
+		},
+		{
+			name:      "read 4 bytes from middle",
+			dst:       readMid,
+			off:       4,
+			wantN:     4,
+			wantBytes: []byte("4567"),
+		},
+		{
+			name:      "read last 4 bytes",
+			dst:       readEnd,
+			off:       12,
+			wantN:     4,
+			wantBytes: []byte("cdef"),
+		},
+		{
+			name:      "read past end",
+			dst:       make([]byte, 4),
+			off:       14,
+			wantN:     2,
+			wantBytes: []byte("ef"),
+			wantEOF:   true,
+		},
+		{
+			name:    "read way out of bounds",
+			dst:     make([]byte, 4),
+			off:     512,
+			wantN:   0,
+			wantEOF: true,
+		},
+		{
+			name:      "buffer more than available",
+			dst:       make([]byte, 512),
+			off:       0,
+			wantN:     16,
+			wantBytes: []byte("0123456789abcdef"),
+			wantEOF:   true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			rc := io.NopCloser(strings.NewReader("0123456789abcdef"))
+			subject := newLazyUnionReader(rc)
+			n, err := subject.ReadAt(tt.dst, tt.off)
+			assert.Equal(t, tt.wantN, n)
+			assert.Equal(t, string(tt.wantBytes), string(tt.dst[:tt.wantN]))
+			if tt.wantEOF {
+				assert.ErrorIs(t, err, io.EOF)
+			}
+		})
+	}
+}
+
+func Test_lazyUnionReader_Seek(t *testing.T) {
+	//const seek = 0
+	//const read = 1
+	type command struct {
+		seekOffset int64
+		seekWhence int
+		readDst    []byte
+	}
+	data := []byte("this is a string of data that I'm very excited to share")
+	tests := []struct {
+		name      string
+		commands  []command
+		wantBytes []byte
+		wantEOF   bool
+	}{
+		{
+			name: "read the first 4 bytes twice",
+			commands: []command{
+				{
+					readDst: make([]byte, 4),
+				},
+				{
+					seekOffset: 0,
+					seekWhence: io.SeekStart,
+				},
+				{
+					readDst: make([]byte, 4),
+				},
+			},
+			wantBytes: []byte("thisthis"),
+		},
+		{
+			name: "read the last 4 bytes twice",
+			commands: []command{
+				{
+					seekWhence: io.SeekEnd,
+					seekOffset: -4,
+				},
+				{
+					readDst: make([]byte, 4),
+				},
+				{
+					seekWhence: io.SeekEnd,
+					seekOffset: -4,
+				},
+				{
+					readDst: make([]byte, 4),
+				},
+			},
+			wantBytes: []byte("harehare"),
+		},
+		{
+			name: "read 4, skip 4, read 4",
+			commands: []command{
+				{readDst: make([]byte, 4)},
+				{seekOffset: 4, seekWhence: io.SeekCurrent},
+				{readDst: make([]byte, 4)},
+			},
+			wantBytes: []byte("thisa st"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			rc := io.NopCloser(bytes.NewReader(data))
+			subject := newLazyUnionReader(rc)
+			var readSeekErr error
+			var readResult []byte
+			for _, c := range tt.commands {
+				var n int
+				if len(c.readDst) > 0 {
+					n, readSeekErr = subject.Read(c.readDst)
+					readResult = append(readResult, c.readDst[:n]...)
+				} else {
+					_, readSeekErr = subject.Seek(c.seekOffset, c.seekWhence)
+				}
+			}
+			if tt.wantEOF {
+				assert.ErrorIs(t, readSeekErr, io.EOF)
+			}
+			assert.Equal(t, string(tt.wantBytes), string(readResult))
+		})
+	}
+}

syft/internal/unionreader/union_reader.go

@@ -1,8 +1,6 @@
 package unionreader
 
 import (
-	"bytes"
-	"fmt"
 	"io"
 
 	macho "github.com/anchore/go-macholibre"
@@ -43,23 +41,5 @@ func GetUnionReader(readerCloser io.ReadCloser) (UnionReader, error) {
 	if ok {
 		return reader, nil
 	}
-
-	b, err := io.ReadAll(readerCloser)
-	if err != nil {
-		return nil, fmt.Errorf("unable to read contents from binary: %w", err)
-	}
-
-	bytesReader := bytes.NewReader(b)
-
-	reader = struct {
-		io.ReadCloser
-		io.ReaderAt
-		io.Seeker
-	}{
-		ReadCloser: io.NopCloser(bytesReader),
-		ReaderAt:   bytesReader,
-		Seeker:     bytesReader,
-	}
-
-	return reader, nil
+	return newLazyUnionReader(readerCloser), nil
 }