traefik/rules/rules.go

321 lines
8.3 KiB
Go
Raw Normal View History

package rules
import (
"errors"
"fmt"
"net/http"
"reflect"
"sort"
"strings"
"github.com/containous/mux"
2018-07-03 14:44:05 +00:00
"github.com/containous/traefik/hostresolver"
"github.com/containous/traefik/log"
"github.com/containous/traefik/middlewares"
"github.com/containous/traefik/types"
)
// Rules holds rule parsing and configuration
type Rules struct {
2018-07-03 14:44:05 +00:00
Route *types.ServerRoute
err error
HostResolver *hostresolver.Resolver
}
func (r *Rules) host(hosts ...string) *mux.Route {
for i, host := range hosts {
hosts[i] = strings.ToLower(host)
}
return r.Route.Route.MatcherFunc(func(req *http.Request, route *mux.RouteMatch) bool {
reqHost := middlewares.GetCanonizedHost(req.Context())
if len(reqHost) == 0 {
return false
}
2018-07-03 14:44:05 +00:00
if r.HostResolver != nil && r.HostResolver.CnameFlattening {
reqH, flatH := r.HostResolver.CNAMEFlatten(reqHost)
2018-07-03 14:44:05 +00:00
for _, host := range hosts {
if strings.EqualFold(reqH, host) || strings.EqualFold(flatH, host) {
2018-07-03 14:44:05 +00:00
return true
}
log.Debugf("CNAMEFlattening: request %s which resolved to %s, is not matched to route %s", reqH, flatH, host)
}
return false
}
for _, host := range hosts {
if reqHost == host {
return true
}
}
return false
})
}
2018-10-25 08:18:03 +00:00
func (r *Rules) hostRegexp(hostPatterns ...string) *mux.Route {
router := r.Route.Route.Subrouter()
2018-10-25 08:18:03 +00:00
for _, hostPattern := range hostPatterns {
router.Host(hostPattern)
}
return r.Route.Route
}
func (r *Rules) path(paths ...string) *mux.Route {
router := r.Route.Route.Subrouter()
for _, path := range paths {
router.Path(path)
}
return r.Route.Route
}
func (r *Rules) pathPrefix(paths ...string) *mux.Route {
router := r.Route.Route.Subrouter()
for _, path := range paths {
2017-12-19 16:00:12 +00:00
buildPath(path, router)
}
return r.Route.Route
}
2017-12-19 16:00:12 +00:00
func buildPath(path string, router *mux.Router) {
// {} 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(path, "{") {
router.PathPrefix(path)
2017-12-19 16:00:12 +00:00
} else {
m := &prefixMatcher{prefix: path}
2017-12-19 16:00:12 +00:00
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 {
2016-11-17 14:36:10 +00:00
router.Path(strings.TrimSpace(path))
}
return r.Route.Route
}
2017-03-24 11:07:59 +00:00
func (r *Rules) pathStripRegex(paths ...string) *mux.Route {
sort.Sort(bySize(paths))
r.Route.StripPrefixesRegex = paths
router := r.Route.Route.Subrouter()
2017-03-24 11:07:59 +00:00
for _, path := range paths {
router.Path(path)
2017-03-24 11:07:59 +00:00
}
return r.Route.Route
2017-03-24 11:07:59 +00:00
}
2017-04-25 18:13:39 +00:00
func (r *Rules) replacePath(paths ...string) *mux.Route {
for _, path := range paths {
r.Route.ReplacePath = path
2017-04-25 18:13:39 +00:00
}
return r.Route.Route
2017-04-25 18:13:39 +00:00
}
2017-10-30 11:54:03 +00:00
func (r *Rules) replacePathRegex(paths ...string) *mux.Route {
for _, path := range paths {
r.Route.ReplacePathRegex = path
2017-10-30 11:54:03 +00:00
}
return r.Route.Route
2017-10-30 11:54:03 +00:00
}
2016-12-02 12:40:18 +00:00
func (r *Rules) addPrefix(paths ...string) *mux.Route {
for _, path := range paths {
r.Route.AddPrefix = path
2016-12-02 12:40:18 +00:00
}
return r.Route.Route
2016-12-02 12:40:18 +00:00
}
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 {
2017-12-19 16:00:12 +00:00
buildPath(path, router)
}
return r.Route.Route
}
2017-03-24 11:07:59 +00:00
func (r *Rules) pathPrefixStripRegex(paths ...string) *mux.Route {
sort.Sort(bySize(paths))
r.Route.StripPrefixesRegex = paths
router := r.Route.Route.Subrouter()
2017-03-24 11:07:59 +00:00
for _, path := range paths {
router.PathPrefix(path)
2017-03-24 11:07:59 +00:00
}
return r.Route.Route
2017-03-24 11:07:59 +00:00
}
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...)
}
2017-08-24 18:28:03 +00:00
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...)
2017-08-24 18:28:03 +00:00
}
func (r *Rules) parseRules(expression string, onRule func(functionName string, function interface{}, arguments []string) error) error {
functions := map[string]interface{}{
2017-03-24 11:07:59 +00:00
"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,
2017-10-30 11:54:03 +00:00
"ReplacePathRegex": r.replacePathRegex,
2017-08-24 18:28:03 +00:00
"Query": r.query,
}
if len(expression) == 0 {
2018-03-23 12:30:03 +00:00
return errors.New("empty rule")
}
f := func(c rune) bool {
return c == ':'
}
2016-06-06 07:21:00 +00:00
// Allow multiple rules separated by ;
splitRule := func(c rune) bool {
return c == ';'
}
2016-06-06 07:21:00 +00:00
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)
2016-06-06 07:21:00 +00:00
}
2018-03-23 12:30:03 +00:00
functionName := strings.TrimSpace(parsedFunctions[0])
parsedFunction, ok := functions[functionName]
2016-06-06 07:21:00 +00:00
if !ok {
return fmt.Errorf("error parsing rule: '%s'. Unknown function: '%s'", rule, parsedFunctions[0])
}
2016-06-06 07:21:00 +00:00
parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...)
2018-03-23 12:30:03 +00:00
// get function
2016-06-06 07:21:00 +00:00
fargs := func(c rune) bool {
return c == ','
}
parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs)
if len(parsedArgs) == 0 {
return fmt.Errorf("error parsing args from rule: '%s'", rule)
2016-06-06 07:21:00 +00:00
}
for i := range parsedArgs {
parsedArgs[i] = strings.TrimSpace(parsedArgs[i])
2016-06-06 07:21:00 +00:00
}
err := onRule(functionName, parsedFunction, parsedArgs)
if err != nil {
2018-03-23 12:30:03 +00:00
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
2018-03-23 12:30:03 +00:00
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)
2016-06-06 07:21:00 +00:00
if method.IsValid() {
resultRoute = method.Call(inputs)[0].Interface().(*mux.Route)
if r.err != nil {
return r.err
2016-06-06 07:21:00 +00:00
}
2018-10-04 08:20:03 +00:00
if resultRoute == nil {
return fmt.Errorf("invalid expression: %s", expression)
}
2016-06-06 07:21:00 +00:00
if resultRoute.GetError() != nil {
return resultRoute.GetError()
2016-06-06 07:21:00 +00:00
}
} else {
2018-03-23 12:30:03 +00:00
return fmt.Errorf("method not found: '%s'", functionName)
}
return nil
})
if err != nil {
return nil, fmt.Errorf("error parsing rule: %v", err)
}
2018-03-23 12:30:03 +00:00
2016-06-06 07:21:00 +00:00
return resultRoute, nil
}
// ParseDomains parses rules expressions and returns domains
func (r *Rules) ParseDomains(expression string) ([]string, error) {
2018-03-23 12:30:03 +00:00
var domains []string
isHostRule := false
2018-03-23 12:30:03 +00:00
err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error {
if functionName == "Host" {
isHostRule = true
domains = append(domains, arguments...)
}
return nil
})
if err != nil {
return nil, fmt.Errorf("error parsing domains: %v", err)
}
2018-03-23 12:30:03 +00:00
var cleanDomains []string
for _, domain := range domains {
2018-09-07 08:11:30 +00:00
canonicalDomain := strings.ToLower(domain)
if len(canonicalDomain) > 0 {
cleanDomains = append(cleanDomains, canonicalDomain)
}
}
// Return an error if an Host rule is detected but no domain are parsed
if isHostRule && len(cleanDomains) == 0 {
return nil, fmt.Errorf("unable to parse correctly the domains in the Host rule from %q", expression)
}
return cleanDomains, nil
}