Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 32 additions & 2 deletions middleware/compress.go
Original file line number Diff line number Diff line change
Expand Up @@ -51,6 +51,7 @@ type gzipResponseWriter struct {
wroteBody bool
minLength int
minLengthExceeded bool
skipCompression bool
buffer *bytes.Buffer
code int
}
Expand Down Expand Up @@ -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)
}
Expand Down Expand Up @@ -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))
}
Expand Down Expand Up @@ -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
Expand All @@ -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()
}
Expand Down
125 changes: 125 additions & 0 deletions middleware/compress_proxy_encoding_test.go
Original file line number Diff line number Diff line change
@@ -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())
}
})
}
}