228 lines
4.9 KiB
Go
228 lines
4.9 KiB
Go
package rules
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/containous/mux"
|
|
"github.com/containous/traefik/log"
|
|
"github.com/containous/traefik/middlewares/requestdecorator"
|
|
"github.com/vulcand/predicate"
|
|
)
|
|
|
|
var funcs = map[string]func(*mux.Route, ...string) error{
|
|
"Host": host,
|
|
"HostRegexp": hostRegexp,
|
|
"Path": path,
|
|
"PathPrefix": pathPrefix,
|
|
"Method": methods,
|
|
"Headers": headers,
|
|
"HeadersRegexp": headersRegexp,
|
|
"Query": query,
|
|
}
|
|
|
|
// Router handle routing with rules
|
|
type Router struct {
|
|
*mux.Router
|
|
parser predicate.Parser
|
|
}
|
|
|
|
// NewRouter returns a new router instance.
|
|
func NewRouter() (*Router, error) {
|
|
parser, err := newParser()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Router{
|
|
Router: mux.NewRouter().SkipClean(true),
|
|
parser: parser,
|
|
}, nil
|
|
}
|
|
|
|
// AddRoute add a new route to the router.
|
|
func (r *Router) AddRoute(rule string, priority int, handler http.Handler) error {
|
|
parse, err := r.parser.Parse(rule)
|
|
if err != nil {
|
|
return fmt.Errorf("error while parsing rule %s: %v", rule, err)
|
|
}
|
|
|
|
buildTree, ok := parse.(treeBuilder)
|
|
if !ok {
|
|
return fmt.Errorf("error while parsing rule %s", rule)
|
|
}
|
|
|
|
if priority == 0 {
|
|
priority = len(rule)
|
|
}
|
|
|
|
route := r.NewRoute().Handler(handler).Priority(priority)
|
|
return addRuleOnRoute(route, buildTree())
|
|
}
|
|
|
|
type tree struct {
|
|
matcher string
|
|
value []string
|
|
ruleLeft *tree
|
|
ruleRight *tree
|
|
}
|
|
|
|
func path(route *mux.Route, paths ...string) error {
|
|
rt := route.Subrouter()
|
|
|
|
for _, path := range paths {
|
|
tmpRt := rt.Path(path)
|
|
if tmpRt.GetError() != nil {
|
|
return tmpRt.GetError()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func pathPrefix(route *mux.Route, paths ...string) error {
|
|
rt := route.Subrouter()
|
|
|
|
for _, path := range paths {
|
|
tmpRt := rt.PathPrefix(path)
|
|
if tmpRt.GetError() != nil {
|
|
return tmpRt.GetError()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func host(route *mux.Route, hosts ...string) error {
|
|
for i, host := range hosts {
|
|
hosts[i] = strings.ToLower(host)
|
|
}
|
|
|
|
route.MatcherFunc(func(req *http.Request, _ *mux.RouteMatch) bool {
|
|
reqHost := requestdecorator.GetCanonizedHost(req.Context())
|
|
if len(reqHost) == 0 {
|
|
log.FromContext(req.Context()).Warnf("Could not retrieve CanonizedHost, rejecting %s", req.Host)
|
|
return false
|
|
}
|
|
|
|
flatH := requestdecorator.GetCNAMEFlatten(req.Context())
|
|
if len(flatH) > 0 {
|
|
for _, host := range hosts {
|
|
if strings.EqualFold(reqHost, host) || strings.EqualFold(flatH, host) {
|
|
return true
|
|
}
|
|
log.FromContext(req.Context()).Debugf("CNAMEFlattening: request %s which resolved to %s, is not matched to route %s", reqHost, flatH, host)
|
|
}
|
|
return false
|
|
}
|
|
|
|
for _, host := range hosts {
|
|
if reqHost == host {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func hostRegexp(route *mux.Route, hosts ...string) error {
|
|
router := route.Subrouter()
|
|
for _, host := range hosts {
|
|
tmpRt := router.Host(host)
|
|
if tmpRt.GetError() != nil {
|
|
return tmpRt.GetError()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func methods(route *mux.Route, methods ...string) error {
|
|
return route.Methods(methods...).GetError()
|
|
}
|
|
|
|
func headers(route *mux.Route, headers ...string) error {
|
|
return route.Headers(headers...).GetError()
|
|
}
|
|
|
|
func headersRegexp(route *mux.Route, headers ...string) error {
|
|
return route.HeadersRegexp(headers...).GetError()
|
|
}
|
|
|
|
func query(route *mux.Route, query ...string) error {
|
|
var queries []string
|
|
for _, elem := range query {
|
|
queries = append(queries, strings.Split(elem, "=")...)
|
|
}
|
|
|
|
route.Queries(queries...)
|
|
// Queries can return nil so we can't chain the GetError()
|
|
return route.GetError()
|
|
}
|
|
|
|
func addRuleOnRouter(router *mux.Router, rule *tree) error {
|
|
switch rule.matcher {
|
|
case "and":
|
|
route := router.NewRoute()
|
|
err := addRuleOnRoute(route, rule.ruleLeft)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return addRuleOnRoute(route, rule.ruleRight)
|
|
case "or":
|
|
err := addRuleOnRouter(router, rule.ruleLeft)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return addRuleOnRouter(router, rule.ruleRight)
|
|
default:
|
|
err := checkRule(rule)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return funcs[rule.matcher](router.NewRoute(), rule.value...)
|
|
}
|
|
}
|
|
|
|
func addRuleOnRoute(route *mux.Route, rule *tree) error {
|
|
switch rule.matcher {
|
|
case "and":
|
|
err := addRuleOnRoute(route, rule.ruleLeft)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return addRuleOnRoute(route, rule.ruleRight)
|
|
case "or":
|
|
subRouter := route.Subrouter()
|
|
|
|
err := addRuleOnRouter(subRouter, rule.ruleLeft)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return addRuleOnRouter(subRouter, rule.ruleRight)
|
|
default:
|
|
err := checkRule(rule)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return funcs[rule.matcher](route, rule.value...)
|
|
}
|
|
}
|
|
|
|
func checkRule(rule *tree) error {
|
|
if len(rule.value) == 0 {
|
|
return fmt.Errorf("no args for matcher %s", rule.matcher)
|
|
}
|
|
|
|
for _, v := range rule.value {
|
|
if len(v) == 0 {
|
|
return fmt.Errorf("empty args for matcher %s, %v", rule.matcher, rule.value)
|
|
}
|
|
}
|
|
return nil
|
|
}
|