Merge v2.4 into master

pkg/middlewares/compress/compress.go

@@ -6,8 +6,8 @@ import (
 	"mime"
 	"net/http"
 
-	"github.com/NYTimes/gziphandler"
 	"github.com/opentracing/opentracing-go/ext"
+	"github.com/traefik/gziphandler"
 	"github.com/traefik/traefik/v2/pkg/config/dynamic"
 	"github.com/traefik/traefik/v2/pkg/log"
 	"github.com/traefik/traefik/v2/pkg/middlewares"
@@ -52,7 +52,7 @@ func (c *compress) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 		c.next.ServeHTTP(rw, req)
 	} else {
 		ctx := middlewares.GetLoggerCtx(req.Context(), c.name, typeName)
-		gzipHandler(ctx, c.next).ServeHTTP(rw, req)
+		c.gzipHandler(ctx).ServeHTTP(rw, req)
 	}
 }
 
@@ -60,15 +60,16 @@ func (c *compress) GetTracingInformation() (string, ext.SpanKindEnum) {
 	return c.name, tracing.SpanKindNoneEnum
 }
 
-func gzipHandler(ctx context.Context, h http.Handler) http.Handler {
+func (c *compress) gzipHandler(ctx context.Context) http.Handler {
 	wrapper, err := gziphandler.GzipHandlerWithOpts(
+		gziphandler.ContentTypeExceptions(c.excludes),
 		gziphandler.CompressionLevel(gzip.DefaultCompression),
 		gziphandler.MinSize(gziphandler.DefaultMinSize))
 	if err != nil {
 		log.FromContext(ctx).Error(err)
 	}
 
-	return wrapper(h)
+	return wrapper(c.next)
 }
 
 func contains(values []string, val string) bool {

pkg/middlewares/compress/compress_test.go

@@ -7,9 +7,9 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/NYTimes/gziphandler"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/traefik/gziphandler"
 	"github.com/traefik/traefik/v2/pkg/config/dynamic"
 	"github.com/traefik/traefik/v2/pkg/testhelpers"
 )
@@ -91,25 +91,26 @@ func TestShouldNotCompressWhenNoAcceptEncodingHeader(t *testing.T) {
 func TestShouldNotCompressWhenSpecificContentType(t *testing.T) {
 	baseBody := generateBytes(gziphandler.DefaultMinSize)
 
-	next := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		_, err := rw.Write(baseBody)
-		if err != nil {
-			http.Error(rw, err.Error(), http.StatusInternalServerError)
-		}
-	})
-
 	testCases := []struct {
-		desc           string
-		conf           dynamic.Compress
-		reqContentType string
+		desc            string
+		conf            dynamic.Compress
+		reqContentType  string
+		respContentType string
 	}{
 		{
-			desc: "text/event-stream",
+			desc: "Exclude Request Content-Type",
 			conf: dynamic.Compress{
 				ExcludedContentTypes: []string{"text/event-stream"},
 			},
 			reqContentType: "text/event-stream",
 		},
+		{
+			desc: "Exclude Response Content-Type",
+			conf: dynamic.Compress{
+				ExcludedContentTypes: []string{"text/event-stream"},
+			},
+			respContentType: "text/event-stream",
+		},
 		{
 			desc:           "application/grpc",
 			conf:           dynamic.Compress{},
@@ -128,6 +129,17 @@ func TestShouldNotCompressWhenSpecificContentType(t *testing.T) {
 				req.Header.Add(contentTypeHeader, test.reqContentType)
 			}
 
+			next := http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+				if len(test.respContentType) > 0 {
+					rw.Header().Set(contentTypeHeader, test.respContentType)
+				}
+
+				_, err := rw.Write(baseBody)
+				if err != nil {
+					http.Error(rw, err.Error(), http.StatusInternalServerError)
+				}
+			})
+
 			handler, err := New(context.Background(), next, test.conf, "test")
 			require.NoError(t, err)
 

pkg/provider/acme/challenge_tls.go

@@ -39,8 +39,8 @@ func NewChallengeTLSALPN(timeout time.Duration) *ChallengeTLSALPN {
 
 // Present presents a challenge to obtain new ACME certificate.
 func (c *ChallengeTLSALPN) Present(domain, _, keyAuth string) error {
-	log.WithoutContext().WithField(log.ProviderName, providerNameALPN).
-		Debugf("TLS Challenge Present temp certificate for %s", domain)
+	logger := log.WithoutContext().WithField(log.ProviderName, providerNameALPN)
+	logger.Debugf("TLS Challenge Present temp certificate for %s", domain)
 
 	certPEMBlock, keyPEMBlock, err := tlsalpn01.ChallengeBlocks(domain, keyAuth)
 	if err != nil {
@@ -68,6 +68,12 @@ func (c *ChallengeTLSALPN) Present(domain, _, keyAuth string) error {
 	case t := <-timer.C:
 		timer.Stop()
 		close(c.chans[string(certPEMBlock)])
+
+		err = c.CleanUp(domain, "", keyAuth)
+		if err != nil {
+			logger.Errorf("Failed to clean up TLS challenge: %v", err)
+		}
+
 		errC = fmt.Errorf("timeout %s", t)
 	case <-ch:
 		// noop

pkg/provider/acme/provider.go

@@ -421,6 +421,7 @@ func (p *Provider) watchNewDomains(ctx context.Context) {
 					if route.TLS == nil || route.TLS.CertResolver != p.ResolverName {
 						continue
 					}
+
 					ctxRouter := log.With(ctx, log.Str(log.RouterName, routerName), log.Str(log.Rule, route.Rule))
 
 					tlsStore := "default"
@@ -462,6 +463,7 @@ func (p *Provider) resolveCertificate(ctx context.Context, domain types.Domain,
 	if len(uncheckedDomains) == 0 {
 		return nil, nil
 	}
+
 	defer p.removeResolvingDomains(uncheckedDomains)
 
 	logger := log.FromContext(ctx)