Merge pull request #435 from fclaeys/multiRules

Allow multiple rules

docs/basics.md

@@ -69,6 +69,8 @@ Frontends can be defined using the following rules:
 - `PathPrefix`: PathPrefix adds a matcher for the URL path prefixes. This matches if the given template is a prefix of the full URL path.
 - `PathPrefixStrip`: Same as `PathPrefix` but strip the given prefix from the request URL's Path.
 
+You can use multiple rules by separating them by `;`
+
 You can optionally enable `passHostHeader` to forward client `Host` header to the backend.
 
 Here is an example of frontends definition:
@@ -87,13 +89,13 @@ Here is an example of frontends definition:
     rule = "Host: localhost, {subdomain:[a-z]+}.localhost"
   [frontends.frontend3]
   backend = "backend2"
-    rule = "Path:/test"
+    rule = "Host: test3.localhost;Path:/test"
 ```
 
 - Three frontends are defined: `frontend1`, `frontend2` and `frontend3`
 - `frontend1` will forward the traffic to the `backend2` if the rule `Host: test.localhost, test2.localhost` is matched
 - `frontend2` will forward the traffic to the `backend1` if the rule `Host: localhost, {subdomain:[a-z]+}.localhost` is matched (forwarding client `Host` header to the backend)
-- `frontend3` will forward the traffic to the `backend2` if the rule `Path:/test` is matched
+- `frontend3` will forward the traffic to the `backend2` if the rules `Host: test3.localhost` and `Path:/test` are matched
 
 ## Backends
 

rules.go

@@ -109,23 +109,34 @@ func (r *Rules) Parse(expression string) (*mux.Route, error) {
 	f := func(c rune) bool {
 		return c == ':'
 	}
+
+	// Allow multiple rules separated by ;
+	splitRule := func(c rune) bool {
+		return c == ';'
+	}
+
+	parsedRules := strings.FieldsFunc(expression, splitRule)
+
+	var resultRoute *mux.Route
+
+	for _, rule := range parsedRules {
 		// get function
-	parsedFunctions := strings.FieldsFunc(expression, f)
+		parsedFunctions := strings.FieldsFunc(rule, f)
 		if len(parsedFunctions) == 0 {
-		return nil, errors.New("Error parsing rule: " + expression)
+			return nil, errors.New("Error parsing rule: " + rule)
 		}
 		parsedFunction, ok := functions[parsedFunctions[0]]
 		if !ok {
-		return nil, errors.New("Error parsing rule: " + expression + ". Unknown function: " + parsedFunctions[0])
+			return nil, errors.New("Error parsing rule: " + rule + ". Unknown function: " + parsedFunctions[0])
 		}
 		parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)
 		fargs := func(c rune) bool {
-		return c == ',' || c == ';'
+			return c == ','
 		}
 		// get function
 		parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
 		if len(parsedArgs) == 0 {
-		return nil, errors.New("Error parsing args from rule: " + expression)
+			return nil, errors.New("Error parsing args from rule: " + rule)
 		}
 
 		inputs := make([]reflect.Value, len(parsedArgs))
@@ -134,14 +145,17 @@ func (r *Rules) Parse(expression string) (*mux.Route, error) {
 		}
 		method := reflect.ValueOf(parsedFunction)
 		if method.IsValid() {
-		resultRoute := method.Call(inputs)[0].Interface().(*mux.Route)
+			resultRoute = method.Call(inputs)[0].Interface().(*mux.Route)
 			if r.err != nil {
 				return nil, r.err
 			}
 			if resultRoute.GetError() != nil {
 				return nil, resultRoute.GetError()
 			}
-		return resultRoute, nil
-	}
+
+		} else {
 			return nil, errors.New("Method not found: " + parsedFunctions[0])
 		}
+	}
+	return resultRoute, nil
+}

rules_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"github.com/gorilla/mux"
+	"net/http"
+	"testing"
+)
+
+func TestParseOneRule(t *testing.T) {
+
+	router := mux.NewRouter()
+	route := router.NewRoute()
+	serverRoute := &serverRoute{route: route}
+	rules := &Rules{route: serverRoute}
+
+	expression := "Host:foo.bar"
+	routeResult, err := rules.Parse(expression)
+
+	if err != nil {
+		t.Fatal("Error while building route for Host:foo.bar")
+	}
+
+	request, err := http.NewRequest("GET", "http://foo.bar", nil)
+	routeMatch := routeResult.Match(request, &mux.RouteMatch{Route: routeResult})
+
+	if routeMatch == false {
+		t.Log(err)
+		t.Fatal("Rule Host:foo.bar don't match")
+	}
+}
+
+func TestParseTwoRules(t *testing.T) {
+
+	router := mux.NewRouter()
+	route := router.NewRoute()
+	serverRoute := &serverRoute{route: route}
+	rules := &Rules{route: serverRoute}
+
+	expression := "Host:foo.bar;Path:/foobar"
+	routeResult, err := rules.Parse(expression)
+
+	if err != nil {
+		t.Fatal("Error while building route for Host:foo.bar;Path:/foobar")
+	}
+
+	request, err := http.NewRequest("GET", "http://foo.bar/foobar", nil)
+	routeMatch := routeResult.Match(request, &mux.RouteMatch{Route: routeResult})
+
+	if routeMatch == false {
+		t.Log(err)
+		t.Fatal("Rule Host:foo.bar;Path:/foobar don't match")
+	}
+}