From d4eb05a9f7929838806f93cda9e938e9a5073a78 Mon Sep 17 00:00:00 2001 From: Twiink Date: Fri, 20 Nov 2026 17:57:17 +0800 Subject: [PATCH] =?UTF-8?q?fix(middleware):=20=E4=BF=AE=E5=A4=8D=E4=BB=A3?= =?UTF-8?q?=E7=90=86=E5=93=8D=E5=BA=94=E8=A2=AB=E9=87=8D=E5=A4=8D=E5=8E=8B?= =?UTF-8?q?=E7=BC=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- middleware/compress.go | 34 +++++- middleware/compress_proxy_encoding_test.go | 125 +++++++++++++++++++++ 2 files changed, 157 insertions(+), 2 deletions(-) create mode 100644 middleware/compress_proxy_encoding_test.go diff --git a/middleware/compress.go b/middleware/compress.go index 7754d5db8..edc36a2a4 100644 --- a/middleware/compress.go +++ b/middleware/compress.go @@ -51,6 +51,7 @@ type gzipResponseWriter struct { wroteBody bool minLength int minLengthExceeded bool + skipCompression bool buffer *bytes.Buffer code int } @@ -113,7 +114,10 @@ func (config GzipConfig) ToMiddleware() (echo.MiddlewareFunc, error) { // There are different reasons for cases when we have not yet written response to the client and now need to do so. // a) handler response had only response code and no response body (ala 404 or redirects etc). Response code need to be written now. // b) body is shorter than our minimum length threshold and being buffered currently and needs to be written - if !grw.wroteBody { + if grw.skipCompression { + c.SetResponse(rw) + w.Reset(io.Discard) + } else if !grw.wroteBody { if res.Header().Get(echo.HeaderContentEncoding) == gzipScheme { res.Header().Del(echo.HeaderContentEncoding) } @@ -145,15 +149,26 @@ func (config GzipConfig) ToMiddleware() (echo.MiddlewareFunc, error) { } func (w *gzipResponseWriter) WriteHeader(code int) { - w.Header().Del(echo.HeaderContentLength) // Issue #444 + if w.skipCompression { + w.ResponseWriter.WriteHeader(code) + return + } w.wroteHeader = true // Delay writing of the header until we know if we'll actually compress the response w.code = code + if !w.skipEncodedResponse() { + w.Header().Del(echo.HeaderContentLength) // Issue #444 + } } func (w *gzipResponseWriter) Write(b []byte) (int, error) { + if w.skipEncodedResponse() { + w.wroteBody = true + return w.ResponseWriter.Write(b) + } + if w.Header().Get(echo.HeaderContentType) == "" { w.Header().Set(echo.HeaderContentType, http.DetectContentType(b)) } @@ -181,6 +196,11 @@ func (w *gzipResponseWriter) Write(b []byte) (int, error) { } func (w *gzipResponseWriter) Flush() { + if w.skipEncodedResponse() { + _ = http.NewResponseController(w.ResponseWriter).Flush() + return + } + if !w.minLengthExceeded { // Enforce compression because we will not know how much more data will come w.minLengthExceeded = true @@ -198,6 +218,16 @@ func (w *gzipResponseWriter) Flush() { _ = http.NewResponseController(w.ResponseWriter).Flush() } +func (w *gzipResponseWriter) skipEncodedResponse() bool { + if !w.skipCompression && !w.wroteBody && !w.minLengthExceeded && w.Header().Get(echo.HeaderContentEncoding) != "" { + w.skipCompression = true + if w.wroteHeader { + w.ResponseWriter.WriteHeader(w.code) + } + } + return w.skipCompression +} + func (w *gzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { return http.NewResponseController(w.ResponseWriter).Hijack() } diff --git a/middleware/compress_proxy_encoding_test.go b/middleware/compress_proxy_encoding_test.go new file mode 100644 index 000000000..d5d5904c7 --- /dev/null +++ b/middleware/compress_proxy_encoding_test.go @@ -0,0 +1,125 @@ +// SPDX-License-Identifier: MIT +// SPDX-FileCopyrightText: © 2015 LabStack LLC and Echo contributors + +package middleware + +import ( + "bytes" + "compress/gzip" + "compress/zlib" + "fmt" + "io" + "net/http" + "net/http/httptest" + "net/url" + "strconv" + "testing" + + "github.com/labstack/echo/v5" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestGzipPreservesProxyContentEncoding(t *testing.T) { + payload := []byte("encoded upstream response") + for _, encoding := range []string{"gzip", "deflate"} { + var encoded bytes.Buffer + var compressor io.WriteCloser + if encoding == "gzip" { + compressor = gzip.NewWriter(&encoded) + } else { + compressor = zlib.NewWriter(&encoded) + } + _, err := compressor.Write(payload) + require.NoError(t, err) + require.NoError(t, compressor.Close()) + wire := append([]byte(nil), encoded.Bytes()...) + for _, minLength := range []int{0, 8, 4096} { + t.Run(fmt.Sprintf("%s/min=%d", encoding, minLength), func(t *testing.T) { + upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set(echo.HeaderContentEncoding, encoding) + w.Header().Set(echo.HeaderContentType, echo.MIMETextPlain) + w.Header().Set(echo.HeaderContentLength, strconv.Itoa(len(wire))) + w.WriteHeader(http.StatusCreated) + _, _ = w.Write(wire) + })) + defer upstream.Close() + target, err := url.Parse(upstream.URL) + require.NoError(t, err) + e := echo.New() + e.Use(GzipWithConfig(GzipConfig{MinLength: minLength})) + e.Use(Proxy(NewRoundRobinBalancer([]*ProxyTarget{{URL: target}}))) + proxy := httptest.NewServer(e) + defer proxy.Close() + transport := &http.Transport{DisableCompression: true} + defer transport.CloseIdleConnections() + client := &http.Client{Transport: transport} + req, err := http.NewRequest(http.MethodGet, proxy.URL, nil) + require.NoError(t, err) + req.Header.Set(echo.HeaderAcceptEncoding, "gzip, deflate") + res, err := client.Do(req) + require.NoError(t, err) + defer res.Body.Close() + body, err := io.ReadAll(res.Body) + require.NoError(t, err) + assert.Equal(t, http.StatusCreated, res.StatusCode) + assert.Equal(t, encoding, res.Header.Get(echo.HeaderContentEncoding)) + assert.Equal(t, wire, body, "proxy must preserve upstream encoded bytes") + var decoder io.ReadCloser + if encoding == "gzip" { + decoder, err = gzip.NewReader(bytes.NewReader(body)) + } else { + decoder, err = zlib.NewReader(bytes.NewReader(body)) + } + require.NoError(t, err) + defer decoder.Close() + decoded, err := io.ReadAll(decoder) + require.NoError(t, err) + assert.Equal(t, payload, decoded, "one decoding must recover the original response") + }) + } + } +} + +func TestGzipPreservesEncodedHandlerResponse(t *testing.T) { + wire := []byte("already encoded body") + for _, mode := range []string{"explicit header", "implicit header", "flush", "head"} { + t.Run(mode, func(t *testing.T) { + e := echo.New() + req := httptest.NewRequest(http.MethodGet, "/", nil) + req.Header.Set(echo.HeaderAcceptEncoding, gzipScheme) + rec := httptest.NewRecorder() + c := e.NewContext(req, rec) + handler := Gzip()(func(c *echo.Context) error { + w := c.Response() + w.Header().Set(echo.HeaderContentEncoding, gzipScheme) + w.Header().Set(echo.HeaderContentLength, strconv.Itoa(len(wire))) + if mode != "implicit header" { + w.WriteHeader(http.StatusCreated) + } + if mode == "head" { + return nil + } + if mode == "flush" { + require.NoError(t, http.NewResponseController(w).Flush()) + } + n, err := w.Write(wire) + assert.Equal(t, len(wire), n) + return err + }) + require.NoError(t, handler(c)) + expectedStatus := http.StatusCreated + if mode == "implicit header" { + expectedStatus = http.StatusOK + } + assert.Equal(t, expectedStatus, rec.Code) + assert.Equal(t, gzipScheme, rec.Result().Header.Get(echo.HeaderContentEncoding)) + assert.Equal(t, strconv.Itoa(len(wire)), rec.Result().Header.Get(echo.HeaderContentLength)) + if mode == "head" { + assert.Empty(t, rec.Body.Bytes()) + } else { + assert.Equal(t, wire, rec.Body.Bytes()) + } + }) + } +}