traefik/pkg/middlewares/compress/compress.go

187 lines
4.8 KiB
Go
Raw Normal View History

2018-11-14 09:18:03 +00:00
package compress
import (
"context"
2024-02-08 13:15:45 +00:00
"errors"
"fmt"
"mime"
2018-11-14 09:18:03 +00:00
"net/http"
2023-08-16 15:50:06 +00:00
"slices"
2018-11-14 09:18:03 +00:00
"github.com/klauspost/compress/gzhttp"
2023-02-03 14:24:05 +00:00
"github.com/traefik/traefik/v3/pkg/config/dynamic"
"github.com/traefik/traefik/v3/pkg/middlewares"
2024-01-08 08:10:06 +00:00
"go.opentelemetry.io/otel/trace"
2018-11-14 09:18:03 +00:00
)
const typeName = "Compress"
// DefaultMinSize is the default minimum size (in bytes) required to enable compression.
// See https://github.com/klauspost/compress/blob/9559b037e79ad673c71f6ef7c732c00949014cd2/gzhttp/compress.go#L47.
const DefaultMinSize = 1024
2018-11-14 09:18:03 +00:00
// Compress is a middleware that allows to compress the response.
type compress struct {
next http.Handler
name string
excludes []string
includes []string
minSize int
defaultEncoding string
brotliHandler http.Handler
gzipHandler http.Handler
zstdHandler http.Handler
2018-11-14 09:18:03 +00:00
}
// New creates a new compress middleware.
func New(ctx context.Context, next http.Handler, conf dynamic.Compress, name string) (http.Handler, error) {
2022-11-21 17:36:05 +00:00
middlewares.GetLogger(ctx, name, typeName).Debug().Msg("Creating middleware")
2018-11-14 09:18:03 +00:00
if len(conf.ExcludedContentTypes) > 0 && len(conf.IncludedContentTypes) > 0 {
2024-02-08 13:15:45 +00:00
return nil, errors.New("excludedContentTypes and includedContentTypes options are mutually exclusive")
}
excludes := []string{"application/grpc"}
for _, v := range conf.ExcludedContentTypes {
mediaType, _, err := mime.ParseMediaType(v)
if err != nil {
return nil, fmt.Errorf("parsing excluded media type: %w", err)
}
excludes = append(excludes, mediaType)
}
var includes []string
for _, v := range conf.IncludedContentTypes {
mediaType, _, err := mime.ParseMediaType(v)
if err != nil {
return nil, fmt.Errorf("parsing included media type: %w", err)
}
includes = append(includes, mediaType)
}
minSize := DefaultMinSize
if conf.MinResponseBodyBytes > 0 {
minSize = conf.MinResponseBodyBytes
}
c := &compress{
next: next,
name: name,
excludes: excludes,
includes: includes,
minSize: minSize,
defaultEncoding: conf.DefaultEncoding,
}
var err error
c.zstdHandler, err = c.newCompressionHandler(zstdName, name)
if err != nil {
return nil, err
}
c.brotliHandler, err = c.newCompressionHandler(brotliName, name)
if err != nil {
return nil, err
}
c.gzipHandler, err = c.newGzipHandler()
if err != nil {
return nil, err
}
return c, nil
2018-11-14 09:18:03 +00:00
}
func (c *compress) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
2022-11-21 17:36:05 +00:00
logger := middlewares.GetLogger(req.Context(), c.name, typeName)
if req.Method == http.MethodHead {
c.next.ServeHTTP(rw, req)
return
}
mediaType, _, err := mime.ParseMediaType(req.Header.Get("Content-Type"))
if err != nil {
2022-11-21 17:36:05 +00:00
logger.Debug().Err(err).Msg("Unable to parse MIME type")
}
// Notably for text/event-stream requests the response should not be compressed.
// See https://github.com/traefik/traefik/issues/2576
2023-08-16 15:50:06 +00:00
if slices.Contains(c.excludes, mediaType) {
2018-11-14 09:18:03 +00:00
c.next.ServeHTTP(rw, req)
return
}
acceptEncoding, ok := req.Header[acceptEncodingHeader]
if !ok {
if c.defaultEncoding != "" {
// RFC says: "If no Accept-Encoding header field is in the request, any content coding is considered acceptable by the user agent."
// https://www.rfc-editor.org/rfc/rfc9110#field.accept-encoding
c.chooseHandler(c.defaultEncoding, rw, req)
return
}
// Client doesn't specify a preferred encoding, for compatibility don't encode the request
// See https://github.com/traefik/traefik/issues/9734
c.next.ServeHTTP(rw, req)
return
}
c.chooseHandler(getCompressionType(acceptEncoding, c.defaultEncoding), rw, req)
}
func (c *compress) chooseHandler(typ string, rw http.ResponseWriter, req *http.Request) {
switch typ {
case zstdName:
c.zstdHandler.ServeHTTP(rw, req)
case brotliName:
c.brotliHandler.ServeHTTP(rw, req)
case gzipName:
c.gzipHandler.ServeHTTP(rw, req)
default:
c.next.ServeHTTP(rw, req)
2018-11-14 09:18:03 +00:00
}
}
2024-01-08 08:10:06 +00:00
func (c *compress) GetTracingInformation() (string, string, trace.SpanKind) {
return c.name, typeName, trace.SpanKindInternal
2018-11-14 09:18:03 +00:00
}
func (c *compress) newGzipHandler() (http.Handler, error) {
var wrapper func(http.Handler) http.HandlerFunc
var err error
if len(c.includes) > 0 {
wrapper, err = gzhttp.NewWrapper(
gzhttp.ContentTypes(c.includes),
gzhttp.MinSize(c.minSize),
)
} else {
wrapper, err = gzhttp.NewWrapper(
gzhttp.ExceptContentTypes(c.excludes),
gzhttp.MinSize(c.minSize),
)
}
if err != nil {
return nil, fmt.Errorf("new gzip wrapper: %w", err)
}
return wrapper(c.next), nil
}
func (c *compress) newCompressionHandler(algo string, middlewareName string) (http.Handler, error) {
cfg := Config{MinSize: c.minSize, Algorithm: algo, MiddlewareName: middlewareName}
if len(c.includes) > 0 {
cfg.IncludedContentTypes = c.includes
} else {
cfg.ExcludedContentTypes = c.excludes
}
return NewCompressionHandler(cfg, c.next)
}