Move code to pkg

pkg/middlewares/replacepathregex/replace_path_regex.go

@@ -0,0 +1,57 @@
+package replacepathregex
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/containous/traefik/pkg/config"
+	"github.com/containous/traefik/pkg/middlewares"
+	"github.com/containous/traefik/pkg/middlewares/replacepath"
+	"github.com/containous/traefik/pkg/tracing"
+	"github.com/opentracing/opentracing-go/ext"
+)
+
+const (
+	typeName = "ReplacePathRegex"
+)
+
+// ReplacePathRegex is a middleware used to replace the path of a URL request with a regular expression.
+type replacePathRegex struct {
+	next        http.Handler
+	regexp      *regexp.Regexp
+	replacement string
+	name        string
+}
+
+// New creates a new replace path regex middleware.
+func New(ctx context.Context, next http.Handler, config config.ReplacePathRegex, name string) (http.Handler, error) {
+	middlewares.GetLogger(ctx, name, typeName).Debug("Creating middleware")
+
+	exp, err := regexp.Compile(strings.TrimSpace(config.Regex))
+	if err != nil {
+		return nil, fmt.Errorf("error compiling regular expression %s: %s", config.Regex, err)
+	}
+
+	return &replacePathRegex{
+		regexp:      exp,
+		replacement: strings.TrimSpace(config.Replacement),
+		next:        next,
+		name:        name,
+	}, nil
+}
+
+func (rp *replacePathRegex) GetTracingInformation() (string, ext.SpanKindEnum) {
+	return rp.name, tracing.SpanKindNoneEnum
+}
+
+func (rp *replacePathRegex) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	if rp.regexp != nil && len(rp.replacement) > 0 && rp.regexp.MatchString(req.URL.Path) {
+		req.Header.Add(replacepath.ReplacedPathHeader, req.URL.Path)
+		req.URL.Path = rp.regexp.ReplaceAllString(req.URL.Path, rp.replacement)
+		req.RequestURI = req.URL.RequestURI()
+	}
+	rp.next.ServeHTTP(rw, req)
+}

pkg/middlewares/replacepathregex/replace_path_regex_test.go

@@ -0,0 +1,104 @@
+package replacepathregex
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/containous/traefik/pkg/config"
+	"github.com/containous/traefik/pkg/middlewares/replacepath"
+	"github.com/containous/traefik/pkg/testhelpers"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestReplacePathRegex(t *testing.T) {
+	testCases := []struct {
+		desc           string
+		path           string
+		config         config.ReplacePathRegex
+		expectedPath   string
+		expectedHeader string
+		expectsError   bool
+	}{
+		{
+			desc: "simple regex",
+			path: "/whoami/and/whoami",
+			config: config.ReplacePathRegex{
+				Replacement: "/who-am-i/$1",
+				Regex:       `^/whoami/(.*)`,
+			},
+			expectedPath:   "/who-am-i/and/whoami",
+			expectedHeader: "/whoami/and/whoami",
+		},
+		{
+			desc: "simple replace (no regex)",
+			path: "/whoami/and/whoami",
+			config: config.ReplacePathRegex{
+				Replacement: "/who-am-i",
+				Regex:       `/whoami`,
+			},
+			expectedPath:   "/who-am-i/and/who-am-i",
+			expectedHeader: "/whoami/and/whoami",
+		},
+		{
+			desc: "no match",
+			path: "/whoami/and/whoami",
+			config: config.ReplacePathRegex{
+				Replacement: "/whoami",
+				Regex:       `/no-match`,
+			},
+			expectedPath: "/whoami/and/whoami",
+		},
+		{
+			desc: "multiple replacement",
+			path: "/downloads/src/source.go",
+			config: config.ReplacePathRegex{
+				Replacement: "/downloads/$1-$2",
+				Regex:       `^(?i)/downloads/([^/]+)/([^/]+)$`,
+			},
+			expectedPath:   "/downloads/src-source.go",
+			expectedHeader: "/downloads/src/source.go",
+		},
+		{
+			desc: "invalid regular expression",
+			path: "/invalid/regexp/test",
+			config: config.ReplacePathRegex{
+				Replacement: "/valid/regexp/$1",
+				Regex:       `^(?err)/invalid/regexp/([^/]+)$`,
+			},
+			expectedPath: "/invalid/regexp/test",
+			expectsError: true,
+		},
+	}
+
+	for _, test := range testCases {
+		t.Run(test.desc, func(t *testing.T) {
+
+			var actualPath, actualHeader, requestURI string
+			next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				actualPath = r.URL.Path
+				actualHeader = r.Header.Get(replacepath.ReplacedPathHeader)
+				requestURI = r.RequestURI
+			})
+
+			handler, err := New(context.Background(), next, test.config, "foo-replace-path-regexp")
+			if test.expectsError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+
+				req := testhelpers.MustNewRequest(http.MethodGet, "http://localhost"+test.path, nil)
+				req.RequestURI = test.path
+
+				handler.ServeHTTP(nil, req)
+
+				assert.Equal(t, test.expectedPath, actualPath, "Unexpected path.")
+				assert.Equal(t, actualPath, requestURI, "Unexpected request URI.")
+				if test.expectedHeader != "" {
+					assert.Equal(t, test.expectedHeader, actualHeader, "Unexpected '%s' header.", replacepath.ReplacedPathHeader)
+				}
+			}
+		})
+	}
+}