Externalize Træfik rules in a dedicated package

rules/rules.go

@@ -0,0 +1,280 @@
+package rules
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/BurntSushi/ty/fun"
+	"github.com/containous/mux"
+	"github.com/containous/traefik/types"
+)
+
+// Rules holds rule parsing and configuration
+type Rules struct {
+	Route *types.ServerRoute
+	err   error
+}
+
+func (r *Rules) host(hosts ...string) *mux.Route {
+	return r.Route.Route.MatcherFunc(func(req *http.Request, route *mux.RouteMatch) bool {
+		reqHost, _, err := net.SplitHostPort(req.Host)
+		if err != nil {
+			reqHost = req.Host
+		}
+		for _, host := range hosts {
+			if types.CanonicalDomain(reqHost) == types.CanonicalDomain(host) {
+				return true
+			}
+		}
+		return false
+	})
+}
+
+func (r *Rules) hostRegexp(hosts ...string) *mux.Route {
+	router := r.Route.Route.Subrouter()
+	for _, host := range hosts {
+		router.Host(types.CanonicalDomain(host))
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) path(paths ...string) *mux.Route {
+	router := r.Route.Route.Subrouter()
+	for _, path := range paths {
+		router.Path(strings.TrimSpace(path))
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) pathPrefix(paths ...string) *mux.Route {
+	router := r.Route.Route.Subrouter()
+	for _, path := range paths {
+		buildPath(path, router)
+	}
+	return r.Route.Route
+}
+
+func buildPath(path string, router *mux.Router) {
+	cleanPath := strings.TrimSpace(path)
+	// {} are used to define a regex pattern in http://www.gorillatoolkit.org/pkg/mux.
+	// if we find a { in the path, that means we use regex, then the gorilla/mux implementation is chosen
+	// otherwise, we use a lightweight implementation
+	if strings.Contains(cleanPath, "{") {
+		router.PathPrefix(cleanPath)
+	} else {
+		m := &prefixMatcher{prefix: cleanPath}
+		router.NewRoute().MatcherFunc(m.Match)
+	}
+}
+
+type prefixMatcher struct {
+	prefix string
+}
+
+func (m *prefixMatcher) Match(r *http.Request, _ *mux.RouteMatch) bool {
+	return strings.HasPrefix(r.URL.Path, m.prefix) || strings.HasPrefix(r.URL.Path, m.prefix+"/")
+}
+
+type bySize []string
+
+func (a bySize) Len() int           { return len(a) }
+func (a bySize) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a bySize) Less(i, j int) bool { return len(a[i]) > len(a[j]) }
+
+func (r *Rules) pathStrip(paths ...string) *mux.Route {
+	sort.Sort(bySize(paths))
+	r.Route.StripPrefixes = paths
+	router := r.Route.Route.Subrouter()
+	for _, path := range paths {
+		router.Path(strings.TrimSpace(path))
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) pathStripRegex(paths ...string) *mux.Route {
+	sort.Sort(bySize(paths))
+	r.Route.StripPrefixesRegex = paths
+	router := r.Route.Route.Subrouter()
+	for _, path := range paths {
+		router.Path(strings.TrimSpace(path))
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) replacePath(paths ...string) *mux.Route {
+	for _, path := range paths {
+		r.Route.ReplacePath = path
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) replacePathRegex(paths ...string) *mux.Route {
+	for _, path := range paths {
+		r.Route.ReplacePathRegex = path
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) addPrefix(paths ...string) *mux.Route {
+	for _, path := range paths {
+		r.Route.AddPrefix = path
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) pathPrefixStrip(paths ...string) *mux.Route {
+	sort.Sort(bySize(paths))
+	r.Route.StripPrefixes = paths
+	router := r.Route.Route.Subrouter()
+	for _, path := range paths {
+		buildPath(path, router)
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) pathPrefixStripRegex(paths ...string) *mux.Route {
+	sort.Sort(bySize(paths))
+	r.Route.StripPrefixesRegex = paths
+	router := r.Route.Route.Subrouter()
+	for _, path := range paths {
+		router.PathPrefix(strings.TrimSpace(path))
+	}
+	return r.Route.Route
+}
+
+func (r *Rules) methods(methods ...string) *mux.Route {
+	return r.Route.Route.Methods(methods...)
+}
+
+func (r *Rules) headers(headers ...string) *mux.Route {
+	return r.Route.Route.Headers(headers...)
+}
+
+func (r *Rules) headersRegexp(headers ...string) *mux.Route {
+	return r.Route.Route.HeadersRegexp(headers...)
+}
+
+func (r *Rules) query(query ...string) *mux.Route {
+	var queries []string
+	for _, elem := range query {
+		queries = append(queries, strings.Split(elem, "=")...)
+	}
+
+	return r.Route.Route.Queries(queries...)
+}
+
+func (r *Rules) parseRules(expression string, onRule func(functionName string, function interface{}, arguments []string) error) error {
+	functions := map[string]interface{}{
+		"Host":                 r.host,
+		"HostRegexp":           r.hostRegexp,
+		"Path":                 r.path,
+		"PathStrip":            r.pathStrip,
+		"PathStripRegex":       r.pathStripRegex,
+		"PathPrefix":           r.pathPrefix,
+		"PathPrefixStrip":      r.pathPrefixStrip,
+		"PathPrefixStripRegex": r.pathPrefixStripRegex,
+		"Method":               r.methods,
+		"Headers":              r.headers,
+		"HeadersRegexp":        r.headersRegexp,
+		"AddPrefix":            r.addPrefix,
+		"ReplacePath":          r.replacePath,
+		"ReplacePathRegex":     r.replacePathRegex,
+		"Query":                r.query,
+	}
+
+	if len(expression) == 0 {
+		return errors.New("Empty rule")
+	}
+
+	f := func(c rune) bool {
+		return c == ':'
+	}
+
+	// Allow multiple rules separated by ;
+	splitRule := func(c rune) bool {
+		return c == ';'
+	}
+
+	parsedRules := strings.FieldsFunc(expression, splitRule)
+
+	for _, rule := range parsedRules {
+		// get function
+		parsedFunctions := strings.FieldsFunc(rule, f)
+		if len(parsedFunctions) == 0 {
+			return fmt.Errorf("error parsing rule: '%s'", rule)
+		}
+		functionName := strings.TrimSpace(parsedFunctions[0])
+		parsedFunction, ok := functions[functionName]
+		if !ok {
+			return fmt.Errorf("error parsing rule: '%s'. Unknown function: '%s'", rule, parsedFunctions[0])
+		}
+		parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)
+		fargs := func(c rune) bool {
+			return c == ','
+		}
+		// get function
+		parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
+		if len(parsedArgs) == 0 {
+			return fmt.Errorf("error parsing args from rule: '%s'", rule)
+		}
+
+		for i := range parsedArgs {
+			parsedArgs[i] = strings.TrimSpace(parsedArgs[i])
+		}
+
+		err := onRule(functionName, parsedFunction, parsedArgs)
+		if err != nil {
+			return fmt.Errorf("Parsing error on rule: %v", err)
+		}
+	}
+	return nil
+}
+
+// Parse parses rules expressions
+func (r *Rules) Parse(expression string) (*mux.Route, error) {
+	var resultRoute *mux.Route
+	err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error {
+		inputs := make([]reflect.Value, len(arguments))
+		for i := range arguments {
+			inputs[i] = reflect.ValueOf(arguments[i])
+		}
+		method := reflect.ValueOf(function)
+		if method.IsValid() {
+			resultRoute = method.Call(inputs)[0].Interface().(*mux.Route)
+			if r.err != nil {
+				return r.err
+			}
+			if resultRoute.GetError() != nil {
+				return resultRoute.GetError()
+			}
+
+		} else {
+			return fmt.Errorf("Method not found: '%s'", functionName)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("error parsing rule: %v", err)
+	}
+	return resultRoute, nil
+}
+
+// ParseDomains parses rules expressions and returns domains
+func (r *Rules) ParseDomains(expression string) ([]string, error) {
+	domains := []string{}
+	err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error {
+		if functionName == "Host" {
+			domains = append(domains, arguments...)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("error parsing domains: %v", err)
+	}
+	return fun.Map(types.CanonicalDomain, domains).([]string), nil
+}

rules/rules_test.go

@@ -0,0 +1,259 @@
+package rules
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"github.com/containous/mux"
+	"github.com/containous/traefik/testhelpers"
+	"github.com/containous/traefik/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseOneRule(t *testing.T) {
+	router := mux.NewRouter()
+	route := router.NewRoute()
+	serverRoute := &types.ServerRoute{Route: route}
+	rules := &Rules{Route: serverRoute}
+
+	expression := "Host:foo.bar"
+	routeResult, err := rules.Parse(expression)
+	require.NoError(t, err, "Error while building route for %s", expression)
+
+	request := testhelpers.MustNewRequest(http.MethodGet, "http://foo.bar", nil)
+	routeMatch := routeResult.Match(request, &mux.RouteMatch{Route: routeResult})
+
+	assert.True(t, routeMatch, "Rule %s don't match.", expression)
+}
+
+func TestParseTwoRules(t *testing.T) {
+	router := mux.NewRouter()
+	route := router.NewRoute()
+	serverRoute := &types.ServerRoute{Route: route}
+	rules := &Rules{Route: serverRoute}
+
+	expression := "Host: Foo.Bar ; Path:/FOObar"
+	routeResult, err := rules.Parse(expression)
+
+	require.NoError(t, err, "Error while building route for %s.", expression)
+
+	request := testhelpers.MustNewRequest(http.MethodGet, "http://foo.bar/foobar", nil)
+	routeMatch := routeResult.Match(request, &mux.RouteMatch{Route: routeResult})
+
+	assert.False(t, routeMatch, "Rule %s don't match.", expression)
+
+	request = testhelpers.MustNewRequest(http.MethodGet, "http://foo.bar/FOObar", nil)
+	routeMatch = routeResult.Match(request, &mux.RouteMatch{Route: routeResult})
+
+	assert.True(t, routeMatch, "Rule %s don't match.", expression)
+}
+
+func TestParseDomains(t *testing.T) {
+	rules := &Rules{}
+
+	tests := []struct {
+		expression string
+		domain     []string
+	}{
+		{
+			expression: "Host:foo.bar,test.bar",
+			domain:     []string{"foo.bar", "test.bar"},
+		},
+		{
+			expression: "Path:/test",
+			domain:     []string{},
+		},
+		{
+			expression: "Host:foo.bar;Path:/test",
+			domain:     []string{"foo.bar"},
+		},
+		{
+			expression: "Host: Foo.Bar ;Path:/test",
+			domain:     []string{"foo.bar"},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.expression, func(t *testing.T) {
+			t.Parallel()
+
+			domains, err := rules.ParseDomains(test.expression)
+			require.NoError(t, err, "%s: Error while parsing domain.", test.expression)
+
+			assert.EqualValues(t, test.domain, domains, "%s: Error parsing domains from expression.", test.expression)
+		})
+	}
+}
+
+func TestPriorites(t *testing.T) {
+	router := mux.NewRouter()
+	router.StrictSlash(true)
+	rules := &Rules{Route: &types.ServerRoute{Route: router.NewRoute()}}
+	expression01 := "PathPrefix:/foo"
+
+	routeFoo, err := rules.Parse(expression01)
+	require.NoError(t, err, "Error while building route for %s", expression01)
+
+	fooHandler := &fakeHandler{name: "fooHandler"}
+	routeFoo.Handler(fooHandler)
+
+	routeMatch := router.Match(&http.Request{URL: &url.URL{Path: "/foo"}}, &mux.RouteMatch{})
+	assert.True(t, routeMatch, "Error matching route")
+
+	routeMatch = router.Match(&http.Request{URL: &url.URL{Path: "/fo"}}, &mux.RouteMatch{})
+	assert.False(t, routeMatch, "Error matching route")
+
+	multipleRules := &Rules{Route: &types.ServerRoute{Route: router.NewRoute()}}
+	expression02 := "PathPrefix:/foobar"
+
+	routeFoobar, err := multipleRules.Parse(expression02)
+	require.NoError(t, err, "Error while building route for %s", expression02)
+
+	foobarHandler := &fakeHandler{name: "foobarHandler"}
+	routeFoobar.Handler(foobarHandler)
+	routeMatch = router.Match(&http.Request{URL: &url.URL{Path: "/foo"}}, &mux.RouteMatch{})
+
+	assert.True(t, routeMatch, "Error matching route")
+
+	fooMatcher := &mux.RouteMatch{}
+	routeMatch = router.Match(&http.Request{URL: &url.URL{Path: "/foobar"}}, fooMatcher)
+
+	assert.True(t, routeMatch, "Error matching route")
+	assert.NotEqual(t, fooMatcher.Handler, foobarHandler, "Error matching priority")
+	assert.Equal(t, fooMatcher.Handler, fooHandler, "Error matching priority")
+
+	routeFoo.Priority(1)
+	routeFoobar.Priority(10)
+	router.SortRoutes()
+
+	foobarMatcher := &mux.RouteMatch{}
+	routeMatch = router.Match(&http.Request{URL: &url.URL{Path: "/foobar"}}, foobarMatcher)
+
+	assert.True(t, routeMatch, "Error matching route")
+	assert.Equal(t, foobarMatcher.Handler, foobarHandler, "Error matching priority")
+	assert.NotEqual(t, foobarMatcher.Handler, fooHandler, "Error matching priority")
+}
+
+func TestHostRegexp(t *testing.T) {
+	testCases := []struct {
+		desc    string
+		hostExp string
+		urls    map[string]bool
+	}{
+		{
+			desc:    "capturing group",
+			hostExp: "{subdomain:(foo\\.)?bar\\.com}",
+			urls: map[string]bool{
+				"http://foo.bar.com": true,
+				"http://bar.com":     true,
+				"http://fooubar.com": false,
+				"http://barucom":     false,
+				"http://barcom":      false,
+			},
+		},
+		{
+			desc:    "non capturing group",
+			hostExp: "{subdomain:(?:foo\\.)?bar\\.com}",
+			urls: map[string]bool{
+				"http://foo.bar.com": true,
+				"http://bar.com":     true,
+				"http://fooubar.com": false,
+				"http://barucom":     false,
+				"http://barcom":      false,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			rls := &Rules{
+				Route: &types.ServerRoute{
+					Route: &mux.Route{},
+				},
+			}
+
+			rt := rls.hostRegexp(test.hostExp)
+
+			for testURL, match := range test.urls {
+				req := testhelpers.MustNewRequest(http.MethodGet, testURL, nil)
+				assert.Equal(t, match, rt.Match(req, &mux.RouteMatch{}))
+			}
+		})
+	}
+}
+
+type fakeHandler struct {
+	name string
+}
+
+func (h *fakeHandler) ServeHTTP(http.ResponseWriter, *http.Request) {}
+
+func TestPathPrefix(t *testing.T) {
+	testCases := []struct {
+		desc string
+		path string
+		urls map[string]bool
+	}{
+		{
+			desc: "leading slash",
+			path: "/bar",
+			urls: map[string]bool{
+				"http://foo.com/bar":  true,
+				"http://foo.com/bar/": true,
+			},
+		},
+		{
+			desc: "leading trailing slash",
+			path: "/bar/",
+			urls: map[string]bool{
+				"http://foo.com/bar":  false,
+				"http://foo.com/bar/": true,
+			},
+		},
+		{
+			desc: "no slash",
+			path: "bar",
+			urls: map[string]bool{
+				"http://foo.com/bar":  false,
+				"http://foo.com/bar/": false,
+			},
+		},
+		{
+			desc: "trailing slash",
+			path: "bar/",
+			urls: map[string]bool{
+				"http://foo.com/bar":  false,
+				"http://foo.com/bar/": false,
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			rls := &Rules{
+				Route: &types.ServerRoute{
+					Route: &mux.Route{},
+				},
+			}
+
+			rt := rls.pathPrefix(test.path)
+
+			for testURL, expectedMatch := range test.urls {
+				req := testhelpers.MustNewRequest(http.MethodGet, testURL, nil)
+				match := rt.Match(req, &mux.RouteMatch{})
+				if match != expectedMatch {
+					t.Errorf("Error matching %s with %s, got %v expected %v", test.path, testURL, match, expectedMatch)
+				}
+			}
+		})
+	}
+}