1.4.5.2

EdgeNode/internal/compressions/cbrotli/cgo.go

@@ -0,0 +1,14 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+//
+// Distributed under MIT license.
+// See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+
+package cbrotli
+
+// Inform golang build system that it should link brotli libraries.
+
+// #cgo CFLAGS: -O2
+// #cgo LDFLAGS: -lbrotlicommon
+// #cgo LDFLAGS: -lbrotlidec
+// #cgo LDFLAGS: -lbrotlienc
+import "C"

EdgeNode/internal/compressions/cbrotli/reader.go

@@ -0,0 +1,163 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Distributed under MIT license.
+// See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+
+// Package cbrotli compresses and decompresses data with C-Brotli library.
+package cbrotli
+
+/*
+#include <stddef.h>
+#include <stdint.h>
+
+#include <brotli/decode.h>
+
+static BrotliDecoderResult DecompressStream(BrotliDecoderState* s,
+                                            uint8_t* out, size_t out_len,
+                                            const uint8_t* in, size_t in_len,
+                                            size_t* bytes_written,
+                                            size_t* bytes_consumed) {
+  size_t in_remaining = in_len;
+  size_t out_remaining = out_len;
+  BrotliDecoderResult result = BrotliDecoderDecompressStream(
+      s, &in_remaining, &in, &out_remaining, &out, NULL);
+  *bytes_written = out_len - out_remaining;
+  *bytes_consumed = in_len - in_remaining;
+  return result;
+}
+*/
+import "C"
+
+import (
+	"bytes"
+	"errors"
+	"io"
+)
+
+type decodeError C.BrotliDecoderErrorCode
+
+func (err decodeError) Error() string {
+	return "cbrotli: " +
+		C.GoString(C.BrotliDecoderErrorString(C.BrotliDecoderErrorCode(err)))
+}
+
+var errExcessiveInput = errors.New("cbrotli: excessive input")
+var errInvalidState = errors.New("cbrotli: invalid state")
+var errReaderClosed = errors.New("cbrotli: Reader is closed")
+
+// Reader implements io.ReadCloser by reading Brotli-encoded data from an
+// underlying Reader.
+type Reader struct {
+	src   io.Reader
+	state *C.BrotliDecoderState
+	buf   []byte // scratch space for reading from src
+	in    []byte // current chunk to decode; usually aliases buf
+}
+
+// readBufSize is a "good" buffer size that avoids excessive round-trips
+// between C and Go but doesn't waste too much memory on buffering.
+// It is arbitrarily chosen to be equal to the constant used in io.Copy.
+const readBufSize = 32 * 1024
+
+// NewReader initializes new Reader instance.
+// Close MUST be called to free resources.
+func NewReader(src io.Reader) *Reader {
+	return &Reader{
+		src:   src,
+		state: C.BrotliDecoderCreateInstance(nil, nil, nil),
+		buf:   make([]byte, readBufSize),
+	}
+}
+
+// Close implements io.Closer. Close MUST be invoked to free native resources.
+func (r *Reader) Close() error {
+	if r.state == nil {
+		return errReaderClosed
+	}
+	// Close despite the state; i.e. there might be some unread decoded data.
+	C.BrotliDecoderDestroyInstance(r.state)
+	r.state = nil
+	return nil
+}
+
+func (r *Reader) Read(p []byte) (n int, err error) {
+	if r.state == nil {
+		return 0, errReaderClosed
+	}
+	if int(C.BrotliDecoderHasMoreOutput(r.state)) == 0 && len(r.in) == 0 {
+		m, readErr := r.src.Read(r.buf)
+		if m == 0 {
+			// If readErr is `nil`, we just proxy underlying stream behavior.
+			return 0, readErr
+		}
+		r.in = r.buf[:m]
+	}
+
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	for {
+		var written, consumed C.size_t
+		var data *C.uint8_t
+		if len(r.in) != 0 {
+			data = (*C.uint8_t)(&r.in[0])
+		}
+		result := C.DecompressStream(r.state,
+			(*C.uint8_t)(&p[0]), C.size_t(len(p)),
+			data, C.size_t(len(r.in)),
+			&written, &consumed)
+		r.in = r.in[int(consumed):]
+		n = int(written)
+
+		switch result {
+		case C.BROTLI_DECODER_RESULT_SUCCESS:
+			if len(r.in) > 0 {
+				return n, errExcessiveInput
+			}
+			return n, nil
+		case C.BROTLI_DECODER_RESULT_ERROR:
+			return n, decodeError(C.BrotliDecoderGetErrorCode(r.state))
+		case C.BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:
+			if n == 0 {
+				return 0, io.ErrShortBuffer
+			}
+			return n, nil
+		case C.BROTLI_DECODER_NEEDS_MORE_INPUT:
+		}
+
+		if len(r.in) != 0 {
+			return 0, errInvalidState
+		}
+
+		// Calling r.src.Read may block. Don't block if we have data to return.
+		if n > 0 {
+			return n, nil
+		}
+
+		// Top off the buffer.
+		encN, err := r.src.Read(r.buf)
+		if encN == 0 {
+			// Not enough data to complete decoding.
+			if err == io.EOF {
+				return 0, io.ErrUnexpectedEOF
+			}
+			return 0, err
+		}
+		r.in = r.buf[:encN]
+	}
+
+	return n, nil
+}
+
+// Decode decodes Brotli encoded data.
+func Decode(encodedData []byte) ([]byte, error) {
+	r := &Reader{
+		src:   bytes.NewReader(nil),
+		state: C.BrotliDecoderCreateInstance(nil, nil, nil),
+		buf:   make([]byte, 4), // arbitrarily small but nonzero so that r.src.Read returns io.EOF
+		in:    encodedData,
+	}
+	defer r.Close()
+	return io.ReadAll(r)
+}

EdgeNode/internal/compressions/cbrotli/writer.go

@@ -0,0 +1,162 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Distributed under MIT license.
+// See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+
+package cbrotli
+
+/*
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <brotli/encode.h>
+
+struct CompressStreamResult {
+  size_t bytes_consumed;
+  const uint8_t* output_data;
+  size_t output_data_size;
+  int success;
+  int has_more;
+};
+
+static struct CompressStreamResult CompressStream(
+    BrotliEncoderState* s, BrotliEncoderOperation op,
+    const uint8_t* data, size_t data_size) {
+  struct CompressStreamResult result;
+  size_t available_in = data_size;
+  const uint8_t* next_in = data;
+  size_t available_out = 0;
+  result.success = BrotliEncoderCompressStream(s, op,
+      &available_in, &next_in, &available_out, 0, 0) ? 1 : 0;
+  result.bytes_consumed = data_size - available_in;
+  result.output_data = 0;
+  result.output_data_size = 0;
+  if (result.success) {
+    result.output_data = BrotliEncoderTakeOutput(s, &result.output_data_size);
+  }
+  result.has_more = BrotliEncoderHasMoreOutput(s) ? 1 : 0;
+  return result;
+}
+*/
+import "C"
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"unsafe"
+)
+
+// WriterOptions configures Writer.
+type WriterOptions struct {
+	// Quality controls the compression-speed vs compression-density trade-offs.
+	// The higher the quality, the slower the compression. Range is 0 to 11.
+	Quality int
+	// LGWin is the base 2 logarithm of the sliding window size.
+	// Range is 10 to 24. 0 indicates automatic configuration based on Quality.
+	LGWin int
+}
+
+// Writer implements io.WriteCloser by writing Brotli-encoded data to an
+// underlying Writer.
+type Writer struct {
+	dst   io.Writer
+	state *C.BrotliEncoderState
+}
+
+var (
+	errEncode       = errors.New("cbrotli: encode error")
+	errWriterClosed = errors.New("cbrotli: Writer is closed")
+)
+
+// NewWriter initializes new Writer instance.
+// Close MUST be called to free resources.
+func NewWriter(dst io.Writer, options WriterOptions) *Writer {
+	state := C.BrotliEncoderCreateInstance(nil, nil, nil)
+	C.BrotliEncoderSetParameter(
+		state, C.BROTLI_PARAM_QUALITY, (C.uint32_t)(options.Quality))
+	if options.LGWin > 0 {
+		C.BrotliEncoderSetParameter(
+			state, C.BROTLI_PARAM_LGWIN, (C.uint32_t)(options.LGWin))
+	}
+	return &Writer{
+		dst:   dst,
+		state: state,
+	}
+}
+
+func (w *Writer) writeChunk(p []byte, op C.BrotliEncoderOperation) (n int, err error) {
+	if w.state == nil {
+		return 0, errWriterClosed
+	}
+
+	for {
+		var data *C.uint8_t
+		if len(p) != 0 {
+			data = (*C.uint8_t)(&p[0])
+		}
+		result := C.CompressStream(w.state, op, data, C.size_t(len(p)))
+		if result.success == 0 {
+			return n, errEncode
+		}
+		p = p[int(result.bytes_consumed):]
+		n += int(result.bytes_consumed)
+
+		length := int(result.output_data_size)
+		if length != 0 {
+			// It is a workaround for non-copying-wrapping of native memory.
+			// C-encoder never pushes output block longer than ((2 << 25) + 502).
+			// TODO(eustas): use natural wrapper, when it becomes available, see
+			//               https://golang.org/issue/13656.
+			output := (*[1 << 30]byte)(unsafe.Pointer(result.output_data))[:length:length]
+			_, err = w.dst.Write(output)
+			if err != nil {
+				return n, err
+			}
+		}
+		if len(p) == 0 && result.has_more == 0 {
+			return n, nil
+		}
+	}
+}
+
+// Flush outputs encoded data for all input provided to Write. The resulting
+// output can be decoded to match all input before Flush, but the stream is
+// not yet complete until after Close.
+// Flush has a negative impact on compression.
+func (w *Writer) Flush() error {
+	_, err := w.writeChunk(nil, C.BROTLI_OPERATION_FLUSH)
+	return err
+}
+
+// Close flushes remaining data to the decorated writer and frees C resources.
+func (w *Writer) Close() error {
+	if w.state == nil {
+		return nil
+	}
+
+	// If stream is already closed, it is reported by `writeChunk`.
+	_, err := w.writeChunk(nil, C.BROTLI_OPERATION_FINISH)
+	// C-Brotli tolerates `nil` pointer here.
+	C.BrotliEncoderDestroyInstance(w.state)
+	w.state = nil
+	return err
+}
+
+// Write implements io.Writer. Flush or Close must be called to ensure that the
+// encoded bytes are actually flushed to the underlying Writer.
+func (w *Writer) Write(p []byte) (n int, err error) {
+	return w.writeChunk(p, C.BROTLI_OPERATION_PROCESS)
+}
+
+// Encode returns content encoded with Brotli.
+func Encode(content []byte, options WriterOptions) ([]byte, error) {
+	var buf bytes.Buffer
+	writer := NewWriter(&buf, options)
+	_, err := writer.Write(content)
+	if closeErr := writer.Close(); err == nil {
+		err = closeErr
+	}
+	return buf.Bytes(), err
+}

EdgeNode/internal/compressions/errors.go

@@ -0,0 +1,14 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package compressions
+
+import "errors"
+
+var ErrIsBusy = errors.New("the system is busy for compression")
+
+func CanIgnore(err error) bool {
+	if err == nil {
+		return true
+	}
+	return errors.Is(err, ErrIsBusy)
+}

EdgeNode/internal/compressions/reader.go

@@ -0,0 +1,16 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import "io"
+
+type Reader interface {
+	Read(p []byte) (n int, err error)
+	Reset(reader io.Reader) error
+	RawClose() error
+	Close() error
+	IncreaseHit() uint32
+
+	SetPool(pool *ReaderPool)
+	ResetFinish()
+}

EdgeNode/internal/compressions/reader_base.go

@@ -0,0 +1,36 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import "sync/atomic"
+
+type BaseReader struct {
+	pool *ReaderPool
+
+	isFinished bool
+	hits       uint32
+}
+
+func (this *BaseReader) SetPool(pool *ReaderPool) {
+	this.pool = pool
+}
+
+func (this *BaseReader) Finish(obj Reader) error {
+	if this.isFinished {
+		return nil
+	}
+	err := obj.RawClose()
+	if err == nil && this.pool != nil {
+		this.pool.Put(obj)
+	}
+	this.isFinished = true
+	return err
+}
+
+func (this *BaseReader) ResetFinish() {
+	this.isFinished = false
+}
+
+func (this *BaseReader) IncreaseHit() uint32 {
+	return atomic.AddUint32(&this.hits, 1)
+}

EdgeNode/internal/compressions/reader_brotli.go

@@ -0,0 +1,44 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+//go:build !plus || !linux
+
+package compressions
+
+import (
+	"github.com/andybalholm/brotli"
+	"io"
+	"strings"
+)
+
+type BrotliReader struct {
+	BaseReader
+
+	reader *brotli.Reader
+}
+
+func NewBrotliReader(reader io.Reader) (Reader, error) {
+	return sharedBrotliReaderPool.Get(reader)
+}
+
+func newBrotliReader(reader io.Reader) (Reader, error) {
+	return &BrotliReader{reader: brotli.NewReader(reader)}, nil
+}
+
+func (this *BrotliReader) Read(p []byte) (n int, err error) {
+	n, err = this.reader.Read(p)
+	if err != nil && strings.Contains(err.Error(), "excessive") {
+		err = io.EOF
+	}
+	return
+}
+
+func (this *BrotliReader) Reset(reader io.Reader) error {
+	return this.reader.Reset(reader)
+}
+
+func (this *BrotliReader) RawClose() error {
+	return nil
+}
+
+func (this *BrotliReader) Close() error {
+	return this.Finish(this)
+}

EdgeNode/internal/compressions/reader_brotli_plus.go

@@ -0,0 +1,48 @@
+// Copyright 2023 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+//go:build plus && linux
+
+package compressions
+
+import (
+	"github.com/TeaOSLab/EdgeNode/internal/compressions/cbrotli"
+	"io"
+	"strings"
+)
+
+type BrotliReader struct {
+	BaseReader
+
+	reader *cbrotli.Reader
+}
+
+func NewBrotliReader(reader io.Reader) (Reader, error) {
+	return sharedBrotliReaderPool.Get(reader)
+}
+
+func newBrotliReader(reader io.Reader) (Reader, error) {
+	return &BrotliReader{reader: cbrotli.NewReader(reader)}, nil
+}
+
+func (this *BrotliReader) Read(p []byte) (n int, err error) {
+	n, err = this.reader.Read(p)
+	if err != nil && strings.Contains(err.Error(), "excessive") {
+		err = io.EOF
+	}
+	return
+}
+
+func (this *BrotliReader) Reset(reader io.Reader) error {
+	if reader == nil {
+		return nil
+	}
+	this.reader = cbrotli.NewReader(reader)
+	return nil
+}
+
+func (this *BrotliReader) RawClose() error {
+	return this.reader.Close()
+}
+
+func (this *BrotliReader) Close() error {
+	return this.Finish(this)
+}

EdgeNode/internal/compressions/reader_brotli_test.go

@@ -0,0 +1,94 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"io"
+	"os"
+	"testing"
+)
+
+func TestBrotliReader(t *testing.T) {
+	for _, testString := range []string{"Hello", "World", "Ni", "Hao"} {
+		t.Log("===", testString, "===")
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewBrotliWriter(buf, 5)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = writer.Write([]byte(testString))
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = writer.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		reader, err := compressions.NewBrotliReader(buf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var data = make([]byte, 4096)
+		for {
+			n, err := reader.Read(data)
+			if n > 0 {
+				t.Log(string(data[:n]))
+			}
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				t.Fatal(err)
+			}
+		}
+		err = reader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkBrotliReader(b *testing.B) {
+	data, err := os.ReadFile("./reader_brotli.go")
+	if err != nil {
+		b.Fatal(err)
+	}
+	var buf = bytes.NewBuffer([]byte{})
+	writer, err := compressions.NewBrotliWriter(buf, 5)
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = writer.Write(data)
+	err = writer.Close()
+	if err != nil {
+		b.Fatal(err)
+	}
+	var compressedData = buf.Bytes()
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			reader, readerErr := compressions.NewBrotliReader(bytes.NewBuffer(compressedData))
+			if readerErr != nil {
+				b.Fatal(readerErr)
+			}
+			var readBuf = make([]byte, 1024)
+			for {
+				_, readErr := reader.Read(readBuf)
+				if readErr != nil {
+					if readErr != io.EOF {
+						b.Fatal(readErr)
+					}
+					break
+				}
+			}
+			closeErr := reader.Close()
+			if closeErr != nil {
+				b.Fatal(closeErr)
+			}
+		}
+	})
+}

EdgeNode/internal/compressions/reader_deflate.go

@@ -0,0 +1,39 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"compress/flate"
+	"io"
+)
+
+type DeflateReader struct {
+	BaseReader
+
+	reader io.ReadCloser
+}
+
+func NewDeflateReader(reader io.Reader) (Reader, error) {
+	return sharedDeflateReaderPool.Get(reader)
+}
+
+func newDeflateReader(reader io.Reader) (Reader, error) {
+	return &DeflateReader{reader: flate.NewReader(reader)}, nil
+}
+
+func (this *DeflateReader) Read(p []byte) (n int, err error) {
+	return this.reader.Read(p)
+}
+
+func (this *DeflateReader) Reset(reader io.Reader) error {
+	this.reader = flate.NewReader(reader)
+	return nil
+}
+
+func (this *DeflateReader) RawClose() error {
+	return this.reader.Close()
+}
+
+func (this *DeflateReader) Close() error {
+	return this.Finish(this)
+}

EdgeNode/internal/compressions/reader_deflate_test.go

@@ -0,0 +1,51 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"io"
+	"testing"
+)
+
+func TestDeflateReader(t *testing.T) {
+	for _, testString := range []string{"Hello", "World", "Ni", "Hao"} {
+		t.Log("===", testString, "===")
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewDeflateWriter(buf, 5)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = writer.Write([]byte(testString))
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = writer.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		reader, err := compressions.NewDeflateReader(buf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var data = make([]byte, 4096)
+		for {
+			n, err := reader.Read(data)
+			if n > 0 {
+				t.Log(string(data[:n]))
+			}
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				t.Fatal(err)
+			}
+		}
+		err = reader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}

EdgeNode/internal/compressions/reader_gzip.go

@@ -0,0 +1,44 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"github.com/klauspost/compress/gzip"
+	"io"
+)
+
+type GzipReader struct {
+	BaseReader
+
+	reader *gzip.Reader
+}
+
+func NewGzipReader(reader io.Reader) (Reader, error) {
+	return sharedGzipReaderPool.Get(reader)
+}
+
+func newGzipReader(reader io.Reader) (Reader, error) {
+	r, err := gzip.NewReader(reader)
+	if err != nil {
+		return nil, err
+	}
+	return &GzipReader{
+		reader: r,
+	}, nil
+}
+
+func (this *GzipReader) Read(p []byte) (n int, err error) {
+	return this.reader.Read(p)
+}
+
+func (this *GzipReader) Reset(reader io.Reader) error {
+	return this.reader.Reset(reader)
+}
+
+func (this *GzipReader) RawClose() error {
+	return this.reader.Close()
+}
+
+func (this *GzipReader) Close() error {
+	return this.Finish(this)
+}

EdgeNode/internal/compressions/reader_gzip_test.go

@@ -0,0 +1,106 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"github.com/iwind/TeaGo/rands"
+	"github.com/iwind/TeaGo/types"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestGzipReader(t *testing.T) {
+	for _, testString := range []string{"Hello", "World", "Ni", "Hao"} {
+		t.Log("===", testString, "===")
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewGzipWriter(buf, 5)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = writer.Write([]byte(testString))
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = writer.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		reader, err := compressions.NewGzipReader(buf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var data = make([]byte, 4096)
+		for {
+			n, err := reader.Read(data)
+			if n > 0 {
+				t.Log(string(data[:n]))
+			}
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				t.Fatal(err)
+			}
+		}
+		err = reader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkGzipReader(b *testing.B) {
+	var randomData = func() []byte {
+		var b = strings.Builder{}
+		for i := 0; i < 1024; i++ {
+			b.WriteString(types.String(rands.Int64() % 10))
+		}
+		return []byte(b.String())
+	}
+
+	var buf = &bytes.Buffer{}
+	writer, err := compressions.NewGzipWriter(buf, 5)
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = writer.Write(randomData())
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		var newBytes = make([]byte, buf.Len())
+		copy(newBytes, buf.Bytes())
+		reader, err := compressions.NewGzipReader(bytes.NewReader(newBytes))
+		if err != nil {
+			b.Fatal(err)
+		}
+		var data = make([]byte, 4096)
+		for {
+			n, err := reader.Read(data)
+			if n > 0 {
+				_ = data[:n]
+			}
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				b.Fatal(err)
+			}
+		}
+		err = reader.Close()
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

EdgeNode/internal/compressions/reader_pool.go

@@ -0,0 +1,63 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"io"
+)
+
+const maxReadHits = 1 << 20
+
+type ReaderPool struct {
+	c       chan Reader
+	newFunc func(reader io.Reader) (Reader, error)
+}
+
+func NewReaderPool(maxSize int, newFunc func(reader io.Reader) (Reader, error)) *ReaderPool {
+	if maxSize <= 0 {
+		maxSize = 1024
+	}
+
+	return &ReaderPool{
+		c:       make(chan Reader, maxSize),
+		newFunc: newFunc,
+	}
+}
+
+func (this *ReaderPool) Get(parentReader io.Reader) (Reader, error) {
+	select {
+	case reader := <-this.c:
+		err := reader.Reset(parentReader)
+		if err != nil {
+			// create new
+			reader, err = this.newFunc(parentReader)
+			if err != nil {
+				return nil, err
+			}
+			reader.SetPool(this)
+			return reader, nil
+		}
+		reader.ResetFinish()
+		return reader, nil
+	default:
+		// create new
+		reader, err := this.newFunc(parentReader)
+		if err != nil {
+			return nil, err
+		}
+		reader.SetPool(this)
+		return reader, nil
+	}
+}
+
+func (this *ReaderPool) Put(reader Reader) {
+	if reader.IncreaseHit() > maxReadHits {
+		// do nothing to discard it
+		return
+	}
+
+	select {
+	case this.c <- reader:
+	default:
+	}
+}

EdgeNode/internal/compressions/reader_pool_brotli.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedBrotliReaderPool *ReaderPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedBrotliReaderPool = NewReaderPool(CalculatePoolSize(), func(reader io.Reader) (Reader, error) {
+		return newBrotliReader(reader)
+	})
+}

EdgeNode/internal/compressions/reader_pool_deflate.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedDeflateReaderPool *ReaderPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedDeflateReaderPool = NewReaderPool(CalculatePoolSize(), func(reader io.Reader) (Reader, error) {
+		return newDeflateReader(reader)
+	})
+}

EdgeNode/internal/compressions/reader_pool_gzip.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedGzipReaderPool *ReaderPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedGzipReaderPool = NewReaderPool(CalculatePoolSize(), func(reader io.Reader) (Reader, error) {
+		return newGzipReader(reader)
+	})
+}

EdgeNode/internal/compressions/reader_pool_zstd.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedZSTDReaderPool *ReaderPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedZSTDReaderPool = NewReaderPool(CalculatePoolSize(), func(reader io.Reader) (Reader, error) {
+		return newZSTDReader(reader)
+	})
+}

EdgeNode/internal/compressions/reader_zstd.go

@@ -0,0 +1,45 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"github.com/klauspost/compress/zstd"
+	"io"
+)
+
+type ZSTDReader struct {
+	BaseReader
+
+	reader *zstd.Decoder
+}
+
+func NewZSTDReader(reader io.Reader) (Reader, error) {
+	return sharedZSTDReaderPool.Get(reader)
+}
+
+func newZSTDReader(reader io.Reader) (Reader, error) {
+	r, err := zstd.NewReader(reader, zstd.WithDecoderMaxWindow(256<<20))
+	if err != nil {
+		return nil, err
+	}
+	return &ZSTDReader{
+		reader: r,
+	}, nil
+}
+
+func (this *ZSTDReader) Read(p []byte) (n int, err error) {
+	return this.reader.Read(p)
+}
+
+func (this *ZSTDReader) Reset(reader io.Reader) error {
+	return this.reader.Reset(reader)
+}
+
+func (this *ZSTDReader) RawClose() error {
+	this.reader.Close()
+	return nil
+}
+
+func (this *ZSTDReader) Close() error {
+	return this.Finish(this)
+}

EdgeNode/internal/compressions/reader_zstd_test.go

@@ -0,0 +1,106 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"github.com/iwind/TeaGo/rands"
+	"github.com/iwind/TeaGo/types"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestZSTDReader(t *testing.T) {
+	for _, testString := range []string{"Hello", "World", "Ni", "Hao"} {
+		t.Log("===", testString, "===")
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewZSTDWriter(buf, 5)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = writer.Write([]byte(testString))
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = writer.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		reader, err := compressions.NewZSTDReader(buf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var data = make([]byte, 4096)
+		for {
+			n, err := reader.Read(data)
+			if n > 0 {
+				t.Log(string(data[:n]))
+			}
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				t.Fatal(err)
+			}
+		}
+		err = reader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkZSTDReader(b *testing.B) {
+	var randomData = func() []byte {
+		var b = strings.Builder{}
+		for i := 0; i < 1024; i++ {
+			b.WriteString(types.String(rands.Int64() % 10))
+		}
+		return []byte(b.String())
+	}
+
+	var buf = &bytes.Buffer{}
+	writer, err := compressions.NewZSTDWriter(buf, 5)
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = writer.Write(randomData())
+	if err != nil {
+		b.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		var newBytes = make([]byte, buf.Len())
+		copy(newBytes, buf.Bytes())
+		reader, err := compressions.NewZSTDReader(bytes.NewReader(newBytes))
+		if err != nil {
+			b.Fatal(err)
+		}
+		var data = make([]byte, 4096)
+		for {
+			n, err := reader.Read(data)
+			if n > 0 {
+				_ = data[:n]
+			}
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				b.Fatal(err)
+			}
+		}
+		err = reader.Close()
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}

EdgeNode/internal/compressions/utils.go

@@ -0,0 +1,120 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"errors"
+	"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs"
+	memutils "github.com/TeaOSLab/EdgeNode/internal/utils/mem"
+	"io"
+	"net/http"
+	"runtime"
+)
+
+type ContentEncoding = string
+
+const (
+	ContentEncodingBr      ContentEncoding = "br"
+	ContentEncodingGzip    ContentEncoding = "gzip"
+	ContentEncodingDeflate ContentEncoding = "deflate"
+	ContentEncodingZSTD    ContentEncoding = "zstd"
+)
+
+var ErrNotSupportedContentEncoding = errors.New("not supported content encoding")
+
+// AllEncodings 当前支持的所有编码
+func AllEncodings() []ContentEncoding {
+	return []ContentEncoding{
+		ContentEncodingBr,
+		ContentEncodingGzip,
+		ContentEncodingZSTD,
+		ContentEncodingDeflate,
+	}
+}
+
+// NewReader 获取Reader
+func NewReader(reader io.Reader, contentEncoding ContentEncoding) (Reader, error) {
+	switch contentEncoding {
+	case ContentEncodingBr:
+		return NewBrotliReader(reader)
+	case ContentEncodingGzip:
+		return NewGzipReader(reader)
+	case ContentEncodingDeflate:
+		return NewDeflateReader(reader)
+	case ContentEncodingZSTD:
+		return NewZSTDReader(reader)
+	}
+	return nil, ErrNotSupportedContentEncoding
+}
+
+// NewWriter 获取Writer
+func NewWriter(writer io.Writer, compressType serverconfigs.HTTPCompressionType, level int) (Writer, error) {
+	switch compressType {
+	case serverconfigs.HTTPCompressionTypeGzip:
+		return NewGzipWriter(writer, level)
+	case serverconfigs.HTTPCompressionTypeDeflate:
+		return NewDeflateWriter(writer, level)
+	case serverconfigs.HTTPCompressionTypeBrotli:
+		return NewBrotliWriter(writer, level)
+	case serverconfigs.HTTPCompressionTypeZSTD:
+		return NewZSTDWriter(writer, level)
+	}
+	return nil, errors.New("invalid compression type '" + compressType + "'")
+}
+
+// SupportEncoding 检查是否支持某个编码
+func SupportEncoding(encoding string) bool {
+	return encoding == ContentEncodingBr ||
+		encoding == ContentEncodingGzip ||
+		encoding == ContentEncodingDeflate ||
+		encoding == ContentEncodingZSTD
+}
+
+// WrapHTTPResponse 包装http.Response对象
+func WrapHTTPResponse(resp *http.Response) {
+	if resp == nil {
+		return
+	}
+
+	var contentEncoding = resp.Header.Get("Content-Encoding")
+	if len(contentEncoding) == 0 || !SupportEncoding(contentEncoding) {
+		return
+	}
+
+	reader, err := NewReader(resp.Body, contentEncoding)
+	if err != nil {
+		// unable to decode, we ignore the error
+		return
+	}
+	resp.Header.Del("Content-Encoding")
+	resp.Header.Del("Content-Length")
+	resp.Body = reader
+}
+
+// 系统CPU线程数
+var countCPU = runtime.NumCPU()
+
+// GenerateCompressLevel 根据系统资源自动生成压缩级别
+func GenerateCompressLevel(minLevel int, maxLevel int) (level int) {
+	if countCPU < 16 {
+		return minLevel
+	}
+
+	if countCPU < 32 {
+		return min(3, maxLevel)
+	}
+
+	return min(5, maxLevel)
+}
+
+// CalculatePoolSize 计算Pool尺寸
+func CalculatePoolSize() int {
+	var maxSize = memutils.SystemMemoryGB() * 32
+	if maxSize == 0 {
+		maxSize = 128
+	}
+	if maxSize > 2048 {
+		maxSize = 2048
+	}
+	return maxSize
+}

EdgeNode/internal/compressions/utils_test.go

@@ -0,0 +1,27 @@
+// Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
+
+package compressions_test
+
+import (
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"github.com/iwind/TeaGo/assert"
+	"testing"
+)
+
+func TestGenerateCompressLevel(t *testing.T) {
+	var a = assert.NewAssertion(t)
+
+	t.Log(compressions.GenerateCompressLevel(0, 10))
+	t.Log(compressions.GenerateCompressLevel(1, 10))
+	t.Log(compressions.GenerateCompressLevel(1, 4))
+
+	{
+		var level = compressions.GenerateCompressLevel(1, 2)
+		t.Log(level)
+		a.IsTrue(level >= 1 && level <= 2)
+	}
+}
+
+func TestCalculatePoolSize(t *testing.T) {
+	t.Log(compressions.CalculatePoolSize())
+}

EdgeNode/internal/compressions/writer.go

@@ -0,0 +1,18 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import "io"
+
+type Writer interface {
+	Write(p []byte) (int, error)
+	Flush() error
+	Reset(writer io.Writer)
+	RawClose() error
+	Close() error
+	Level() int
+	IncreaseHit() uint32
+
+	SetPool(pool *WriterPool)
+	ResetFinish()
+}

EdgeNode/internal/compressions/writer_base.go

@@ -0,0 +1,39 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"sync/atomic"
+)
+
+type BaseWriter struct {
+	pool *WriterPool
+
+	isFinished bool
+
+	hits uint32
+}
+
+func (this *BaseWriter) SetPool(pool *WriterPool) {
+	this.pool = pool
+}
+
+func (this *BaseWriter) Finish(obj Writer) error {
+	if this.isFinished {
+		return nil
+	}
+	err := obj.RawClose()
+	if err == nil && this.pool != nil {
+		this.pool.Put(obj)
+	}
+	this.isFinished = true
+	return err
+}
+
+func (this *BaseWriter) ResetFinish() {
+	this.isFinished = false
+}
+
+func (this *BaseWriter) IncreaseHit() uint32 {
+	return atomic.AddUint32(&this.hits, 1)
+}

EdgeNode/internal/compressions/writer_brotli.go

@@ -0,0 +1,55 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+//go:build !plus || !linux
+
+package compressions
+
+import (
+	"github.com/andybalholm/brotli"
+	"io"
+)
+
+type BrotliWriter struct {
+	BaseWriter
+
+	writer *brotli.Writer
+	level  int
+}
+
+func NewBrotliWriter(writer io.Writer, level int) (Writer, error) {
+	return sharedBrotliWriterPool.Get(writer, level)
+}
+
+func newBrotliWriter(writer io.Writer) (*BrotliWriter, error) {
+	var level = GenerateCompressLevel(brotli.BestSpeed, brotli.BestCompression)
+	return &BrotliWriter{
+		writer: brotli.NewWriterOptions(writer, brotli.WriterOptions{
+			Quality: level,
+			LGWin:   14, // TODO 在全局设置里可以设置此值
+		}),
+		level: level,
+	}, nil
+}
+
+func (this *BrotliWriter) Write(p []byte) (int, error) {
+	return this.writer.Write(p)
+}
+
+func (this *BrotliWriter) Flush() error {
+	return this.writer.Flush()
+}
+
+func (this *BrotliWriter) Reset(newWriter io.Writer) {
+	this.writer.Reset(newWriter)
+}
+
+func (this *BrotliWriter) RawClose() error {
+	return this.writer.Close()
+}
+
+func (this *BrotliWriter) Close() error {
+	return this.Finish(this)
+}
+
+func (this *BrotliWriter) Level() int {
+	return this.level
+}

EdgeNode/internal/compressions/writer_brotli_plus.go

@@ -0,0 +1,71 @@
+// Copyright 2023 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+//go:build plus && linux
+
+package compressions
+
+import (
+	"github.com/TeaOSLab/EdgeNode/internal/compressions/cbrotli"
+	"io"
+)
+
+const (
+	BrotliBestSpeed       = 0
+	BrotliBestCompression = 11
+
+	BrotliDefaultLGWin = 14
+)
+
+type BrotliWriter struct {
+	BaseWriter
+
+	writer *cbrotli.Writer
+
+	level int
+}
+
+func NewBrotliWriter(writer io.Writer, level int) (Writer, error) {
+	return sharedBrotliWriterPool.Get(writer, level)
+}
+
+func newBrotliWriter(writer io.Writer) (*BrotliWriter, error) {
+	var level = GenerateCompressLevel(BrotliBestSpeed, BrotliBestCompression)
+
+	return &BrotliWriter{
+		writer: cbrotli.NewWriter(writer, cbrotli.WriterOptions{
+			Quality: level,
+			LGWin:   BrotliDefaultLGWin,
+		}),
+		level: level,
+	}, nil
+}
+
+func (this *BrotliWriter) Write(p []byte) (int, error) {
+	return this.writer.Write(p)
+}
+
+func (this *BrotliWriter) Flush() error {
+	return this.writer.Flush()
+}
+
+func (this *BrotliWriter) Reset(newWriter io.Writer) {
+	_ = this.writer.Close()
+	if newWriter == nil {
+		return
+	}
+	this.writer = cbrotli.NewWriter(newWriter, cbrotli.WriterOptions{
+		Quality: this.level,
+		LGWin:   BrotliDefaultLGWin,
+	})
+}
+
+func (this *BrotliWriter) RawClose() error {
+	return this.writer.Close()
+}
+
+func (this *BrotliWriter) Close() error {
+	return this.Finish(this)
+}
+
+func (this *BrotliWriter) Level() int {
+	return this.level
+}

EdgeNode/internal/compressions/writer_brotli_test.go

@@ -0,0 +1,152 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	stringutil "github.com/iwind/TeaGo/utils/string"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestBrotliWriter_LargeFile(t *testing.T) {
+	var data = []byte{}
+	for i := 0; i < 1024*1024; i++ {
+		data = append(data, stringutil.Rand(32)...)
+	}
+	t.Log(len(data)/1024/1024, "M")
+
+	var before = time.Now()
+	defer func() {
+		t.Log(time.Since(before).Seconds()*1000, "ms")
+	}()
+
+	var buf = &bytes.Buffer{}
+	writer, err := compressions.NewBrotliWriter(buf, 5)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var offset = 0
+	var size = 4096
+	for offset < len(data) {
+		_, err = writer.Write(data[offset : offset+size])
+		if err != nil {
+			t.Fatal(err)
+		}
+		offset += size
+	}
+
+	err = writer.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func BenchmarkBrotliWriter_Write(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 1024))
+
+	for i := 0; i < b.N; i++ {
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewBrotliWriter(buf, 5)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		for j := 0; j < 100; j++ {
+			_, err = writer.Write(data)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			/**err = writer.Flush()
+			if err != nil {
+				b.Fatal(err)
+			}**/
+		}
+
+		_ = writer.Close()
+	}
+}
+
+func BenchmarkBrotliWriter_Write_Parallel(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 1024))
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var buf = &bytes.Buffer{}
+			writer, err := compressions.NewBrotliWriter(buf, 5)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			for j := 0; j < 100; j++ {
+				_, err = writer.Write(data)
+				if err != nil {
+					b.Fatal(err)
+				}
+
+				/**err = writer.Flush()
+				if err != nil {
+					b.Fatal(err)
+				}**/
+			}
+
+			_ = writer.Close()
+		}
+	})
+}
+
+func BenchmarkBrotliWriter_Write_Small(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 16))
+
+	for i := 0; i < b.N; i++ {
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewBrotliWriter(buf, 5)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		for j := 0; j < 100; j++ {
+			_, err = writer.Write(data)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			/**err = writer.Flush()
+			if err != nil {
+				b.Fatal(err)
+			}**/
+		}
+
+		_ = writer.Close()
+	}
+}
+
+func BenchmarkBrotliWriter_Write_Large(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 4096))
+
+	for i := 0; i < b.N; i++ {
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewBrotliWriter(buf, 5)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		for j := 0; j < 100; j++ {
+			_, err = writer.Write(data)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			/**err = writer.Flush()
+			if err != nil {
+				b.Fatal(err)
+			}**/
+		}
+
+		_ = writer.Close()
+	}
+}

EdgeNode/internal/compressions/writer_deflate.go

@@ -0,0 +1,57 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"compress/flate"
+	"io"
+)
+
+type DeflateWriter struct {
+	BaseWriter
+
+	writer *flate.Writer
+	level  int
+}
+
+func NewDeflateWriter(writer io.Writer, level int) (Writer, error) {
+	return sharedDeflateWriterPool.Get(writer, level)
+}
+
+func newDeflateWriter(writer io.Writer) (Writer, error) {
+	var level = GenerateCompressLevel(flate.BestSpeed, flate.BestCompression)
+
+	flateWriter, err := flate.NewWriter(writer, level)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DeflateWriter{
+		writer: flateWriter,
+		level:  level,
+	}, nil
+}
+
+func (this *DeflateWriter) Write(p []byte) (int, error) {
+	return this.writer.Write(p)
+}
+
+func (this *DeflateWriter) Flush() error {
+	return this.writer.Flush()
+}
+
+func (this *DeflateWriter) Reset(writer io.Writer) {
+	this.writer.Reset(writer)
+}
+
+func (this *DeflateWriter) RawClose() error {
+	return this.writer.Close()
+}
+
+func (this *DeflateWriter) Close() error {
+	return this.Finish(this)
+}
+
+func (this *DeflateWriter) Level() int {
+	return this.level
+}

EdgeNode/internal/compressions/writer_deflate_test.go

@@ -0,0 +1,36 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"strings"
+	"testing"
+)
+
+func BenchmarkDeflateWriter_Write(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 1024))
+
+	for i := 0; i < b.N; i++ {
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewDeflateWriter(buf, 5)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		for j := 0; j < 100; j++ {
+			_, err = writer.Write(data)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			/**err = writer.Flush()
+			if err != nil {
+				b.Fatal(err)
+			}**/
+		}
+
+		_ = writer.Close()
+	}
+}

EdgeNode/internal/compressions/writer_gzip.go

@@ -0,0 +1,57 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"github.com/klauspost/compress/gzip"
+	"io"
+)
+
+type GzipWriter struct {
+	BaseWriter
+
+	writer *gzip.Writer
+	level  int
+}
+
+func NewGzipWriter(writer io.Writer, level int) (Writer, error) {
+	return sharedGzipWriterPool.Get(writer, level)
+}
+
+func newGzipWriter(writer io.Writer) (Writer, error) {
+	var level = GenerateCompressLevel(gzip.BestSpeed, gzip.BestCompression)
+
+	gzipWriter, err := gzip.NewWriterLevel(writer, level)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GzipWriter{
+		writer: gzipWriter,
+		level:  level,
+	}, nil
+}
+
+func (this *GzipWriter) Write(p []byte) (int, error) {
+	return this.writer.Write(p)
+}
+
+func (this *GzipWriter) Flush() error {
+	return this.writer.Flush()
+}
+
+func (this *GzipWriter) Reset(writer io.Writer) {
+	this.writer.Reset(writer)
+}
+
+func (this *GzipWriter) RawClose() error {
+	return this.writer.Close()
+}
+
+func (this *GzipWriter) Close() error {
+	return this.Finish(this)
+}
+
+func (this *GzipWriter) Level() int {
+	return this.level
+}

EdgeNode/internal/compressions/writer_gzip_test.go

@@ -0,0 +1,72 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"testing"
+)
+
+func BenchmarkGzipWriter_Write(b *testing.B) {
+	var data = make([]byte, 1024)
+	for i := 0; i < 1024; i++ {
+		data[i] = 'A' + byte(i%26)
+	}
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewGzipWriter(buf, 5)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		for j := 0; j < 100; j++ {
+			_, err = writer.Write(data)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			/**err = writer.Flush()
+			if err != nil {
+				b.Fatal(err)
+			}**/
+		}
+
+		_ = writer.Close()
+	}
+}
+
+func BenchmarkGzipWriter_Write_Parallel(b *testing.B) {
+	var data = make([]byte, 1024)
+	for i := 0; i < 1024; i++ {
+		data[i] = 'A' + byte(i%26)
+	}
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var buf = &bytes.Buffer{}
+			writer, err := compressions.NewGzipWriter(buf, 5)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			for j := 0; j < 100; j++ {
+				_, err = writer.Write(data)
+				if err != nil {
+					b.Fatal(err)
+				}
+
+				/**err = writer.Flush()
+				if err != nil {
+					b.Fatal(err)
+				}**/
+			}
+
+			_ = writer.Close()
+		}
+	})
+}

EdgeNode/internal/compressions/writer_pool.go

@@ -0,0 +1,82 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"github.com/TeaOSLab/EdgeNode/internal/utils/goman"
+	"io"
+	"time"
+)
+
+const maxWriterHits = 1 << 20
+
+var isBusy = false
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	goman.New(func() {
+		var ticker = time.NewTicker(100 * time.Millisecond)
+		for range ticker.C {
+			if isBusy {
+				isBusy = false
+			}
+		}
+	})
+}
+
+func IsBusy() bool {
+	return isBusy
+}
+
+type WriterPool struct {
+	c       chan Writer // level => chan Writer
+	newFunc func(writer io.Writer, level int) (Writer, error)
+}
+
+func NewWriterPool(maxSize int, newFunc func(writer io.Writer, level int) (Writer, error)) *WriterPool {
+	if maxSize <= 0 {
+		maxSize = 1024
+	}
+
+	return &WriterPool{
+		c:       make(chan Writer, maxSize),
+		newFunc: newFunc,
+	}
+}
+
+func (this *WriterPool) Get(parentWriter io.Writer, level int) (Writer, error) {
+	if isBusy {
+		return nil, ErrIsBusy
+	}
+
+	select {
+	case writer := <-this.c:
+		writer.Reset(parentWriter)
+		writer.ResetFinish()
+		return writer, nil
+	default:
+		writer, err := this.newFunc(parentWriter, level)
+		if err != nil {
+			return nil, err
+		}
+		writer.SetPool(this)
+		return writer, nil
+	}
+}
+
+func (this *WriterPool) Put(writer Writer) {
+	if writer.IncreaseHit() > maxWriterHits {
+		// do nothing to discard it
+		return
+	}
+
+	select {
+	case this.c <- writer:
+	default:
+		isBusy = true
+	}
+}

EdgeNode/internal/compressions/writer_pool_brotli.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedBrotliWriterPool *WriterPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedBrotliWriterPool = NewWriterPool(CalculatePoolSize(), func(writer io.Writer, level int) (Writer, error) {
+		return newBrotliWriter(writer)
+	})
+}

EdgeNode/internal/compressions/writer_pool_deflate.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedDeflateWriterPool *WriterPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedDeflateWriterPool = NewWriterPool(CalculatePoolSize(), func(writer io.Writer, level int) (Writer, error) {
+		return newDeflateWriter(writer)
+	})
+}

EdgeNode/internal/compressions/writer_pool_gzip.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedGzipWriterPool *WriterPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedGzipWriterPool = NewWriterPool(CalculatePoolSize(), func(writer io.Writer, level int) (Writer, error) {
+		return newGzipWriter(writer)
+	})
+}

EdgeNode/internal/compressions/writer_pool_zstd.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	teaconst "github.com/TeaOSLab/EdgeNode/internal/const"
+	"io"
+)
+
+var sharedZSTDWriterPool *WriterPool
+
+func init() {
+	if !teaconst.IsMain {
+		return
+	}
+
+	sharedZSTDWriterPool = NewWriterPool(CalculatePoolSize(), func(writer io.Writer, level int) (Writer, error) {
+		return newZSTDWriter(writer)
+	})
+}

EdgeNode/internal/compressions/writer_zstd.go

@@ -0,0 +1,58 @@
+// Copyright 2021 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions
+
+import (
+	"github.com/klauspost/compress/zstd"
+	"io"
+)
+
+type ZSTDWriter struct {
+	BaseWriter
+
+	writer *zstd.Encoder
+	level  int
+}
+
+func NewZSTDWriter(writer io.Writer, level int) (Writer, error) {
+	return sharedZSTDWriterPool.Get(writer, level)
+}
+
+func newZSTDWriter(writer io.Writer) (Writer, error) {
+	var level = 1
+	var zstdLevel = zstd.SpeedFastest
+
+	zstdWriter, err := zstd.NewWriter(writer, zstd.WithEncoderLevel(zstdLevel), zstd.WithWindowSize(16<<10), zstd.WithLowerEncoderMem(true))
+	if err != nil {
+		return nil, err
+	}
+
+	return &ZSTDWriter{
+		writer: zstdWriter,
+		level:  level,
+	}, nil
+}
+
+func (this *ZSTDWriter) Write(p []byte) (int, error) {
+	return this.writer.Write(p)
+}
+
+func (this *ZSTDWriter) Flush() error {
+	return this.writer.Flush()
+}
+
+func (this *ZSTDWriter) Reset(writer io.Writer) {
+	this.writer.Reset(writer)
+}
+
+func (this *ZSTDWriter) RawClose() error {
+	return this.writer.Close()
+}
+
+func (this *ZSTDWriter) Close() error {
+	return this.Finish(this)
+}
+
+func (this *ZSTDWriter) Level() int {
+	return this.level
+}

EdgeNode/internal/compressions/writer_zstd_test.go

@@ -0,0 +1,100 @@
+// Copyright 2022 Liuxiangchao iwind.liu@gmail.com. All rights reserved.
+
+package compressions_test
+
+import (
+	"bytes"
+	"github.com/TeaOSLab/EdgeNode/internal/compressions"
+	"strings"
+	"testing"
+)
+
+func TestNewZSTDWriter_Level0(t *testing.T) {
+	var buf = &bytes.Buffer{}
+	writer, err := compressions.NewZSTDWriter(buf, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var originData = []byte(strings.Repeat("Hello", 1024))
+	_, err = writer.Write(originData)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log("origin data:", len(originData), "result:", buf.Len())
+}
+
+func TestNewZSTDWriter(t *testing.T) {
+	var buf = &bytes.Buffer{}
+	writer, err := compressions.NewZSTDWriter(buf, 10)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var originData = []byte(strings.Repeat("Hello", 1024))
+	_, err = writer.Write(originData)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Log("origin data:", len(originData), "result:", buf.Len())
+}
+
+func BenchmarkZSTDWriter_Write(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 1024))
+
+	for i := 0; i < b.N; i++ {
+		var buf = &bytes.Buffer{}
+		writer, err := compressions.NewZSTDWriter(buf, 5)
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		for j := 0; j < 100; j++ {
+			_, err = writer.Write(data)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			/**err = writer.Flush()
+			if err != nil {
+				b.Fatal(err)
+			}**/
+		}
+
+		_ = writer.Close()
+	}
+}
+
+func BenchmarkZSTDWriter_Write_Parallel(b *testing.B) {
+	var data = []byte(strings.Repeat("A", 1024))
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var buf = &bytes.Buffer{}
+			writer, err := compressions.NewZSTDWriter(buf, 5)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			for j := 0; j < 100; j++ {
+				_, err = writer.Write(data)
+				if err != nil {
+					b.Fatal(err)
+				}
+
+				/**err = writer.Flush()
+				if err != nil {
+					b.Fatal(err)
+				}**/
+			}
+
+			_ = writer.Close()
+		}
+	})
+}