From 97aca6bd55da728dc07eced692e4a311e9dc78cf Mon Sep 17 00:00:00 2001 From: Asim Aslam Date: Fri, 14 Aug 2020 23:51:52 +0100 Subject: [PATCH] Strip Advertise/Process from router --- registry.go | 376 +---------------------------------------------- registry_test.go | 108 -------------- table.go | 44 +----- table_test.go | 109 +++++++------- 4 files changed, 66 insertions(+), 571 deletions(-) diff --git a/registry.go b/registry.go index 11571a1..c762d7b 100644 --- a/registry.go +++ b/registry.go @@ -2,12 +2,10 @@ package registry import ( "fmt" - "sort" "strings" "sync" "time" - "github.com/google/uuid" "github.com/micro/go-micro/v3/logger" "github.com/micro/go-micro/v3/registry" "github.com/micro/go-micro/v3/router" @@ -18,26 +16,17 @@ var ( RefreshInterval = time.Second * 120 // PruneInterval is how often we prune the routing table PruneInterval = time.Second * 10 - // AdvertiseEventsTick is time interval in which the router advertises route updates - AdvertiseEventsTick = 10 * time.Second - // DefaultAdvertTTL is default advertisement TTL - DefaultAdvertTTL = 2 * time.Minute ) // rtr implements router interface type rtr struct { sync.RWMutex - running bool - table *table - options router.Options - exit chan bool - initChan chan bool - eventChan chan *router.Event - - // advert subscribers - sub sync.RWMutex - subscribers map[string]chan *router.Advert + running bool + table *table + options router.Options + exit chan bool + initChan chan bool } // NewRouter creates new router and returns it @@ -52,9 +41,8 @@ func NewRouter(opts ...router.Option) router.Router { // construct the router r := &rtr{ - options: options, - initChan: make(chan bool), - subscribers: make(map[string]chan *router.Advert), + options: options, + initChan: make(chan bool), } // create the new table, passing the fetchRoute method in as a fallback if @@ -327,214 +315,6 @@ func (r *rtr) watchRegistry(w registry.Watcher) error { return nil } -// watchTable watches routing table entries and either adds or deletes locally registered service to/from network registry -// It returns error if the locally registered services either fails to be added/deleted to/from network registry. -func (r *rtr) watchTable(w router.Watcher) error { - exit := make(chan bool) - - defer func() { - close(exit) - }() - - // wait in the background for the router to stop - // when the router stops, stop the watcher and exit - go func() { - defer w.Stop() - - select { - case <-r.exit: - return - case <-exit: - return - } - }() - - for { - event, err := w.Next() - if err != nil { - if err != router.ErrWatcherStopped { - return err - } - break - } - - select { - case <-r.exit: - return nil - case r.eventChan <- event: - // process event - } - } - - return nil -} - -// publishAdvert publishes router advert to advert channel -func (r *rtr) publishAdvert(advType router.AdvertType, events []*router.Event) { - a := &router.Advert{ - Id: r.options.Id, - Type: advType, - TTL: DefaultAdvertTTL, - Timestamp: time.Now(), - Events: events, - } - - r.sub.RLock() - for _, sub := range r.subscribers { - // now send the message - select { - case sub <- a: - case <-r.exit: - r.sub.RUnlock() - return - } - } - r.sub.RUnlock() -} - -// adverts maintains a map of router adverts -type adverts map[uint64]*router.Event - -// advertiseEvents advertises routing table events -// It suppresses unhealthy flapping events and advertises healthy events upstream. -func (r *rtr) advertiseEvents() error { - // ticker to periodically scan event for advertising - ticker := time.NewTicker(AdvertiseEventsTick) - defer ticker.Stop() - - // adverts is a map of advert events - adverts := make(adverts) - - // routing table watcher - w, err := r.Watch() - if err != nil { - return err - } - defer w.Stop() - - go func() { - var err error - - for { - select { - case <-r.exit: - return - default: - if w == nil { - // routing table watcher - w, err = r.Watch() - if err != nil { - if logger.V(logger.DebugLevel, logger.DefaultLogger) { - logger.Debugf("Error creating watcher: %v", err) - } - time.Sleep(time.Second) - continue - } - } - - if err := r.watchTable(w); err != nil { - if logger.V(logger.DebugLevel, logger.DefaultLogger) { - logger.Debugf("Error watching table: %v", err) - } - time.Sleep(time.Second) - } - - if w != nil { - // reset - w.Stop() - w = nil - } - } - } - }() - - for { - select { - case <-ticker.C: - // If we're not advertising any events then sip processing them entirely - if r.options.Advertise == router.AdvertiseNone { - continue - } - - var events []*router.Event - - // collect all events which are not flapping - for key, event := range adverts { - // if we only advertise local routes skip processing anything not link local - if r.options.Advertise == router.AdvertiseLocal && event.Route.Link != "local" { - continue - } - - // copy the event and append - e := new(router.Event) - // this is ok, because router.Event only contains builtin types - // and no references so this creates a deep copy of struct Event - *e = *event - events = append(events, e) - // delete the advert from adverts - delete(adverts, key) - } - - // advertise events to subscribers - if len(events) > 0 { - if logger.V(logger.DebugLevel, logger.DefaultLogger) { - logger.Debugf("Router publishing %d events", len(events)) - } - go r.publishAdvert(router.RouteUpdate, events) - } - case e := <-r.eventChan: - // if event is nil, continue - if e == nil { - continue - } - - // If we're not advertising any events then skip processing them entirely - if r.options.Advertise == router.AdvertiseNone { - continue - } - - // if we only advertise local routes skip processing anything not link local - if r.options.Advertise == router.AdvertiseLocal && e.Route.Link != "local" { - continue - } - - if logger.V(logger.DebugLevel, logger.DefaultLogger) { - logger.Debugf("Router processing table event %s for service %s %s", e.Type, e.Route.Service, e.Route.Address) - } - - // check if we have already registered the route - hash := e.Route.Hash() - ev, ok := adverts[hash] - if !ok { - ev = e - adverts[hash] = e - continue - } - - // override the route event only if the previous event was different - if ev.Type != e.Type { - ev = e - } - case <-r.exit: - if w != nil { - w.Stop() - } - return nil - } - } -} - -// drain all the events, only called on Stop -func (r *rtr) drain() { - for { - select { - case <-r.eventChan: - default: - return - } - } -} - // start the router. Should be called under lock. func (r *rtr) start() error { if r.running { @@ -621,130 +401,6 @@ func (r *rtr) start() error { return nil } -// Advertise stars advertising the routes to the network and returns the advertisements channel to consume from. -// If the router is already advertising it returns the channel to consume from. -// It returns error if either the router is not running or if the routing table fails to list the routes to advertise. -func (r *rtr) Advertise() (<-chan *router.Advert, error) { - r.Lock() - defer r.Unlock() - - // we're mutating the subscribers so they need to be locked also - r.sub.Lock() - defer r.sub.Unlock() - - // already advertising - if r.eventChan != nil { - advertChan := make(chan *router.Advert, 128) - r.subscribers[uuid.New().String()] = advertChan - return advertChan, nil - } - - // list all the routes and pack them into even slice to advertise - events, err := r.flushRouteEvents(router.Create) - if err != nil { - return nil, fmt.Errorf("failed to flush routes: %s", err) - } - - // create event channels - r.eventChan = make(chan *router.Event) - - // create advert channel - advertChan := make(chan *router.Advert, 128) - r.subscribers[uuid.New().String()] = advertChan - - // advertise your presence - go r.publishAdvert(router.Announce, events) - - go func() { - select { - case <-r.exit: - return - default: - if err := r.advertiseEvents(); err != nil { - if logger.V(logger.DebugLevel, logger.DefaultLogger) { - logger.Debugf("Error adveritising events: %v", err) - } - } - } - }() - - return advertChan, nil - -} - -// Process updates the routing table using the advertised values -func (r *rtr) Process(a *router.Advert) error { - // NOTE: event sorting might not be necessary - // copy update events intp new slices - events := make([]*router.Event, len(a.Events)) - copy(events, a.Events) - // sort events by timestamp - sort.Slice(events, func(i, j int) bool { - return events[i].Timestamp.Before(events[j].Timestamp) - }) - - if logger.V(logger.TraceLevel, logger.DefaultLogger) { - logger.Tracef("Router %s processing advert from: %s", r.options.Id, a.Id) - } - - for _, event := range events { - // skip if the router is the origin of this route - if event.Route.Router == r.options.Id { - if logger.V(logger.TraceLevel, logger.DefaultLogger) { - logger.Tracef("Router skipping processing its own route: %s", r.options.Id) - } - continue - } - // create a copy of the route - route := event.Route - action := event.Type - - if logger.V(logger.TraceLevel, logger.DefaultLogger) { - logger.Tracef("Router %s applying %s from router %s for service %s %s", r.options.Id, action, route.Router, route.Service, route.Address) - } - - if err := r.manageRoute(route, action.String()); err != nil { - return fmt.Errorf("failed applying action %s to routing table: %s", action, err) - } - } - - return nil -} - -// flushRouteEvents returns a slice of events, one per each route in the routing table -func (r *rtr) flushRouteEvents(evType router.EventType) ([]*router.Event, error) { - // get a list of routes for each service in our routing table - // for the configured advertising strategy - q := []router.QueryOption{ - router.QueryStrategy(r.options.Advertise), - } - - routes, err := r.table.Query(q...) - if err != nil && err != router.ErrRouteNotFound { - return nil, err - } - - if logger.V(logger.DebugLevel, logger.DefaultLogger) { - logger.Debugf("Router advertising %d routes with strategy %s", len(routes), r.options.Advertise) - } - - // build a list of events to advertise - events := make([]*router.Event, len(routes)) - var i int - - for _, route := range routes { - event := &router.Event{ - Type: evType, - Timestamp: time.Now(), - Route: route, - } - events[i] = event - i++ - } - - return events, nil -} - // Lookup routes in the routing table func (r *rtr) Lookup(q ...router.QueryOption) ([]router.Route, error) { return r.Table().Query(q...) @@ -769,24 +425,6 @@ func (r *rtr) Close() error { } close(r.exit) - // extract the events - r.drain() - - r.sub.Lock() - // close advert subscribers - for id, sub := range r.subscribers { - // close the channel - close(sub) - // delete the subscriber - delete(r.subscribers, id) - } - r.sub.Unlock() - } - - // close and remove event chan - if r.eventChan != nil { - close(r.eventChan) - r.eventChan = nil } r.running = false diff --git a/registry_test.go b/registry_test.go index 0c1af95..b8886df 100644 --- a/registry_test.go +++ b/registry_test.go @@ -1,11 +1,8 @@ package registry import ( - "fmt" "os" - "sync" "testing" - "time" "github.com/micro/go-micro/v3/registry/memory" "github.com/micro/go-micro/v3/router" @@ -19,11 +16,6 @@ func routerTestSetup() router.Router { func TestRouterClose(t *testing.T) { r := routerTestSetup() - _, err := r.Advertise() - if err != nil { - t.Errorf("failed to start advertising: %v", err) - } - if err := r.Close(); err != nil { t.Errorf("failed to stop router: %v", err) } @@ -31,103 +23,3 @@ func TestRouterClose(t *testing.T) { t.Logf("TestRouterStartStop STOPPED") } } - -func TestRouterAdvertise(t *testing.T) { - r := routerTestSetup() - - // lower the advertise interval - AdvertiseEventsTick = 500 * time.Millisecond - - ch, err := r.Advertise() - if err != nil { - t.Errorf("failed to start advertising: %v", err) - } - - // receive announce event - ann := <-ch - if len(os.Getenv("IN_TRAVIS_CI")) == 0 { - t.Logf("received announce advert: %v", ann) - } - - // Generate random unique routes - nrRoutes := 5 - routes := make([]router.Route, nrRoutes) - route := router.Route{ - Service: "dest.svc", - Address: "dest.addr", - Gateway: "dest.gw", - Network: "dest.network", - Router: "src.router", - Link: "local", - Metric: 10, - } - - for i := 0; i < nrRoutes; i++ { - testRoute := route - testRoute.Service = fmt.Sprintf("%s-%d", route.Service, i) - routes[i] = testRoute - } - - var advertErr error - - createDone := make(chan bool) - errChan := make(chan error) - - var wg sync.WaitGroup - wg.Add(1) - go func() { - wg.Done() - defer close(createDone) - for _, route := range routes { - if len(os.Getenv("IN_TRAVIS_CI")) == 0 { - t.Logf("Creating route %v", route) - } - if err := r.Table().Create(route); err != nil { - if len(os.Getenv("IN_TRAVIS_CI")) == 0 { - t.Logf("Failed to create route: %v", err) - } - errChan <- err - return - } - } - }() - - var adverts int - readDone := make(chan bool) - - wg.Add(1) - go func() { - defer func() { - wg.Done() - readDone <- true - }() - for advert := range ch { - select { - case advertErr = <-errChan: - t.Errorf("failed advertising events: %v", advertErr) - default: - // do nothing for now - if len(os.Getenv("IN_TRAVIS_CI")) == 0 { - t.Logf("Router advert received: %v", advert) - } - adverts += len(advert.Events) - } - return - } - }() - - // done adding routes to routing table - <-createDone - // done reading adverts from the routing table - <-readDone - - if adverts != nrRoutes { - t.Errorf("Expected %d adverts, received: %d", nrRoutes, adverts) - } - - wg.Wait() - - if err := r.Close(); err != nil { - t.Errorf("failed to stop router: %v", err) - } -} diff --git a/table.go b/table.go index 7e4b069..cefd723 100644 --- a/table.go +++ b/table.go @@ -217,7 +217,7 @@ func (t *table) List() ([]router.Route, error) { } // isMatch checks if the route matches given query options -func isMatch(route router.Route, address, gateway, network, rtr string, strategy router.Strategy) bool { +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 { @@ -232,13 +232,6 @@ func isMatch(route router.Route, address, gateway, network, rtr string, strategy b string } - // by default assume we are querying all routes - link := "*" - // if AdvertiseLocal change the link query accordingly - if strategy == router.AdvertiseLocal { - link = "local" - } - // compare the following values values := []compare{ {gateway, route.Gateway}, @@ -264,7 +257,7 @@ func filterRoutes(routes map[uint64]*route, opts router.QueryOptions) []router.R gateway := opts.Gateway network := opts.Network rtr := opts.Router - strategy := opts.Strategy + link := opts.Link // routeMap stores the routes we're going to advertise routeMap := make(map[string][]router.Route) @@ -273,37 +266,15 @@ func filterRoutes(routes map[uint64]*route, opts router.QueryOptions) []router.R // get the actual route route := rt.route - if isMatch(route, address, gateway, network, rtr, strategy) { + if isMatch(route, address, gateway, network, rtr, link) { // add matchihg route to the routeMap routeKey := route.Service + "@" + route.Network - // append the first found route to routeMap - _, ok := routeMap[routeKey] - if !ok { - routeMap[routeKey] = append(routeMap[routeKey], route) - continue - } - - // if AdvertiseAll, keep appending - if strategy == router.AdvertiseAll || strategy == router.AdvertiseLocal { - routeMap[routeKey] = append(routeMap[routeKey], route) - continue - } - - // now we're going to find the best routes - if strategy == router.AdvertiseBest { - // if the current optimal route metric is higher than routing table route, replace it - if len(routeMap[routeKey]) > 0 { - // NOTE: we know that when AdvertiseBest is set, we only ever have one item in current - if routeMap[routeKey][0].Metric > route.Metric { - routeMap[routeKey][0] = route - continue - } - } - } + routeMap[routeKey] = append(routeMap[routeKey], route) } } var results []router.Route + for _, route := range routeMap { results = append(results, route...) } @@ -319,11 +290,6 @@ func (t *table) Query(q ...router.QueryOption) ([]router.Route, error) { // create a cwslicelist of query results results := make([]router.Route, 0, len(t.routes)) - // if No routes are queried, return early - if opts.Strategy == router.AdvertiseNone { - return results, nil - } - // readAndFilter routes for this service under read lock. readAndFilter := func(q router.QueryOptions) ([]router.Route, bool) { t.RLock() diff --git a/table_test.go b/table_test.go index 4fa4131..1cb5fc5 100644 --- a/table_test.go +++ b/table_test.go @@ -28,19 +28,19 @@ func TestCreate(t *testing.T) { table, route := testSetup() if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } // adds new route for the original destination route.Gateway = "dest.gw2" if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } // adding the same route under Insert policy must error if err := table.Create(route); err != router.ErrDuplicateRoute { - t.Errorf("error adding route. Expected error: %s, found: %s", router.ErrDuplicateRoute, err) + t.Fatalf("error adding route. Expected error: %s, found: %s", router.ErrDuplicateRoute, err) } } @@ -48,7 +48,7 @@ func TestDelete(t *testing.T) { table, route := testSetup() if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } // should fail to delete non-existant route @@ -56,14 +56,14 @@ func TestDelete(t *testing.T) { route.Service = "randDest" if err := table.Delete(route); err != router.ErrRouteNotFound { - t.Errorf("error deleting route. Expected: %s, found: %s", router.ErrRouteNotFound, err) + t.Fatalf("error deleting route. Expected: %s, found: %s", router.ErrRouteNotFound, err) } // we should be able to delete the existing route route.Service = prevSvc if err := table.Delete(route); err != nil { - t.Errorf("error deleting route: %s", err) + t.Fatalf("error deleting route: %s", err) } } @@ -71,21 +71,21 @@ func TestUpdate(t *testing.T) { table, route := testSetup() if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } // change the metric of the original route route.Metric = 200 if err := table.Update(route); err != nil { - t.Errorf("error updating route: %s", err) + t.Fatalf("error updating route: %s", err) } // this should add a new route route.Service = "rand.dest" if err := table.Update(route); err != nil { - t.Errorf("error updating route: %s", err) + t.Fatalf("error updating route: %s", err) } } @@ -97,17 +97,17 @@ func TestList(t *testing.T) { for i := 0; i < len(svc); i++ { route.Service = svc[i] if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } } routes, err := table.List() if err != nil { - t.Errorf("error listing routes: %s", err) + t.Fatalf("error listing routes: %s", err) } if len(routes) != len(svc) { - t.Errorf("incorrect number of routes listed. Expected: %d, found: %d", len(svc), len(routes)) + t.Fatalf("incorrect number of routes listed. Expected: %d, found: %d", len(svc), len(routes)) } } @@ -124,17 +124,19 @@ func TestQuery(t *testing.T) { route.Network = net[i] route.Gateway = gw[i] route.Router = rtr[i] + route.Link = router.DefaultLink + if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } } // return all routes routes, err := table.Query() if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } else if len(routes) == 0 { - t.Errorf("error looking up routes: not found") + t.Fatalf("error looking up routes: not found") } // query routes particular network @@ -142,16 +144,16 @@ func TestQuery(t *testing.T) { routes, err = table.Query(router.QueryNetwork(network)) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } if len(routes) != 2 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes)) } for _, route := range routes { if route.Network != network { - t.Errorf("incorrect route returned. Expected network: %s, found: %s", network, route.Network) + t.Fatalf("incorrect route returned. Expected network: %s, found: %s", network, route.Network) } } @@ -160,15 +162,15 @@ func TestQuery(t *testing.T) { routes, err = table.Query(router.QueryGateway(gateway)) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } if len(routes) != 1 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) } if routes[0].Gateway != gateway { - t.Errorf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway) + t.Fatalf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway) } // query routes for particular router @@ -176,15 +178,15 @@ func TestQuery(t *testing.T) { routes, err = table.Query(router.QueryRouter(rt)) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } if len(routes) != 1 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) } if routes[0].Router != rt { - t.Errorf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router) + t.Fatalf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router) } // query particular gateway and network @@ -196,57 +198,57 @@ func TestQuery(t *testing.T) { routes, err = table.Query(query...) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } if len(routes) != 1 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) } if routes[0].Gateway != gateway { - t.Errorf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway) + t.Fatalf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway) } if routes[0].Network != network { - t.Errorf("incorrect network returned. Expected network: %s, found: %s", network, routes[0].Network) + t.Fatalf("incorrect network returned. Expected network: %s, found: %s", network, routes[0].Network) } if routes[0].Router != rt { - t.Errorf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router) + t.Fatalf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router) } // non-existen route query routes, err = table.Query(router.QueryService("foobar")) if err != router.ErrRouteNotFound { - t.Errorf("error looking up routes. Expected: %s, found: %s", router.ErrRouteNotFound, err) + t.Fatalf("error looking up routes. Expected: %s, found: %s", router.ErrRouteNotFound, err) } if len(routes) != 0 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes)) } // query NO routes query = []router.QueryOption{ router.QueryGateway(gateway), router.QueryNetwork(network), - router.QueryStrategy(router.AdvertiseNone), + router.QueryLink("network"), } routes, err = table.Query(query...) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } if len(routes) > 0 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes)) } // insert local routes to query for i := 0; i < 2; i++ { - route.Link = "local" + route.Link = "foobar" route.Address = fmt.Sprintf("local.route.address-%d", i) if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } } @@ -254,16 +256,16 @@ func TestQuery(t *testing.T) { query = []router.QueryOption{ router.QueryGateway("*"), router.QueryNetwork("*"), - router.QueryStrategy(router.AdvertiseLocal), + router.QueryLink("foobar"), } routes, err = table.Query(query...) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } if len(routes) != 2 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes)) + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes)) } // add two different routes for svcX with different metric @@ -271,32 +273,30 @@ func TestQuery(t *testing.T) { route.Service = "svcX" route.Address = fmt.Sprintf("svcX.route.address-%d", i) route.Metric = int64(100 + i) + route.Link = router.DefaultLink if err := table.Create(route); err != nil { - t.Errorf("error adding route: %s", err) + t.Fatalf("error adding route: %s", err) } } - // query best routes for svcX query = []router.QueryOption{ router.QueryService("svcX"), - router.QueryStrategy(router.AdvertiseBest), } routes, err = table.Query(query...) if err != nil { - t.Errorf("error looking up routes: %s", err) + t.Fatalf("error looking up routes: %s", err) } - if len(routes) != 1 { - t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) + if len(routes) != 2 { + t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes)) } } func TestFallback(t *testing.T) { r := &rtr{ - subscribers: make(map[string]chan *router.Advert), - options: router.DefaultOptions(), + options: router.DefaultOptions(), } route := router.Route{ Service: "go.micro.service.foo", @@ -311,31 +311,30 @@ func TestFallback(t *testing.T) { rts, err := r.Lookup(router.QueryService("go.micro.service.foo")) if err != nil { - t.Errorf("error looking up service %s", err) + t.Fatalf("error looking up service %s", err) } if len(rts) != 1 { - t.Errorf("incorrect number of routes returned %d", len(rts)) + t.Fatalf("incorrect number of routes returned %d", len(rts)) } // deleting from the table but the next query should invoke the fallback that we passed during new table creation if err := r.table.Delete(route); err != nil { - t.Errorf("error deleting route %s", err) + t.Fatalf("error deleting route %s", err) } rts, err = r.Lookup(router.QueryService("go.micro.service.foo")) if err != nil { - t.Errorf("error looking up service %s", err) + t.Fatalf("error looking up service %s", err) } if len(rts) != 1 { - t.Errorf("incorrect number of routes returned %d", len(rts)) + t.Fatalf("incorrect number of routes returned %d", len(rts)) } } func TestFallbackError(t *testing.T) { r := &rtr{ - subscribers: make(map[string]chan *router.Advert), - options: router.DefaultOptions(), + options: router.DefaultOptions(), } r.table = newTable(func(s string) ([]router.Route, error) { return nil, fmt.Errorf("ERROR") @@ -343,7 +342,7 @@ func TestFallbackError(t *testing.T) { r.start() _, err := r.Lookup(router.QueryService("go.micro.service.foo")) if err == nil { - t.Errorf("expected error looking up service but none returned") + t.Fatalf("expected error looking up service but none returned") } }