package main import ( "errors" "github.com/gorilla/mux" "net" "net/http" "reflect" "sort" "strings" ) // Rules holds rule parsing and configuration type Rules struct { route *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 reqHost == strings.TrimSpace(host) { return true } } return false }) } func (r *Rules) hostRegexp(hosts ...string) *mux.Route { router := r.route.route.Subrouter() for _, host := range hosts { router.Host(strings.TrimSpace(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 { router.PathPrefix(strings.TrimSpace(path)) } return r.route.route } 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) pathPrefixStrip(paths ...string) *mux.Route { sort.Sort(bySize(paths)) r.route.stripPrefixes = 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...) } // Parse parses rules expressions func (r *Rules) Parse(expression string) (*mux.Route, error) { functions := map[string]interface{}{ "Host": r.host, "HostRegexp": r.hostRegexp, "Path": r.path, "PathStrip": r.pathStrip, "PathPrefix": r.pathPrefix, "PathPrefixStrip": r.pathPrefixStrip, "Method": r.methods, "Headers": r.headers, "HeadersRegexp": r.headersRegexp, } f := func(c rune) bool { return c == ':' } // get function parsedFunctions := strings.FieldsFunc(expression, f) if len(parsedFunctions) == 0 { return nil, errors.New("Error parsing rule: " + expression) } parsedFunction, ok := functions[parsedFunctions[0]] if !ok { return nil, errors.New("Error parsing rule: " + expression + ". Unknown function: " + parsedFunctions[0]) } parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...) fargs := func(c rune) bool { return c == ',' || c == ';' } // get function parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs) if len(parsedArgs) == 0 { return nil, errors.New("Error parsing args from rule: " + expression) } inputs := make([]reflect.Value, len(parsedArgs)) for i := range parsedArgs { inputs[i] = reflect.ValueOf(parsedArgs[i]) } method := reflect.ValueOf(parsedFunction) if method.IsValid() { 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 } return nil, errors.New("Method not found: " + parsedFunctions[0]) }