Add URL normalizePath() filter

docs/reference/filters.md

@@ -365,6 +365,32 @@ Parameters:
 The replacement may contain [template placeholders](#template-placeholders).
 If a template placeholder can't be resolved then empty value is used for it.
 
+### normalizePath
+
+Normalize the URL path by removing empty path segments and trailing slashes.
+
+Parameters:
+
+- The URL path
+
+Example:
+
+```
+all: * -> normalizePath() -> "https://backend.example.org/api/v1;
+```
+
+Requests to
+
+```
+https://backend.example.org//api/v1/
+https://backend.example.org//api/v1
+https://backend.example.org/api//v1
+https://backend.example.org/api//v1/
+https://backend.example.org/api/v1/
+```
+
+will all be normalized to `https://backend.example.org/api/v1`.

+
 ## HTTP Redirect
 ### redirectTo
 

filters/builtin/builtin.go

@@ -16,6 +16,7 @@ import (
 	"github.com/zalando/skipper/filters/fadein"
 	"github.com/zalando/skipper/filters/flowid"
 	logfilter "github.com/zalando/skipper/filters/log"
+	"github.com/zalando/skipper/filters/normalizepath"
 	"github.com/zalando/skipper/filters/rfc"
 	"github.com/zalando/skipper/filters/scheduler"
 	"github.com/zalando/skipper/filters/sed"
@@ -233,6 +234,7 @@ func Filters() []filters.Spec {
 		consistenthash.NewConsistentHashKey(),
 		consistenthash.NewConsistentHashBalanceFactor(),
 		tls.New(),
+		normalizepath.NewNormalizePath(),
 	}
 }
 

filters/filters.go

@@ -370,4 +370,5 @@ const (
 	SetFastCgiFilenameName = "setFastCgiFilename"
 	DisableRatelimitName   = "disableRatelimit"
 	UnknownRatelimitName   = "unknownRatelimit"
+	NormalizePath          = "normalizePath"
 )

filters/normalizepath/normalizepath.go

@@ -0,0 +1,38 @@
+package normalizepath
+
+import (
+	"strings"
+
+	"github.com/zalando/skipper/filters"
+)
+
+const (
+	Name = filters.NormalizePath
+)
+
+type normalizePath struct{}
+
+func NewNormalizePath() filters.Spec { return normalizePath{} }
+
+func (spec normalizePath) Name() string { return "normalizePath" }
+
+func (spec normalizePath) CreateFilter(config []interface{}) (filters.Filter, error) {
+	return normalizePath{}, nil
+}
+
+func (f normalizePath) Request(ctx filters.FilterContext) {
+	req := ctx.Request()
+
+	segments := strings.Split(req.URL.Path, "/")
+	var filteredSegments []string
+	for _, seg := range segments {
+		if seg != "" {
+			filteredSegments = append(filteredSegments, seg)
+		}
+	}
+	normalizedPath := "/" + strings.Join(filteredSegments, "/")
+
+	req.URL.Path = normalizedPath
+}
+
+func (f normalizePath) Response(ctx filters.FilterContext) {}

filters/normalizepath/normalizepath_test.go

@@ -0,0 +1,59 @@
+package normalizepath
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/zalando/skipper/filters/filtertest"
+)
+
+// TestNormalizePath tests the NormalizePath function in accordance to the
+// https://opensource.zalando.com/restful-api-guidelines/#136
+// specifically the notion of normalization of request paths:
+//
+// All services should normalize request paths before processing by removing
+// duplicate and trailing slashes. Hence, the following requests should refer
+// to the same resource:
+// GET /orders/{order-id}
+// GET /orders/{order-id}/
+// GET /orders//{order-id}
+func TestNormalizePath(t *testing.T) {
+	urls := []string{
+		"/orders/{order-id}",
+		"/orders/{order-id}/",
+		"/orders//{order-id}",
+		"/orders/{order-id}//",
+		"/orders/{order-id}///",
+		"/orders///{order-id}//",
+	}
+
+	for _, u := range urls {
+		req := &http.Request{URL: &url.URL{Path: u}}
+		ctx := &filtertest.Context{
+			FRequest: req,
+		}
+		f, err := NewNormalizePath().CreateFilter(nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		f.Request(ctx)
+		if req.URL.Path != "/orders/{order-id}" {
+			t.Errorf("failed to normalize the path: %s", req.URL.Path)
+		}
+	}
+
+	// Ensure that root paths work as expected
+	req := &http.Request{URL: &url.URL{Path: "/"}}
+	ctx := &filtertest.Context{
+		FRequest: req,
+	}
+	f, err := NewNormalizePath().CreateFilter(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	f.Request(ctx)
+	if req.URL.Path != "/" {
+		t.Errorf("unexpected URL path change: %s, expected /", req.URL.Path)
+	}
+}