Example #1
0
func (r *Trie) Insert(uri route.Uri, value *route.Pool) *Trie {
	key := strings.TrimPrefix(uri.String(), "/")
	node := r

	for {
		pathParts := parts(key)
		SegmentValue := pathParts[0]

		matchingChild, ok := node.ChildNodes[SegmentValue]

		if !ok {
			matchingChild = NewTrie()
			matchingChild.Segment = SegmentValue
			matchingChild.Parent = node
			node.ChildNodes[SegmentValue] = matchingChild
		}

		node = matchingChild

		if len(pathParts) != 2 {
			break
		}

		key = pathParts[1]
	}

	node.Pool = value
	return node
}
Example #2
0
func (r *Trie) Find(uri route.Uri) (*route.Pool, bool) {
	key := strings.TrimPrefix(uri.String(), "/")
	node := r

	for {
		pathParts := parts(key)
		SegmentValue := pathParts[0]

		matchingChild, ok := node.ChildNodes[SegmentValue]
		if !ok {
			return nil, false
		}

		node = matchingChild

		if len(pathParts) <= 1 {
			break
		}

		key = pathParts[1]
	}

	if nil != node.Pool {
		return node.Pool, true
	}

	return nil, false
}
Example #3
0
func (r *Trie) Delete(uri route.Uri) bool {
	key := strings.TrimPrefix(uri.String(), "/")
	node := r
	initialKey := key

	for {
		pathParts := parts(key)
		SegmentValue := pathParts[0]

		// It is currently impossible to Delete a non-existent path. This invariant is
		// provided by the fact that a call to Find is done before Delete in the registry.
		matchingChild, _ := node.ChildNodes[SegmentValue]

		node = matchingChild

		if len(pathParts) <= 1 {
			break
		}

		key = pathParts[1]
	}
	node.Pool = nil
	r.deleteEmptyNodes(initialKey)

	return true
}
Example #4
0
func parseContextPath(uri route.Uri) string {
	contextPath := "/"
	split := strings.SplitN(strings.TrimPrefix(uri.String(), "/"), "/", 2)

	if len(split) > 1 {
		contextPath += split[1]
	}
	return contextPath
}
Example #5
0
func (r *RouteRegistry) Lookup(uri route.Uri) *route.Pool {
	r.RLock()

	uri = uri.RouteKey()
	var err error
	pool, found := r.byUri.MatchUri(uri)

	r.logger.Infof("endpoint pool: %#v", pool)
	for !found && err == nil {
		uri, err = uri.NextWildcard()
		pool, found = r.byUri.MatchUri(uri)
	}

	r.RUnlock()

	return pool
}
Example #6
0
func (r *RouteRegistry) Register(uri route.Uri, ep *route.Endpoint) {
	t := time.Now()
	r.Lock()

	uri = uri.RouteKey()

	pool, found := r.byUri.Find(uri)
	if !found {
		contextPath := parseContextPath(uri)
		pool = route.NewPool(r.dropletStaleThreshold/4, contextPath)
		r.byUri.Insert(uri, pool)
	}

	pool.Put(ep)

	r.timeOfLastUpdate = t
	r.Unlock()
}
Example #7
0
func (r *RouteRegistry) Unregister(uri route.Uri, ep *route.Endpoint) {
	r.Lock()

	uri = uri.RouteKey()

	pool, found := r.byUri.Find(uri)
	if found {

		r.logger.Infof("remove endpoint %#v of uri: %#v", ep, uri)
		pool.Remove(ep)

		if pool.IsEmpty() {
			r.byUri.Delete(uri)
		}
	}

	r.Unlock()
}
Example #8
0
func (r *RouteRegistry) RegisterAll(uri route.Uri, eps []*route.Endpoint) {
	r.Lock()
	defer r.Unlock()

	uri = uri.RouteKey()

	contextPath := parseContextPath(uri)
	pool := route.NewPool(r.dropletStaleThreshold/4, contextPath)

	for _, ep := range eps {
		r.logger.Infof("route.endpoint: %v", ep)
		pool.Put(ep)
	}

	r.logger.Infof("byUri: %#v", *pool)
	ok := r.byUri.Insert(uri, pool)
	r.logger.Infof("=======ok: %#v", *ok.Pool)

	r.timeOfLastUpdate = time.Now()

}