Пример #1
0
// ThenFlat provides a binary operation for handling routing using flatchains,it inspects the requests where
// if it matches the given criteria passes off to the supplied Chain else passes it down its own chain scope
func ThenFlat(methods, pattern string, pass FlatChains, log *log.Logger) FlatChains {
	var rmethods = GetMethods(methods)
	var rxc = reggy.CreateClassic(pattern)

	return NewFlatChain(func(c *Context, next NextHandler) {
		req := c.Req
		res := c.Res
		method := req.Method
		url := req.URL.Path

		//ok we have no method restrictions or we have the method,so we can continue else ignore
		if len(rmethods) == 0 || HasMethod(rmethods, method) {
			ok, param := rxc.Validate(url)
			// not good, so ignore
			if ok {
				//ok we got a hit, copy over the parameters
				pass.Handle(res, req, Collector(param))
			} else {
				c.Copy(param)
				next(c)
			}
		} else {
			next(c)
		}
	}, log)
}
Пример #2
0
// BareRule defines a matching rule for a specified pattern
func (r *ChainRouter) BareRule(mo, pattern string, fx RHandler) {
	methods := GetMethods(mo)
	patt := reggy.CreateClassic(pattern)
	cr := &ChainRouta{ClassicMatchMux: patt, Handler: BuildMatchesMethod(methods, fx)}
	r.wg.Lock()
	defer r.wg.Unlock()
	r.paths = append(r.paths, cr)
}
Пример #3
0
// Rule defines a matching rule which returns a flatchain
func (r *ChainRouter) Rule(mo, pattern string, fx FlatHandler) FlatChains {
	if fx == nil {
		fx = IdentityCall
	}
	methods := GetMethods(mo)
	patt := reggy.CreateClassic(pattern)
	fr := FlatRouteBuild(methods, patt, fx, r.Log)
	cr := &ChainRouta{ClassicMatchMux: patt, Handler: fr.Handle}
	r.wg.Lock()
	defer r.wg.Unlock()
	r.paths = append(r.paths, cr)
	return fr
}
Пример #4
0
// Add adds a route into the sets of routes, method can be "" to allow all methods to be handled or a stringed range eg "get head put" to allow this range of methods(get,head,put) only for the handler
func (r *Routes) Add(mo, pattern string, h RHandler) {
	r.ro.Lock()
	defer r.ro.Unlock()

	var methods []string

	if mo != "" {
		cln := multispaces.ReplaceAllString(mo, " ")
		methods = multispaces.Split(cln, -1)
	}

	if router, ok := r.routes[pattern]; ok {
		for _, ro := range methods {
			if _, ok := router.method[ro]; !ok {
				router.method[ro] = h
			}
		}
		return
	}

	var fatt string

	if r.namespace != "" {
		fatt = reggy.CleanPath(fmt.Sprintf("/%s/%s", r.namespace, pattern))
	} else {
		fatt = pattern
	}

	var mod = make(map[string]RHandler)

	for _, ro := range methods {
		mod[ro] = h
	}

	r.routes[pattern] = &Route{
		ClassicMatchMux: reggy.CreateClassic(fatt),
		handler:         h,
		method:          mod,
		nomethod:        len(mod) == 0,
	}
}
Пример #5
0
// FlatRoute provides a new routing system based on the middleware stack and if a request matches
// then its passed down the chain else ignored
func FlatRoute(methods, pattern string, fx FlatHandler, lg *log.Logger) FlatChains {
	return FlatRouteBuild(GetMethods(methods), reggy.CreateClassic(pattern), fx, lg)
}