Move router and proxy into network package
This commit is contained in:
Asim Aslam
@@ -1,323 +0,0 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/micro/go-micro/registry"
|
||||
"github.com/olekukonko/tablewriter"
|
||||
)
|
||||
|
||||
var (
|
||||
// AdvertiseTick defines how often in seconds do we scal the local registry
|
||||
// to advertise the local services to the network registry
|
||||
AdvertiseTick = 5 * time.Second
|
||||
// AdvertiseTTL defines network registry TTL in seconds
|
||||
// NOTE: this is a rather arbitrary picked value subject to change
|
||||
AdvertiseTTL = 120 * time.Second
|
||||
)
|
||||
|
||||
type router struct {
|
||||
opts Options
|
||||
exit chan struct{}
|
||||
wg *sync.WaitGroup
|
||||
}
|
||||
|
||||
// newRouter creates new router and returns it
|
||||
func newRouter(opts ...Option) Router {
|
||||
// get default options
|
||||
options := DefaultOptions()
|
||||
|
||||
// apply requested options
|
||||
for _, o := range opts {
|
||||
o(&options)
|
||||
}
|
||||
|
||||
return &router{
|
||||
opts: options,
|
||||
exit: make(chan struct{}),
|
||||
wg: &sync.WaitGroup{},
|
||||
}
|
||||
}
|
||||
|
||||
// Init initializes router with given options
|
||||
func (r *router) Init(opts ...Option) error {
|
||||
for _, o := range opts {
|
||||
o(&r.opts)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Options returns router options
|
||||
func (r *router) Options() Options {
|
||||
return r.opts
|
||||
}
|
||||
|
||||
// ID returns router ID
|
||||
func (r *router) ID() string {
|
||||
return r.opts.ID
|
||||
}
|
||||
|
||||
// Table returns routing table
|
||||
func (r *router) Table() Table {
|
||||
return r.opts.Table
|
||||
}
|
||||
|
||||
// Address returns router's bind address
|
||||
func (r *router) Address() string {
|
||||
return r.opts.Address
|
||||
}
|
||||
|
||||
// Network returns the address router advertises to the network
|
||||
func (r *router) Network() string {
|
||||
return r.opts.Advertise
|
||||
}
|
||||
|
||||
// Advertise advertises the router routes to the network.
|
||||
// Advertise is a blocking function. It launches multiple goroutines that watch
|
||||
// service registries and advertise the router routes to other routers in the network.
|
||||
// It returns error if any of the launched goroutines fail with error.
|
||||
func (r *router) Advertise() error {
|
||||
// add local service routes into the routing table
|
||||
if err := r.addServiceRoutes(r.opts.Registry, DefaultLocalMetric); err != nil {
|
||||
return fmt.Errorf("failed adding routes for local services: %v", err)
|
||||
}
|
||||
|
||||
// add network service routes into the routing table
|
||||
if err := r.addServiceRoutes(r.opts.Network, DefaultNetworkMetric); err != nil {
|
||||
return fmt.Errorf("failed adding routes for network services: %v", err)
|
||||
}
|
||||
|
||||
node, err := r.parseToNode()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to parse router into service node: %v", err)
|
||||
}
|
||||
|
||||
localWatcher, err := r.opts.Registry.Watch()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to create local registry watcher: %v", err)
|
||||
}
|
||||
|
||||
networkWatcher, err := r.opts.Network.Watch()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to create network registry watcher: %v", err)
|
||||
}
|
||||
|
||||
// error channel collecting goroutine errors
|
||||
errChan := make(chan error, 3)
|
||||
|
||||
r.wg.Add(1)
|
||||
go func() {
|
||||
defer r.wg.Done()
|
||||
// watch local registry and register routes in routine table
|
||||
errChan <- r.manageServiceRoutes(localWatcher, DefaultLocalMetric)
|
||||
}()
|
||||
|
||||
r.wg.Add(1)
|
||||
go func() {
|
||||
defer r.wg.Done()
|
||||
// watch network registry and register routes in routine table
|
||||
errChan <- r.manageServiceRoutes(networkWatcher, DefaultNetworkMetric)
|
||||
}()
|
||||
|
||||
r.wg.Add(1)
|
||||
go func() {
|
||||
defer r.wg.Done()
|
||||
// watch local registry and advertise local service to the network
|
||||
errChan <- r.advertiseToNetwork(node)
|
||||
}()
|
||||
|
||||
return <-errChan
|
||||
}
|
||||
|
||||
// addServiceRoutes adds all services in given registry to the routing table.
|
||||
// NOTE: this is a one-off operation done when bootstrapping the routing table of the new router.
|
||||
// It returns error if either the services could not be listed or if the routes could not be added to the routing table.
|
||||
func (r *router) addServiceRoutes(reg registry.Registry, metric int) error {
|
||||
services, err := reg.ListServices()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to list services: %v", err)
|
||||
}
|
||||
|
||||
for _, service := range services {
|
||||
route := Route{
|
||||
Destination: service.Name,
|
||||
Router: r,
|
||||
Network: r.opts.Advertise,
|
||||
Metric: metric,
|
||||
}
|
||||
if err := r.opts.Table.Add(route); err != nil && err != ErrDuplicateRoute {
|
||||
return fmt.Errorf("error adding route for service: %s", service.Name)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// parseToNode parses router into registry.Node and returns the result.
|
||||
// It returns error if the router network address could not be parsed into host and port.
|
||||
func (r *router) parseToNode() (*registry.Node, error) {
|
||||
// split router address to host and port part
|
||||
addr, portStr, err := net.SplitHostPort(r.opts.Advertise)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("could not parse router address: %v", err)
|
||||
}
|
||||
|
||||
// try to parse network port into integer
|
||||
port, err := strconv.Atoi(portStr)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("could not parse router network address: %v", err)
|
||||
}
|
||||
|
||||
node := ®istry.Node{
|
||||
Id: r.opts.ID,
|
||||
Address: addr,
|
||||
Port: port,
|
||||
}
|
||||
|
||||
return node, nil
|
||||
}
|
||||
|
||||
// advertiseToNetwork periodically scans local registry and registers (i.e. advertises) all the local services in the network registry.
|
||||
// It returns error if either the local services failed to be listed or if it fails to register local service in network registry.
|
||||
func (r *router) advertiseToNetwork(node *registry.Node) error {
|
||||
// ticker to periodically scan the local registry
|
||||
ticker := time.NewTicker(AdvertiseTick)
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-r.exit:
|
||||
return nil
|
||||
case <-ticker.C:
|
||||
// list all local services
|
||||
services, err := r.opts.Registry.ListServices()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to list local services: %v", err)
|
||||
}
|
||||
// loop through all registered local services and register them in the network registry
|
||||
for _, service := range services {
|
||||
svc := ®istry.Service{
|
||||
Name: service.Name,
|
||||
Nodes: []*registry.Node{node},
|
||||
}
|
||||
// register the local service in the network registry
|
||||
if err := r.opts.Network.Register(svc, registry.RegisterTTL(AdvertiseTTL)); err != nil {
|
||||
return fmt.Errorf("failed to register service %s in network registry: %v", svc.Name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// manageServiceRoutes watches services in given registry and updates the routing table accordingly.
|
||||
// It returns error if the service registry watcher has stopped or if the routing table failed to be updated.
|
||||
func (r *router) manageServiceRoutes(w registry.Watcher, metric int) error {
|
||||
// wait in the background for the router to stop
|
||||
// when the router stops, stop the watcher and exit
|
||||
r.wg.Add(1)
|
||||
go func() {
|
||||
defer r.wg.Done()
|
||||
<-r.exit
|
||||
w.Stop()
|
||||
}()
|
||||
|
||||
var watchErr error
|
||||
|
||||
for {
|
||||
res, err := w.Next()
|
||||
if err == registry.ErrWatcherStopped {
|
||||
break
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
watchErr = err
|
||||
break
|
||||
}
|
||||
|
||||
route := Route{
|
||||
Destination: res.Service.Name,
|
||||
Router: r,
|
||||
Network: r.opts.Advertise,
|
||||
Metric: metric,
|
||||
}
|
||||
|
||||
switch res.Action {
|
||||
case "create":
|
||||
if len(res.Service.Nodes) > 0 {
|
||||
// only return error if the route is not duplicate, but something else has failed
|
||||
if err := r.opts.Table.Add(route); err != nil && err != ErrDuplicateRoute {
|
||||
return fmt.Errorf("failed to add route for service: %v", res.Service.Name)
|
||||
}
|
||||
}
|
||||
case "delete":
|
||||
if len(res.Service.Nodes) < 1 {
|
||||
// only return error if the route is present in the table, but something else has failed
|
||||
if err := r.opts.Table.Delete(route); err != nil && err != ErrRouteNotFound {
|
||||
return fmt.Errorf("failed to delete route for service: %v", res.Service.Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return watchErr
|
||||
}
|
||||
|
||||
// Stop stops the router
|
||||
func (r *router) Stop() error {
|
||||
// notify all goroutines to finish
|
||||
close(r.exit)
|
||||
|
||||
// wait for all goroutines to finish
|
||||
r.wg.Wait()
|
||||
|
||||
// NOTE: we need a more efficient way of doing this e.g. network routes
|
||||
// should ideally be autodeleted when the router stops gossiping
|
||||
query := NewQuery(QueryRouter(r), QueryNetwork(r.opts.Advertise))
|
||||
routes, err := r.opts.Table.Lookup(query)
|
||||
if err != nil && err != ErrRouteNotFound {
|
||||
return fmt.Errorf("failed to lookup routes for router %s: %v", r.opts.ID, err)
|
||||
}
|
||||
|
||||
// parse router to registry.Node
|
||||
node, err := r.parseToNode()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to parse router into service node: %v", err)
|
||||
}
|
||||
|
||||
for _, route := range routes {
|
||||
service := ®istry.Service{
|
||||
Name: route.Destination,
|
||||
Nodes: []*registry.Node{node},
|
||||
}
|
||||
if err := r.opts.Network.Deregister(service); err != nil {
|
||||
return fmt.Errorf("failed to deregister service %s from network registry: %v", service.Name, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// String prints debugging information about router
|
||||
func (r *router) String() string {
|
||||
sb := &strings.Builder{}
|
||||
|
||||
table := tablewriter.NewWriter(sb)
|
||||
table.SetHeader([]string{"ID", "Address", "Network", "Table"})
|
||||
|
||||
data := []string{
|
||||
r.opts.ID,
|
||||
r.opts.Address,
|
||||
r.opts.Advertise,
|
||||
fmt.Sprintf("%d", r.opts.Table.Size()),
|
||||
}
|
||||
table.Append(data)
|
||||
|
||||
// render table into sb
|
||||
table.Render()
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
@@ -1,289 +0,0 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"hash"
|
||||
"hash/fnv"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/olekukonko/tablewriter"
|
||||
)
|
||||
|
||||
// TableOptions are routing table options
|
||||
// TODO: table options TBD in the future
|
||||
type TableOptions struct{}
|
||||
|
||||
// table is in memory routing table
|
||||
type table struct {
|
||||
// opts are table options
|
||||
opts TableOptions
|
||||
// m stores routing table map
|
||||
m map[string]map[uint64]Route
|
||||
// h hashes route entries
|
||||
h hash.Hash64
|
||||
// w is a list of table watchers
|
||||
w map[string]*tableWatcher
|
||||
sync.RWMutex
|
||||
}
|
||||
|
||||
// newTable creates in memory routing table and returns it
|
||||
func newTable(opts ...TableOption) Table {
|
||||
// default options
|
||||
var options TableOptions
|
||||
|
||||
// apply requested options
|
||||
for _, o := range opts {
|
||||
o(&options)
|
||||
}
|
||||
|
||||
h := fnv.New64()
|
||||
h.Reset()
|
||||
|
||||
return &table{
|
||||
opts: options,
|
||||
m: make(map[string]map[uint64]Route),
|
||||
w: make(map[string]*tableWatcher),
|
||||
h: h,
|
||||
}
|
||||
}
|
||||
|
||||
// Init initializes routing table with options
|
||||
func (t *table) Init(opts ...TableOption) error {
|
||||
for _, o := range opts {
|
||||
o(&t.opts)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Options returns routing table options
|
||||
func (t *table) Options() TableOptions {
|
||||
return t.opts
|
||||
}
|
||||
|
||||
// Add adds a route to the routing table
|
||||
func (t *table) Add(r Route) error {
|
||||
destAddr := r.Destination
|
||||
sum := t.hash(r)
|
||||
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
// check if the destination has any routes in the table
|
||||
if _, ok := t.m[destAddr]; !ok {
|
||||
t.m[destAddr] = make(map[uint64]Route)
|
||||
t.m[destAddr][sum] = r
|
||||
go t.sendEvent(&Event{Type: CreateEvent, Route: r})
|
||||
return nil
|
||||
}
|
||||
|
||||
// add new route to the table for the given destination
|
||||
if _, ok := t.m[destAddr][sum]; !ok {
|
||||
t.m[destAddr][sum] = r
|
||||
go t.sendEvent(&Event{Type: CreateEvent, Route: r})
|
||||
return nil
|
||||
}
|
||||
|
||||
// only add the route if the route override is explicitly requested
|
||||
if _, ok := t.m[destAddr][sum]; ok && r.Policy == OverrideIfExists {
|
||||
t.m[destAddr][sum] = r
|
||||
go t.sendEvent(&Event{Type: UpdateEvent, Route: r})
|
||||
return nil
|
||||
}
|
||||
|
||||
// if we reached this point without already returning the route already exists
|
||||
// we return nil only if explicitly requested by the client
|
||||
if r.Policy == IgnoreIfExists {
|
||||
return nil
|
||||
}
|
||||
|
||||
return ErrDuplicateRoute
|
||||
}
|
||||
|
||||
// Delete deletes the route from the routing table
|
||||
func (t *table) Delete(r Route) error {
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
destAddr := r.Destination
|
||||
sum := t.hash(r)
|
||||
|
||||
if _, ok := t.m[destAddr]; !ok {
|
||||
return ErrRouteNotFound
|
||||
}
|
||||
|
||||
delete(t.m[destAddr], sum)
|
||||
go t.sendEvent(&Event{Type: DeleteEvent, Route: r})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Update updates routing table with new route
|
||||
func (t *table) Update(r Route) error {
|
||||
destAddr := r.Destination
|
||||
sum := t.hash(r)
|
||||
|
||||
t.Lock()
|
||||
defer t.Unlock()
|
||||
|
||||
// check if the destAddr has ANY routes in the table
|
||||
if _, ok := t.m[destAddr]; !ok {
|
||||
return ErrRouteNotFound
|
||||
}
|
||||
|
||||
// if the route has been found update it
|
||||
if _, ok := t.m[destAddr][sum]; ok {
|
||||
t.m[destAddr][sum] = r
|
||||
go t.sendEvent(&Event{Type: UpdateEvent, Route: r})
|
||||
return nil
|
||||
}
|
||||
|
||||
return ErrRouteNotFound
|
||||
}
|
||||
|
||||
// List returns a list of all routes in the table
|
||||
func (t *table) List() ([]Route, error) {
|
||||
t.RLock()
|
||||
defer t.RUnlock()
|
||||
|
||||
var routes []Route
|
||||
for _, rmap := range t.m {
|
||||
for _, route := range rmap {
|
||||
routes = append(routes, route)
|
||||
}
|
||||
}
|
||||
|
||||
return routes, nil
|
||||
}
|
||||
|
||||
// Lookup queries routing table and returns all routes that match it
|
||||
func (t *table) Lookup(q Query) ([]Route, error) {
|
||||
t.RLock()
|
||||
defer t.RUnlock()
|
||||
|
||||
var results []Route
|
||||
|
||||
for destAddr, routes := range t.m {
|
||||
if q.Options().Destination != "*" {
|
||||
if q.Options().Destination != destAddr {
|
||||
continue
|
||||
}
|
||||
for _, route := range routes {
|
||||
if q.Options().Network == "*" || q.Options().Network == route.Network {
|
||||
if q.Options().Router.ID() == "*" || q.Options().Router.ID() == route.Router.ID() {
|
||||
if route.Metric <= q.Options().Metric {
|
||||
results = append(results, route)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if q.Options().Destination == "*" {
|
||||
for _, route := range routes {
|
||||
if q.Options().Network == "*" || q.Options().Network == route.Router.Network() {
|
||||
if q.Options().Router.ID() == "*" || q.Options().Router.ID() == route.Router.ID() {
|
||||
if route.Metric <= q.Options().Metric {
|
||||
results = append(results, route)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(results) == 0 && q.Options().Policy != DiscardNoRoute {
|
||||
return nil, ErrRouteNotFound
|
||||
}
|
||||
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// Watch returns routing table entry watcher
|
||||
func (t *table) Watch(opts ...WatchOption) (Watcher, error) {
|
||||
// by default watch everything
|
||||
wopts := WatchOptions{
|
||||
Destination: "*",
|
||||
Network: "*",
|
||||
}
|
||||
|
||||
for _, o := range opts {
|
||||
o(&wopts)
|
||||
}
|
||||
|
||||
watcher := &tableWatcher{
|
||||
opts: wopts,
|
||||
resChan: make(chan *Event, 10),
|
||||
done: make(chan struct{}),
|
||||
}
|
||||
|
||||
t.Lock()
|
||||
t.w[uuid.New().String()] = watcher
|
||||
t.Unlock()
|
||||
|
||||
return watcher, nil
|
||||
}
|
||||
|
||||
// sendEvent sends rules to all subscribe watchers
|
||||
func (t *table) sendEvent(r *Event) {
|
||||
t.RLock()
|
||||
defer t.RUnlock()
|
||||
|
||||
for _, w := range t.w {
|
||||
select {
|
||||
case w.resChan <- r:
|
||||
case <-w.done:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Size returns the size of the routing table
|
||||
func (t *table) Size() int {
|
||||
t.RLock()
|
||||
defer t.RUnlock()
|
||||
|
||||
return len(t.m)
|
||||
}
|
||||
|
||||
// String returns debug information
|
||||
func (t *table) String() string {
|
||||
t.RLock()
|
||||
defer t.RUnlock()
|
||||
|
||||
// this will help us build routing table string
|
||||
sb := &strings.Builder{}
|
||||
|
||||
// create nice table printing structure
|
||||
table := tablewriter.NewWriter(sb)
|
||||
table.SetHeader([]string{"Destination", "Router", "Network", "Metric"})
|
||||
|
||||
for _, destRoute := range t.m {
|
||||
for _, route := range destRoute {
|
||||
strRoute := []string{
|
||||
route.Destination,
|
||||
route.Router.Address(),
|
||||
route.Network,
|
||||
fmt.Sprintf("%d", route.Metric),
|
||||
}
|
||||
table.Append(strRoute)
|
||||
}
|
||||
}
|
||||
|
||||
// render table into sb
|
||||
table.Render()
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
// hash hashes the route using router gateway and network address
|
||||
func (t *table) hash(r Route) uint64 {
|
||||
destAddr := r.Destination
|
||||
routerAddr := r.Router.Address()
|
||||
netAddr := r.Network
|
||||
|
||||
t.h.Reset()
|
||||
t.h.Write([]byte(destAddr + routerAddr + netAddr))
|
||||
|
||||
return t.h.Sum64()
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"github.com/google/uuid"
|
||||
"github.com/micro/go-micro/registry"
|
||||
)
|
||||
|
||||
var (
|
||||
// DefaultAddress is default router address
|
||||
DefaultAddress = ":9093"
|
||||
// DefaultAdvertise is default address advertised to the network
|
||||
DefaultAdvertise = ":9094"
|
||||
)
|
||||
|
||||
// Options are router options
|
||||
type Options struct {
|
||||
// ID is router id
|
||||
ID string
|
||||
// Address is router address
|
||||
Address string
|
||||
// Advertise is the address advertised to the network
|
||||
Advertise string
|
||||
// Registry is the local registry
|
||||
Registry registry.Registry
|
||||
// Networkis the network registry
|
||||
Network registry.Registry
|
||||
// Table is routing table
|
||||
Table Table
|
||||
}
|
||||
|
||||
// ID sets Router ID
|
||||
func ID(id string) Option {
|
||||
return func(o *Options) {
|
||||
o.ID = id
|
||||
}
|
||||
}
|
||||
|
||||
// Address sets router service address
|
||||
func Address(a string) Option {
|
||||
return func(o *Options) {
|
||||
o.Address = a
|
||||
}
|
||||
}
|
||||
|
||||
// Advertise sets the address that is advertise to the network
|
||||
func Advertise(n string) Option {
|
||||
return func(o *Options) {
|
||||
o.Advertise = n
|
||||
}
|
||||
}
|
||||
|
||||
// RoutingTable sets the routing table
|
||||
func RoutingTable(t Table) Option {
|
||||
return func(o *Options) {
|
||||
o.Table = t
|
||||
}
|
||||
}
|
||||
|
||||
// Registry sets the local registry
|
||||
func Registry(r registry.Registry) Option {
|
||||
return func(o *Options) {
|
||||
o.Registry = r
|
||||
}
|
||||
}
|
||||
|
||||
// Network sets the network registry
|
||||
func Network(r registry.Registry) Option {
|
||||
return func(o *Options) {
|
||||
o.Network = r
|
||||
}
|
||||
}
|
||||
|
||||
// DefaultOptions returns router default options
|
||||
func DefaultOptions() Options {
|
||||
// NOTE: by default both local and network registies use default registry i.e. mdns
|
||||
return Options{
|
||||
ID: uuid.New().String(),
|
||||
Address: DefaultAddress,
|
||||
Advertise: DefaultAdvertise,
|
||||
Registry: registry.DefaultRegistry,
|
||||
Network: registry.DefaultRegistry,
|
||||
Table: NewTable(),
|
||||
}
|
||||
}
|
||||
116
router/query.go
116
router/query.go
@@ -1,116 +0,0 @@
|
||||
package router
|
||||
|
||||
// LookupPolicy defines query policy
|
||||
type LookupPolicy int
|
||||
|
||||
const (
|
||||
// DiscardNoRoute discards query when no route is found
|
||||
DiscardNoRoute LookupPolicy = iota
|
||||
// ClosestMatch returns closest match to supplied query
|
||||
ClosestMatch
|
||||
)
|
||||
|
||||
// String returns human representation of LookupPolicy
|
||||
func (lp LookupPolicy) String() string {
|
||||
switch lp {
|
||||
case DiscardNoRoute:
|
||||
return "DISCARD"
|
||||
case ClosestMatch:
|
||||
return "CLOSEST"
|
||||
default:
|
||||
return "UNKNOWN"
|
||||
}
|
||||
}
|
||||
|
||||
// QueryOption sets routing table query options
|
||||
type QueryOption func(*QueryOptions)
|
||||
|
||||
// QueryOptions are routing table query options
|
||||
type QueryOptions struct {
|
||||
// Destination is destination address
|
||||
Destination string
|
||||
// Network is network address
|
||||
Network string
|
||||
// Router is gateway address
|
||||
Router Router
|
||||
// Metric is route metric
|
||||
Metric int
|
||||
// Policy is query lookup policy
|
||||
Policy LookupPolicy
|
||||
}
|
||||
|
||||
// QueryDestination sets query destination address
|
||||
func QueryDestination(a string) QueryOption {
|
||||
return func(o *QueryOptions) {
|
||||
o.Destination = a
|
||||
}
|
||||
}
|
||||
|
||||
// QueryNetwork sets query network address
|
||||
func QueryNetwork(a string) QueryOption {
|
||||
return func(o *QueryOptions) {
|
||||
o.Network = a
|
||||
}
|
||||
}
|
||||
|
||||
// QueryRouter sets query gateway address
|
||||
func QueryRouter(r Router) QueryOption {
|
||||
return func(o *QueryOptions) {
|
||||
o.Router = r
|
||||
}
|
||||
}
|
||||
|
||||
// QueryMetric sets query metric
|
||||
func QueryMetric(m int) QueryOption {
|
||||
return func(o *QueryOptions) {
|
||||
o.Metric = m
|
||||
}
|
||||
}
|
||||
|
||||
// QueryPolicy sets query policy
|
||||
// NOTE: this might be renamed to filter or some such
|
||||
func QueryPolicy(p LookupPolicy) QueryOption {
|
||||
return func(o *QueryOptions) {
|
||||
o.Policy = p
|
||||
}
|
||||
}
|
||||
|
||||
// Query is routing table query
|
||||
type Query interface {
|
||||
// Options returns query options
|
||||
Options() QueryOptions
|
||||
}
|
||||
|
||||
// query is a basic implementation of Query
|
||||
type query struct {
|
||||
opts QueryOptions
|
||||
}
|
||||
|
||||
// NewQuery creates new query and returns it
|
||||
func NewQuery(opts ...QueryOption) Query {
|
||||
// default gateway for wildcard router
|
||||
r := newRouter(ID("*"))
|
||||
|
||||
// default options
|
||||
// NOTE: by default we use DefaultNetworkMetric
|
||||
qopts := QueryOptions{
|
||||
Destination: "*",
|
||||
Network: "*",
|
||||
Router: r,
|
||||
Metric: DefaultNetworkMetric,
|
||||
Policy: DiscardNoRoute,
|
||||
}
|
||||
|
||||
for _, o := range opts {
|
||||
o(&qopts)
|
||||
}
|
||||
|
||||
return &query{
|
||||
opts: qopts,
|
||||
}
|
||||
}
|
||||
|
||||
// Options returns query options
|
||||
func (q *query) Options() QueryOptions {
|
||||
return q.opts
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/olekukonko/tablewriter"
|
||||
)
|
||||
|
||||
var (
|
||||
// DefaultLocalMetric is default route cost for local network
|
||||
DefaultLocalMetric = 1
|
||||
// DefaultNetworkMetric is default route cost for micro network
|
||||
DefaultNetworkMetric = 10
|
||||
)
|
||||
|
||||
// RoutePolicy defines routing table addition policy
|
||||
type RoutePolicy int
|
||||
|
||||
const (
|
||||
// OverrideIfExists overrides route if it already exists
|
||||
OverrideIfExists RoutePolicy = iota
|
||||
// IgnoreIfExists does not modify existing route
|
||||
IgnoreIfExists
|
||||
)
|
||||
|
||||
// String returns human reprensentation of policy
|
||||
func (p RoutePolicy) String() string {
|
||||
switch p {
|
||||
case OverrideIfExists:
|
||||
return "OVERRIDE"
|
||||
case IgnoreIfExists:
|
||||
return "IGNORE"
|
||||
default:
|
||||
return "UNKNOWN"
|
||||
}
|
||||
}
|
||||
|
||||
// Route is network route
|
||||
type Route struct {
|
||||
// Destination is destination address
|
||||
Destination string
|
||||
// Router is the network router
|
||||
Router Router
|
||||
// Network is micro network address
|
||||
Network string
|
||||
// Metric is the route cost metric
|
||||
Metric int
|
||||
// Policy defines route policy
|
||||
Policy RoutePolicy
|
||||
}
|
||||
|
||||
// String allows to print the route
|
||||
func (r *Route) String() string {
|
||||
// this will help us build routing table string
|
||||
sb := &strings.Builder{}
|
||||
|
||||
// create nice table printing structure
|
||||
table := tablewriter.NewWriter(sb)
|
||||
table.SetHeader([]string{"Destination", "Router", "Network", "Metric"})
|
||||
|
||||
strRoute := []string{
|
||||
r.Destination,
|
||||
r.Router.Address(),
|
||||
r.Network,
|
||||
fmt.Sprintf("%d", r.Metric),
|
||||
}
|
||||
table.Append(strRoute)
|
||||
|
||||
// render table into sb
|
||||
table.Render()
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
// Package router provides a network routing control plane
|
||||
package router
|
||||
|
||||
// Router is an interface for a routing control plane
|
||||
type Router interface {
|
||||
// Init initializes the router with options
|
||||
Init(...Option) error
|
||||
// Options returns the router options
|
||||
Options() Options
|
||||
// ID returns the id of the router
|
||||
ID() string
|
||||
// Table returns the routing table
|
||||
Table() Table
|
||||
// Address returns the router adddress
|
||||
Address() string
|
||||
// Network returns the network address of the router
|
||||
Network() string
|
||||
// Advertise starts advertising the routes to the network
|
||||
Advertise() error
|
||||
// Stop stops the router
|
||||
Stop() error
|
||||
// String returns debug info
|
||||
String() string
|
||||
}
|
||||
|
||||
// Option used by the router
|
||||
type Option func(*Options)
|
||||
|
||||
// NewRouter creates new Router and returns it
|
||||
func NewRouter(opts ...Option) Router {
|
||||
return newRouter(opts...)
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"errors"
|
||||
)
|
||||
|
||||
var (
|
||||
// ErrRouteNotFound is returned when no route was found in the routing table
|
||||
ErrRouteNotFound = errors.New("route not found")
|
||||
// ErrDuplicateRoute is returned when the route already exists
|
||||
ErrDuplicateRoute = errors.New("duplicate route")
|
||||
)
|
||||
|
||||
// Table defines routing table interface
|
||||
type Table interface {
|
||||
// Init initializes the router with options
|
||||
Init(...TableOption) error
|
||||
// Options returns the router options
|
||||
Options() TableOptions
|
||||
// Add adds new route to the routing table
|
||||
Add(Route) error
|
||||
// Delete deletes existing route from the routing table
|
||||
Delete(Route) error
|
||||
// Update updates route in the routing table
|
||||
Update(Route) error
|
||||
// List returns the list of all routes in the table
|
||||
List() ([]Route, error)
|
||||
// Lookup looks up routes in the routing table and returns them
|
||||
Lookup(Query) ([]Route, error)
|
||||
// Watch returns a watcher which allows to track updates to the routing table
|
||||
Watch(opts ...WatchOption) (Watcher, error)
|
||||
// Size returns the size of the routing table
|
||||
Size() int
|
||||
// String prints the routing table
|
||||
String() string
|
||||
}
|
||||
|
||||
// TableOption used by the routing table
|
||||
type TableOption func(*TableOptions)
|
||||
|
||||
// NewTable creates new routing table and returns it
|
||||
func NewTable(opts ...TableOption) Table {
|
||||
return newTable(opts...)
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"strings"
|
||||
|
||||
"github.com/olekukonko/tablewriter"
|
||||
)
|
||||
|
||||
var (
|
||||
// ErrWatcherStopped is returned when routing table watcher has been stopped
|
||||
ErrWatcherStopped = errors.New("routing table watcher stopped")
|
||||
)
|
||||
|
||||
// EventType defines routing table event
|
||||
type EventType int
|
||||
|
||||
const (
|
||||
// CreateEvent is emitted when new route has been created
|
||||
CreateEvent EventType = iota
|
||||
// DeleteEvent is emitted when an existing route has been deleted
|
||||
DeleteEvent
|
||||
// UpdateEvent is emitted when a routing table has been updated
|
||||
UpdateEvent
|
||||
)
|
||||
|
||||
// String returns string representation of the event
|
||||
func (et EventType) String() string {
|
||||
switch et {
|
||||
case CreateEvent:
|
||||
return "CREATE"
|
||||
case DeleteEvent:
|
||||
return "DELETE"
|
||||
case UpdateEvent:
|
||||
return "UPDATE"
|
||||
default:
|
||||
return "UNKNOWN"
|
||||
}
|
||||
}
|
||||
|
||||
// Event is returned by a call to Next on the watcher.
|
||||
type Event struct {
|
||||
// Type defines type of event
|
||||
Type EventType
|
||||
// Route is table rout
|
||||
Route Route
|
||||
}
|
||||
|
||||
// WatchOption is used to define what routes to watch in the table
|
||||
type WatchOption func(*WatchOptions)
|
||||
|
||||
// Watcher defines routing table watcher interface
|
||||
// Watcher returns updates to the routing table
|
||||
type Watcher interface {
|
||||
// Next is a blocking call that returns watch result
|
||||
Next() (*Event, error)
|
||||
// Chan returns event channel
|
||||
Chan() (<-chan *Event, error)
|
||||
// Stop stops watcher
|
||||
Stop()
|
||||
}
|
||||
|
||||
// WatchOptions are table watcher options
|
||||
type WatchOptions struct {
|
||||
// Specify destination address to watch
|
||||
Destination string
|
||||
// Specify network to watch
|
||||
Network string
|
||||
}
|
||||
|
||||
// WatchDestination sets what destination to watch
|
||||
// Destination is usually microservice name
|
||||
func WatchDestination(a string) WatchOption {
|
||||
return func(o *WatchOptions) {
|
||||
o.Destination = a
|
||||
}
|
||||
}
|
||||
|
||||
// WatchNetwork sets what network to watch
|
||||
func WatchNetwork(n string) WatchOption {
|
||||
return func(o *WatchOptions) {
|
||||
o.Network = n
|
||||
}
|
||||
}
|
||||
|
||||
type tableWatcher struct {
|
||||
opts WatchOptions
|
||||
resChan chan *Event
|
||||
done chan struct{}
|
||||
}
|
||||
|
||||
// Next returns the next noticed action taken on table
|
||||
// TODO: this needs to be thought through properly
|
||||
// we are aiming to provide the same options Query provides
|
||||
func (w *tableWatcher) Next() (*Event, error) {
|
||||
for {
|
||||
select {
|
||||
case res := <-w.resChan:
|
||||
switch w.opts.Destination {
|
||||
case "*", "":
|
||||
if w.opts.Network == "*" || w.opts.Network == res.Route.Network {
|
||||
return res, nil
|
||||
}
|
||||
case res.Route.Destination:
|
||||
if w.opts.Network == "*" || w.opts.Network == res.Route.Network {
|
||||
return res, nil
|
||||
}
|
||||
}
|
||||
case <-w.done:
|
||||
return nil, ErrWatcherStopped
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Chan returns watcher events channel
|
||||
func (w *tableWatcher) Chan() (<-chan *Event, error) {
|
||||
return w.resChan, nil
|
||||
}
|
||||
|
||||
// Stop stops routing table watcher
|
||||
func (w *tableWatcher) Stop() {
|
||||
select {
|
||||
case <-w.done:
|
||||
return
|
||||
default:
|
||||
close(w.done)
|
||||
}
|
||||
}
|
||||
|
||||
// String prints debug information
|
||||
func (w *tableWatcher) String() string {
|
||||
sb := &strings.Builder{}
|
||||
|
||||
table := tablewriter.NewWriter(sb)
|
||||
table.SetHeader([]string{"Destination", "Network"})
|
||||
|
||||
data := []string{
|
||||
w.opts.Destination,
|
||||
w.opts.Network,
|
||||
}
|
||||
table.Append(data)
|
||||
|
||||
// render table into sb
|
||||
table.Render()
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
Reference in New Issue
Block a user