traefik/server/router/rules.go
Ludovic Fernandez 04958c6951 Adds default rule system on Docker provider.
Co-authored-by: Julien Salleyron <julien@containo.us>
2019-01-21 19:06:02 +01:00

167 lines
3.8 KiB
Go

package router
import (
"context"
"fmt"
"net/http"
"strings"
"github.com/containous/mux"
"github.com/containous/traefik/log"
"github.com/containous/traefik/middlewares/requestdecorator"
)
func addRoute(ctx context.Context, router *mux.Router, rule string, priority int, handler http.Handler) error {
matchers, err := parseRule(rule)
if err != nil {
return err
}
if len(matchers) == 0 {
return fmt.Errorf("invalid rule: %s", rule)
}
if priority == 0 {
priority = len(rule)
}
route := router.NewRoute().Handler(handler).Priority(priority)
for _, matcher := range matchers {
matcher(route)
if route.GetError() != nil {
log.FromContext(ctx).Error(route.GetError())
}
}
return nil
}
func parseRule(rule string) ([]func(*mux.Route), error) {
funcs := map[string]func(*mux.Route, ...string){
"Host": host,
"HostRegexp": hostRegexp,
"Path": path,
"PathPrefix": pathPrefix,
"Method": methods,
"Headers": headers,
"HeadersRegexp": headersRegexp,
"Query": query,
}
splitRule := func(c rune) bool {
return c == ';'
}
parsedRules := strings.FieldsFunc(rule, splitRule)
var matchers []func(*mux.Route)
for _, expression := range parsedRules {
expParts := strings.Split(expression, ":")
if len(expParts) > 1 && len(expParts[1]) > 0 {
if fn, ok := funcs[expParts[0]]; ok {
parseOr := func(c rune) bool {
return c == ','
}
exp := strings.FieldsFunc(strings.Join(expParts[1:], ":"), parseOr)
var trimmedExp []string
for _, value := range exp {
trimmedExp = append(trimmedExp, strings.TrimSpace(value))
}
// FIXME struct for onhostrule ?
matcher := func(rt *mux.Route) {
fn(rt, trimmedExp...)
}
matchers = append(matchers, matcher)
} else {
return nil, fmt.Errorf("invalid matcher: %s", expression)
}
}
}
return matchers, nil
}
func path(route *mux.Route, paths ...string) {
rt := route.Subrouter()
for _, path := range paths {
tmpRt := rt.Path(path)
if tmpRt.GetError() != nil {
log.WithoutContext().WithField("paths", strings.Join(paths, ",")).Error(tmpRt.GetError())
}
}
}
func pathPrefix(route *mux.Route, paths ...string) {
rt := route.Subrouter()
for _, path := range paths {
tmpRt := rt.PathPrefix(path)
if tmpRt.GetError() != nil {
log.WithoutContext().WithField("paths", strings.Join(paths, ",")).Error(tmpRt.GetError())
}
}
}
func host(route *mux.Route, hosts ...string) {
for i, host := range hosts {
hosts[i] = strings.ToLower(host)
}
route.MatcherFunc(func(req *http.Request, route *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
})
}
func hostRegexp(route *mux.Route, hosts ...string) {
router := route.Subrouter()
for _, host := range hosts {
router.Host(host)
}
}
func methods(route *mux.Route, methods ...string) {
route.Methods(methods...)
}
func headers(route *mux.Route, headers ...string) {
route.Headers(headers...)
}
func headersRegexp(route *mux.Route, headers ...string) {
route.HeadersRegexp(headers...)
}
func query(route *mux.Route, query ...string) {
var queries []string
for _, elem := range query {
queries = append(queries, strings.Split(elem, "=")...)
}
route.Queries(queries...)
}