Example #1
0
//FromRoute returns a route based on a previous route
func FromRoute(r *Route, path string) *Route {
	return RawRoute(path, flux.DoPushSocket(r.Valid, func(v interface{}, s flux.SocketInterface) {
		req, ok := v.(*Request)

		if !ok {
			return
		}

		nreq := FromRequest(req, nil)

		s.Emit(nreq)
	}), flux.PushSocket(r.DTO), r.DTO, r.fail)
}
Example #2
0
//InvertRoute returns a route based on a previous route rejection of a request
//provides a divert like or not path logic (i.e if that path does not match the parent route)
//then this gets validate that rejected route)
//the fail action can be set as nil which then uses the previous fail action from
//the previous route
func InvertRoute(r *Route, path string, fail Failure) *Route {
	valids := flux.DoPushSocket(r.Invalid, func(v interface{}, s flux.SocketInterface) {
		req, ok := v.(*Request)

		if !ok {
			return
		}

		s.Emit(req)
	})

	if fail == nil {
		fail = r.fail
	}

	return RawRoute(path, valids, flux.PushSocket(r.DTO), r.DTO, fail)
}
Example #3
0
//RawRoute returns a route struct for a specific route path
// which allows us to do NewRoute('{id:[/d+/]}')
//As far as operation is concerned any when a Route gets a path to validate
//against it first splits into into a list '/app/2/status' => ['app',2,'status']
//where each route within this route chain checks each first index and creates a new
//slice excluding that first index if the first value in the first index match its own
//rule and then pass it to the next route in its range else drops that packet into
//its Invalid socket, also all child routes that extend from a base will all recieve
//the parents Invalid socket so you can deal with routes that dont match in one place
func RawRoute(path string, base *flux.Push, invalid *flux.Push, ts int, fail Failure) *Route {
	if path == "" {
		panic("route path can not be an empty string")
	}

	m := reggy.GenerateClassicMatcher(path)
	r := &Route{
		base,
		make(map[string]*Route),
		m.Original,
		m,
		nil,
		invalid,
		ts,
		new(sync.RWMutex),
		fail,
	}

	//add new socket for valid routes and optional can made into payloadable
	r.Valid = flux.DoPushSocket(r, func(v interface{}, s flux.SocketInterface) {
		req, ok := v.(*Request)

		if !ok {
			return
		}

		if r.fail != nil {
			_, ok = req.Payload.(*PayloadRack)

			if !ok {

				var to int
				if req.Timeout == 0 {
					to = r.DTO
				} else {
					to = req.Timeout
				}

				py := req.Payload
				pl := NewPayloadRack(to, fail)

				req.Payload = pl
				pl.Load(py)
			}
		}

		f := req.Paths[0]

		ok = r.Pattern.Validate(f)

		if !ok {
			r.Invalid.Emit(req)
			return
		}

		req.Param = f

		s.Emit(req)
	})

	return r
}