Registry router fixes (#1961)

* only cache routes if told to do so

* Use roundrobin selector and retry in proxy

* Update lookup to require service

* Fix compile

* Fix compile

* Update

* Update

* rename query to lookup

* Update router.go

* Update

table.go

@@ -12,8 +12,6 @@ import (
 // table is an in-memory routing table
 type table struct {
 	sync.RWMutex
-	// lookup for a service
-	lookup func(string) ([]router.Route, error)
 	// routes stores service routes
 	routes map[string]map[uint64]*route
 	// watchers stores table watchers
@@ -26,9 +24,8 @@ type route struct {
 }
 
 // newtable creates a new routing table and returns it
-func newTable(lookup func(string) ([]router.Route, error), opts ...router.Option) *table {
+func newTable() *table {
 	return &table{
-		lookup:   lookup,
 		routes:   make(map[string]map[uint64]*route),
 		watchers: make(map[string]*tableWatcher),
 	}
@@ -216,136 +213,23 @@ func (t *table) List() ([]router.Route, error) {
 	return routes, nil
 }
 
-// isMatch checks if the route matches given query options
-func isMatch(route router.Route, address, gateway, network, rtr, link string) bool {
-	// matches the values provided
-	match := func(a, b string) bool {
-		if a == "*" || b == "*" || a == b {
-			return true
-		}
-		return false
-	}
-
-	// a simple struct to hold our values
-	type compare struct {
-		a string
-		b string
-	}
-
-	// compare the following values
-	values := []compare{
-		{gateway, route.Gateway},
-		{network, route.Network},
-		{rtr, route.Router},
-		{address, route.Address},
-		{link, route.Link},
-	}
-
-	for _, v := range values {
-		// attempt to match each value
-		if !match(v.a, v.b) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// filterRoutes finds all the routes for given network and router and returns them
-func filterRoutes(routes map[uint64]*route, opts router.QueryOptions) []router.Route {
-	address := opts.Address
-	gateway := opts.Gateway
-	network := opts.Network
-	rtr := opts.Router
-	link := opts.Link
-
-	// routeMap stores the routes we're going to advertise
-	routeMap := make(map[string][]router.Route)
-
-	for _, rt := range routes {
-		// get the actual route
-		route := rt.route
-
-		if isMatch(route, address, gateway, network, rtr, link) {
-			// add matchihg route to the routeMap
-			routeKey := route.Service + "@" + route.Network
-			routeMap[routeKey] = append(routeMap[routeKey], route)
-		}
-	}
-
-	var results []router.Route
-
-	for _, route := range routeMap {
-		results = append(results, route...)
-	}
-
-	return results
-}
-
 // Lookup queries routing table and returns all routes that match the lookup query
-func (t *table) Query(q ...router.QueryOption) ([]router.Route, error) {
-	// create new query options
-	opts := router.NewQuery(q...)
-
-	// create a cwslicelist of query results
-	results := make([]router.Route, 0, len(t.routes))
-
-	// readAndFilter routes for this service under read lock.
-	readAndFilter := func(q router.QueryOptions) ([]router.Route, bool) {
-		t.RLock()
-		defer t.RUnlock()
-
-		routes, ok := t.routes[q.Service]
-		if !ok || len(routes) == 0 {
-			return nil, false
-		}
-
-		return filterRoutes(routes, q), true
-	}
-
-	if opts.Service != "*" {
-		// try and load services from the cache
-		if routes, ok := readAndFilter(opts); ok {
-			return routes, nil
-		}
-
-		// lookup the route and try again
-		// TODO: move this logic out of the hot path
-		// being hammered on queries will require multiple lookups
-		routes, err := t.lookup(opts.Service)
-		if err != nil {
-			return nil, err
-		}
-
-		// cache the routes
-		for _, rt := range routes {
-			t.Create(rt)
-		}
-
-		// try again
-		if routes, ok := readAndFilter(opts); ok {
-			return routes, nil
-		}
+func (t *table) Query(service string) ([]router.Route, error) {
+	t.RLock()
+	defer t.RUnlock()
 
+	routeMap, ok := t.routes[service]
+	if !ok {
 		return nil, router.ErrRouteNotFound
 	}
 
-	// search through all destinations
-	t.RLock()
+	var routes []router.Route
 
-	for _, routes := range t.routes {
-		// filter the routes
-		found := filterRoutes(routes, opts)
-		// ensure we don't append zero length routes
-		if len(found) == 0 {
-			continue
-		}
-		results = append(results, found...)
+	for _, rt := range routeMap {
+		routes = append(routes, rt.route)
 	}
 
-	t.RUnlock()
-
-	return results, nil
+	return routes, nil
 }
 
 // Watch returns routing table entry watcher