mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-16 22:57:53 +08:00
DecodeResponseBody used zstd.NewReader with its default options, which hands blocks to up to four asynchronous decoders: allocations and handoff latency on every streamed response for no gain on bodies read as they arrive. Decode with WithDecoderConcurrency(1) instead. A response without Content-Encoding was sniffed for gzip/zstd magic with Peek(4) before DecodeResponseBody returned, blocking the caller until the upstream sent its first bytes. Detect on the first Read instead, waiting for more than one byte only when the first byte can start a gzip or zstd frame.
188 lines
5.5 KiB
Go
188 lines
5.5 KiB
Go
package helps
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/flate"
|
|
"compress/gzip"
|
|
"compress/zlib"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/andybalholm/brotli"
|
|
"github.com/klauspost/compress/zstd"
|
|
)
|
|
|
|
type responseDecodeTestBody struct {
|
|
io.Reader
|
|
closeCount int
|
|
closeErr error
|
|
}
|
|
|
|
func (b *responseDecodeTestBody) Close() error {
|
|
b.closeCount++
|
|
return b.closeErr
|
|
}
|
|
|
|
func encodeResponseDecodeTestBody(t *testing.T, encoding string, plain []byte) []byte {
|
|
t.Helper()
|
|
var output bytes.Buffer
|
|
var writer io.WriteCloser
|
|
var errWriter error
|
|
switch encoding {
|
|
case "gzip":
|
|
writer = gzip.NewWriter(&output)
|
|
case "deflate":
|
|
writer, errWriter = flate.NewWriter(&output, flate.DefaultCompression)
|
|
case "zlib":
|
|
writer = zlib.NewWriter(&output)
|
|
case "br":
|
|
writer = brotli.NewWriter(&output)
|
|
case "zstd":
|
|
writer, errWriter = zstd.NewWriter(&output)
|
|
}
|
|
if errWriter != nil {
|
|
t.Fatal(errWriter)
|
|
}
|
|
if _, errWrite := writer.Write(plain); errWrite != nil {
|
|
t.Fatal(errWrite)
|
|
}
|
|
if errClose := writer.Close(); errClose != nil {
|
|
t.Fatal(errClose)
|
|
}
|
|
return output.Bytes()
|
|
}
|
|
|
|
func TestDecodeResponseBody(t *testing.T) {
|
|
plain := []byte("data: response.completed\n\n")
|
|
for _, tt := range []struct {
|
|
name string
|
|
encodings []string
|
|
header http.Header
|
|
}{
|
|
{name: "plain"},
|
|
{name: "short-plain"},
|
|
{name: "identity", header: http.Header{"Content-Encoding": {"identity"}}},
|
|
{name: "gzip", encodings: []string{"gzip"}, header: http.Header{"Content-Encoding": {"GZIP"}}},
|
|
{name: "gzip-sniff", encodings: []string{"gzip"}},
|
|
{name: "zstd", encodings: []string{"zstd"}, header: http.Header{"Content-Encoding": {"zstd"}}},
|
|
{name: "zstd-sniff", encodings: []string{"zstd"}},
|
|
{name: "brotli", encodings: []string{"br"}, header: http.Header{"Content-Encoding": {"br"}}},
|
|
{name: "deflate-raw", encodings: []string{"deflate"}, header: http.Header{"Content-Encoding": {"deflate"}}},
|
|
{name: "deflate-zlib", encodings: []string{"zlib"}, header: http.Header{"Content-Encoding": {"deflate"}}},
|
|
{name: "stacked", encodings: []string{"gzip", "br", "zstd"}, header: http.Header{"Content-Encoding": {"gzip, br", "zstd"}}},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
want := plain
|
|
if tt.name == "short-plain" {
|
|
want = []byte("a")
|
|
}
|
|
wire := want
|
|
for _, encoding := range tt.encodings {
|
|
wire = encodeResponseDecodeTestBody(t, encoding, wire)
|
|
}
|
|
body := &responseDecodeTestBody{Reader: bytes.NewReader(wire)}
|
|
decoded, errDecode := DecodeResponseBody(body, tt.header)
|
|
if errDecode != nil {
|
|
t.Fatal(errDecode)
|
|
}
|
|
got, errRead := io.ReadAll(decoded)
|
|
errClose := decoded.Close()
|
|
if errRead != nil || errClose != nil || !bytes.Equal(got, want) {
|
|
t.Fatalf("decode mismatch: read=%v, close=%v, got=%q", errRead, errClose, got)
|
|
}
|
|
if body.closeCount != 1 {
|
|
t.Fatalf("original body closed %d times, want 1", body.closeCount)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDecodeResponseBodySetupErrorsCloseOriginal(t *testing.T) {
|
|
for _, header := range []http.Header{
|
|
{"Content-Encoding": {"unsupported"}},
|
|
{"Content-Encoding": {"gzip"}},
|
|
{"Content-Encoding": {"unsupported, gzip"}},
|
|
} {
|
|
body := &responseDecodeTestBody{Reader: bytes.NewReader([]byte("invalid gzip"))}
|
|
if _, errDecode := DecodeResponseBody(body, header); errDecode == nil {
|
|
t.Fatal("expected decoding error")
|
|
}
|
|
if body.closeCount != 1 {
|
|
t.Fatalf("setup error closed body %d times, want 1", body.closeCount)
|
|
}
|
|
}
|
|
if _, errDecode := DecodeResponseBody(nil, nil); errDecode == nil {
|
|
t.Fatal("nil body must return an error")
|
|
}
|
|
}
|
|
|
|
func TestDecodeResponseBodyCompositeClose(t *testing.T) {
|
|
wantErr := errors.New("first close error")
|
|
var order []int
|
|
body := &compositeReadCloser{closers: []func() error{
|
|
func() error { order = append(order, 1); return wantErr },
|
|
nil,
|
|
func() error { order = append(order, 2); return errors.New("second close error") },
|
|
}}
|
|
if errClose := body.Close(); !errors.Is(errClose, wantErr) || !reflect.DeepEqual(order, []int{1, 2}) {
|
|
t.Fatalf("close must attempt all closers and return first error: %v, order=%v", errClose, order)
|
|
}
|
|
}
|
|
|
|
func TestDecodeResponseBodyUnlabeledDoesNotWaitForFirstByte(t *testing.T) {
|
|
reader, writer := io.Pipe()
|
|
returned := make(chan io.ReadCloser, 1)
|
|
go func() {
|
|
body, errDecode := DecodeResponseBody(reader, http.Header{})
|
|
if errDecode != nil {
|
|
t.Error(errDecode)
|
|
}
|
|
returned <- body
|
|
}()
|
|
var body io.ReadCloser
|
|
select {
|
|
case body = <-returned:
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("DecodeResponseBody blocked until the upstream sent its first byte")
|
|
}
|
|
go func() {
|
|
_, _ = writer.Write([]byte("data: {}\n\n"))
|
|
_ = writer.Close()
|
|
}()
|
|
got, errRead := io.ReadAll(body)
|
|
if errRead != nil || string(got) != "data: {}\n\n" {
|
|
t.Fatalf("read %q, %v", got, errRead)
|
|
}
|
|
if errClose := body.Close(); errClose != nil {
|
|
t.Fatal(errClose)
|
|
}
|
|
}
|
|
|
|
func TestDecodeResponseBodySniffsSplitMagicBytes(t *testing.T) {
|
|
plain := []byte("data: response.completed\n\n")
|
|
for _, encoding := range []string{"gzip", "zstd"} {
|
|
wire := encodeResponseDecodeTestBody(t, encoding, plain)
|
|
reader, writer := io.Pipe()
|
|
go func() {
|
|
// The magic bytes arrive one write at a time.
|
|
for i := range wire {
|
|
_, _ = writer.Write(wire[i : i+1])
|
|
}
|
|
_ = writer.Close()
|
|
}()
|
|
body, errDecode := DecodeResponseBody(reader, http.Header{})
|
|
if errDecode != nil {
|
|
t.Fatal(errDecode)
|
|
}
|
|
got, errRead := io.ReadAll(body)
|
|
if errRead != nil || !bytes.Equal(got, plain) {
|
|
t.Fatalf("%s: read %q, %v", encoding, got, errRead)
|
|
}
|
|
_ = body.Close()
|
|
}
|
|
}
|