Potential workaround for poor zstd performance

Performance is still not great, but better

internal/decompress/gzip.go

@@ -11,3 +11,9 @@ type GZip struct{}
 func (g GZip) Reader(src io.Reader) (io.ReadCloser, error) {
 	return zlib.NewReader(src)
 }
+
+func (g GZip) Resetable() bool { return true }
+
+func (g GZip) Reset(old, src io.Reader) error {
+	return old.(zlib.Resetter).Reset(src, nil)
+}

internal/decompress/interface.go

@@ -1,7 +1,19 @@
 package decompress
 
-import "io"
+import (
+	"errors"
+	"io"
+)
+
+var ErrNotResetable = errors.New("decompressor not resetable")
 
 type Decompressor interface {
+	//Creates a new decompressor reading from src.
 	Reader(src io.Reader) (io.ReadCloser, error)
+	//Reports whether Reset will work or not.
+	Resetable() bool
+	//Reset attempts to re-use an old decompressor with new data.
+	//Will return ErrNotResetable if not Resetable().
+	//Must ALWAYS be provided with a reader created with Reader.
+	Reset(old, src io.Reader) error
 }

internal/decompress/lz4.go

@@ -11,3 +11,10 @@ type Lz4 struct{}
 func (l Lz4) Reader(r io.Reader) (io.ReadCloser, error) {
 	return io.NopCloser(lz4.NewReader(r)), nil
 }
+
+func (l Lz4) Resetable() bool { return true }
+
+func (l Lz4) Reset(old, src io.Reader) error {
+	old.(*lz4.Reader).Reset(src)
+	return nil
+}

internal/decompress/lzma.go

@@ -12,3 +12,7 @@ func (l Lzma) Reader(r io.Reader) (io.ReadCloser, error) {
 	rdr, err := lzma.NewReader(r)
 	return io.NopCloser(rdr), err
 }
+
+func (l Lzma) Resetable() bool { return false }
+
+func (l Lzma) Reset(old, src io.Reader) error { return ErrNotResetable }

internal/decompress/lzo.go

@@ -16,3 +16,7 @@ func (l Lzo) Reader(r io.Reader) (io.ReadCloser, error) {
 	}
 	return io.NopCloser(bytes.NewReader(cache)), nil
 }
+
+func (l Lzo) Resetable() bool { return false }
+
+func (l Lzo) Reset(old, src io.Reader) error { return ErrNotResetable }

internal/decompress/xz.go

@@ -12,3 +12,9 @@ func (x Xz) Reader(r io.Reader) (io.ReadCloser, error) {
 	rdr, err := xz.NewReader(r, 0)
 	return io.NopCloser(rdr), err
 }
+
+func (x Xz) Resetable() bool { return true }
+
+func (x Xz) Reset(old, src io.Reader) error {
+	return old.(*xz.Reader).Reset(src)
+}

internal/decompress/zstd.go

@@ -1,31 +1,29 @@
 package decompress
 
 import (
-	"bytes"
 	"io"
 
 	"github.com/klauspost/compress/zstd"
 )
 
-type Zstd struct{}
+type Zstd struct {
+	writeToReader *zstd.Decoder
+}
 
 func (z Zstd) Reader(src io.Reader) (io.ReadCloser, error) {
 	r, err := zstd.NewReader(src)
 	return r.IOReadCloser(), err
 }
 
-type ZstdDecodeAll struct {
-	rdr *zstd.Decoder
+func (z Zstd) Resetable() bool { return true }
+
+func (z Zstd) Reset(old, src io.Reader) error {
+	return old.(*zstd.Decoder).Reset(src)
 }
 
-func (z *ZstdDecodeAll) Reader(src io.Reader) (io.ReadCloser, error) {
-	if z.rdr == nil {
-		z.rdr, _ = zstd.NewReader(nil)
+func (z *Zstd) Decode(in []byte) (out []byte, err error) {
+	if z.writeToReader == nil {
+		z.writeToReader, _ = zstd.NewReader(nil)
 	}
-	data, err := io.ReadAll(src)
-	if err != nil {
-		return nil, err
-	}
-	out, err := z.rdr.DecodeAll(data, nil)
-	return io.NopCloser(bytes.NewReader(out)), err
+	return z.writeToReader.DecodeAll(in, nil)
 }