36-add-route-path-into-route-object

Added the route path into the route object so that we can
see what meshes packets are routed across.

cmd/dns/main.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"log"
+
+	smegdns "github.com/tim-beatham/wgmesh/pkg/dns"
+)
+
+func main() {
+	server, err := smegdns.NewDns(53)
+
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	defer server.Close()
+	server.Listen()
+}

cmd/wg-mesh/main.go

@@ -8,7 +8,9 @@ import (
 	"time"
 
 	"github.com/akamensky/argparse"
+	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
 	"github.com/tim-beatham/wgmesh/pkg/ipc"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
 	logging "github.com/tim-beatham/wgmesh/pkg/log"
 )
 
@@ -93,9 +95,13 @@ func getMesh(client *ipcRpc.Client, meshId string) {
 		fmt.Println("Control Endpoint: " + node.HostEndpoint)
 		fmt.Println("WireGuard Endpoint: " + node.WgEndpoint)
 		fmt.Println("Wg IP: " + node.WgHost)
-		fmt.Println(fmt.Sprintf("Timestamp: %s", time.Unix(node.Timestamp, 0).String()))
+		fmt.Printf("Timestamp: %s", time.Unix(node.Timestamp, 0).String())
 
-		advertiseRoutes := strings.Join(node.Routes, ",")
+		mapFunc := func(r ctrlserver.MeshRoute) string {
+			return r.Destination
+		}
+
+		advertiseRoutes := strings.Join(lib.Map(node.Routes, mapFunc), ",")
 		fmt.Printf("Routes: %s\n", advertiseRoutes)
 
 		fmt.Println("---")

cmd/wgmeshd/main.go

@@ -13,7 +13,7 @@ import (
 	"github.com/tim-beatham/wgmesh/pkg/mesh"
 	"github.com/tim-beatham/wgmesh/pkg/robin"
 	"github.com/tim-beatham/wgmesh/pkg/sync"
-	"github.com/tim-beatham/wgmesh/pkg/timestamp"
+	timer "github.com/tim-beatham/wgmesh/pkg/timers"
 	"golang.zx2c4.com/wireguard/wgctrl"
 )
 
@@ -57,8 +57,9 @@ func main() {
 	syncProvider.Server = ctrlServer
 	syncRequester := sync.NewSyncRequester(ctrlServer)
 	syncScheduler := sync.NewSyncScheduler(ctrlServer, syncRequester)
-	timestampScheduler := timestamp.NewTimestampScheduler(ctrlServer)
+	timestampScheduler := timer.NewTimestampScheduler(ctrlServer)
 	pruneScheduler := mesh.NewPruner(ctrlServer.MeshManager, *conf)
+	routeScheduler := timer.NewRouteScheduler(ctrlServer)
 
 	robinIpcParams := robin.RobinIpcParams{
 		CtrlServer: ctrlServer,
@@ -78,6 +79,7 @@ func main() {
 	go syncScheduler.Run()
 	go timestampScheduler.Run()
 	go pruneScheduler.Run()
+	go routeScheduler.Run()
 
 	closeResources := func() {
 		logging.Log.WriteInfof("Closing resources")

pkg/api/apiserver.go

@@ -30,15 +30,14 @@ func (s *SmegServer) routeToApiRoute(meshNode ctrlserver.MeshNode) []Route {
 	routes := make([]Route, len(meshNode.Routes))
 
 	for index, route := range meshNode.Routes {
-		word, err := s.words.Convert(route)
 
-		if err != nil {
+		if route.Path == nil {
-			fmt.Println(err.Error())
+			route.Path = make([]string, 0)
 		}
 
 		routes[index] = Route{
-			Prefix:  route,
+			Prefix: route.Destination,
-			RouteId: word,
+			Path:   route.Path,
 		}
 	}
 
@@ -47,7 +46,7 @@ func (s *SmegServer) routeToApiRoute(meshNode ctrlserver.MeshNode) []Route {
 
 func (s *SmegServer) meshNodeToAPIMeshNode(meshNode ctrlserver.MeshNode) *SmegNode {
 	if meshNode.Routes == nil {
-		meshNode.Routes = make([]string, 0)
+		meshNode.Routes = make([]ctrlserver.MeshRoute, 0)
 	}
 
 	alias := meshNode.Alias

pkg/api/types.go

@@ -1,8 +1,8 @@
 package api
 
 type Route struct {
-	RouteId string `json:"routeId"`
+	Prefix string   `json:"prefix"`
-	Prefix  string `json:"prefix"`
+	Path   []string `json:"path"`
 }
 
 type SmegNode struct {

pkg/automerge/automerge.go

@@ -35,7 +35,7 @@ func (c *CrdtMeshManager) AddNode(node mesh.MeshNode) {
 		panic("node must be of type *MeshNodeCrdt")
 	}
 
-	crdt.Routes = make(map[string]interface{})
+	crdt.Routes = make(map[string]Route)
 	crdt.Services = make(map[string]string)
 	crdt.Timestamp = time.Now().Unix()
 
@@ -58,11 +58,30 @@ func (c *CrdtMeshManager) isPeer(nodeId string) bool {
 	return nodeType.Str() == string(conf.PEER_ROLE)
 }
 
+// isAlive: checks that the node's configuration has been updated
+// since the rquired keep alive time
+func (c *CrdtMeshManager) isAlive(nodeId string) bool {
+	node, err := c.doc.Path("nodes").Map().Get(nodeId)
+
+	if err != nil || node.Kind() != automerge.KindMap {
+		return false
+	}
+
+	timestamp, err := node.Map().Get("timestamp")
+
+	if err != nil || timestamp.Kind() != automerge.KindInt64 {
+		return false
+	}
+
+	keepAliveTime := timestamp.Int64()
+	return (time.Now().Unix() - keepAliveTime) < int64(c.conf.DeadTime)
+}
+
 func (c *CrdtMeshManager) GetPeers() []string {
 	keys, _ := c.doc.Path("nodes").Map().Keys()
 
-	keys = lib.Filter(keys, func(s string) bool {
+	keys = lib.Filter(keys, func(publicKey string) bool {
-		return c.isPeer(s)
+		return c.isPeer(publicKey) && c.isAlive(publicKey)
 	})
 
 	return keys
@@ -300,7 +319,7 @@ func (m *CrdtMeshManager) RemoveService(nodeId, key string) error {
 }
 
 // AddRoutes: adds routes to the specific nodeId
-func (m *CrdtMeshManager) AddRoutes(nodeId string, routes ...string) error {
+func (m *CrdtMeshManager) AddRoutes(nodeId string, routes ...mesh.Route) error {
 	nodeVal, err := m.doc.Path("nodes").Map().Get(nodeId)
 	logging.Log.WriteInfof("Adding route to %s", nodeId)
 
@@ -319,7 +338,10 @@ func (m *CrdtMeshManager) AddRoutes(nodeId string, routes ...string) error {
 	}
 
 	for _, route := range routes {
-		err = routeMap.Map().Set(route, struct{}{})
+		err = routeMap.Map().Set(route.GetDestination().String(), Route{
+			Destination: route.GetDestination().String(),
+			Path:        route.GetPath(),
+		})
 
 		if err != nil {
 			return err
@@ -328,6 +350,67 @@ func (m *CrdtMeshManager) AddRoutes(nodeId string, routes ...string) error {
 	return nil
 }
 
+func (m *CrdtMeshManager) getRoutes(nodeId string) ([]Route, error) {
+	nodeVal, err := m.doc.Path("nodes").Map().Get(nodeId)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if nodeVal.Kind() != automerge.KindMap {
+		return nil, fmt.Errorf("node does not exist")
+	}
+
+	routeMap, err := nodeVal.Map().Get("routes")
+
+	if err != nil {
+		return nil, err
+	}
+
+	if routeMap.Kind() != automerge.KindMap {
+		return nil, fmt.Errorf("node %s is not a map", nodeId)
+	}
+
+	routes, err := automerge.As[map[string]Route](routeMap)
+
+	return lib.MapValues(routes), err
+}
+
+func (m *CrdtMeshManager) GetRoutes(targetNode string) (map[string]mesh.Route, error) {
+	node, err := m.GetNode(targetNode)
+
+	if err != nil {
+		return nil, err
+	}
+
+	routes := make(map[string]mesh.Route)
+
+	for _, route := range node.GetRoutes() {
+		routes[route.GetDestination().String()] = route
+	}
+
+	for _, node := range m.GetPeers() {
+		nodeRoutes, err := m.getRoutes(node)
+
+		if err != nil {
+			return nil, err
+		}
+
+		for _, route := range nodeRoutes {
+			otherRoute, ok := routes[route.GetDestination().String()]
+
+			if !ok || route.GetHopCount()+1 < otherRoute.GetHopCount() {
+				routes[route.GetDestination().String()] = &Route{
+					Destination: route.GetDestination().String(),
+					Path:        append(route.Path, m.GetMeshId()),
+				}
+			}
+		}
+	}
+
+	return routes, nil
+}
+
 // DeleteRoutes deletes the specified routes
 func (m *CrdtMeshManager) RemoveRoutes(nodeId string, routes ...string) error {
 	nodeVal, err := m.doc.Path("nodes").Map().Get(nodeId)
@@ -440,8 +523,13 @@ func (m *MeshNodeCrdt) GetTimeStamp() int64 {
 	return m.Timestamp
 }
 
-func (m *MeshNodeCrdt) GetRoutes() []string {
+func (m *MeshNodeCrdt) GetRoutes() []mesh.Route {
-	return lib.MapKeys(m.Routes)
+	return lib.Map(lib.MapValues(m.Routes), func(r Route) mesh.Route {
+		return &Route{
+			Destination: r.Destination,
+			Path:        r.Path,
+		}
+	})
 }
 
 func (m *MeshNodeCrdt) GetDescription() string {
@@ -497,3 +585,16 @@ func (m *MeshCrdt) GetNodes() map[string]mesh.MeshNode {
 
 	return nodes
 }
+
+func (r *Route) GetDestination() *net.IPNet {
+	_, ipnet, _ := net.ParseCIDR(r.Destination)
+	return ipnet
+}
+
+func (r *Route) GetHopCount() int {
+	return len(r.Path)
+}
+
+func (r *Route) GetPath() []string {
+	return r.Path
+}

pkg/automerge/factory.go

@@ -41,7 +41,7 @@ func (f *MeshNodeFactory) Build(params *mesh.MeshNodeFactoryParams) mesh.MeshNod
 		WgHost:       fmt.Sprintf("%s/128", params.NodeIP.String()),
 		// Always set the routes as empty.
 		// Routes handled by external component
-		Routes:      map[string]interface{}{},
+		Routes:      make(map[string]Route),
 		Description: "",
 		Alias:       "",
 		Type:        string(f.Config.Role),

pkg/automerge/types.go

@@ -1,17 +1,23 @@
 package crdt
 
+// Route: Represents a CRDT of the given route
+type Route struct {
+	Destination string   `automerge:"destination"`
+	Path        []string `automerge:"path"`
+}
+
 // MeshNodeCrdt: Represents a CRDT for a mesh nodes
 type MeshNodeCrdt struct {
-	HostEndpoint string                 `automerge:"hostEndpoint"`
+	HostEndpoint string            `automerge:"hostEndpoint"`
-	WgEndpoint   string                 `automerge:"wgEndpoint"`
+	WgEndpoint   string            `automerge:"wgEndpoint"`
-	PublicKey    string                 `automerge:"publicKey"`
+	PublicKey    string            `automerge:"publicKey"`
-	WgHost       string                 `automerge:"wgHost"`
+	WgHost       string            `automerge:"wgHost"`
-	Timestamp    int64                  `automerge:"timestamp"`
+	Timestamp    int64             `automerge:"timestamp"`
-	Routes       map[string]interface{} `automerge:"routes"`
+	Routes       map[string]Route  `automerge:"routes"`
-	Alias        string                 `automerge:"alias"`
+	Alias        string            `automerge:"alias"`
-	Description  string                 `automerge:"description"`
+	Description  string            `automerge:"description"`
-	Services     map[string]string      `automerge:"services"`
+	Services     map[string]string `automerge:"services"`
-	Type         string                 `automerge:"type"`
+	Type         string            `automerge:"type"`
 }
 
 // MeshCrdt: Represents the mesh network as a whole

pkg/conf/conf.go

@@ -64,8 +64,11 @@ type WgMeshConfiguration struct {
 	KeepAliveTime int `yaml:"keepAliveTime"`
 	// Timeout number of seconds before we consider the node as dead
 	Timeout int `yaml:"timeout"`
-	// PruneTime number of seconds before we consider the 'node' as dead
+	// PruneTime number of seconds before we remove nodes that are likely to be dead
 	PruneTime int `yaml:"pruneTime"`
+	// DeadTime: number of seconds before we consider the node as dead and stop considering it
+	// when picking a random peer
+	DeadTime int `yaml:"deadTime"`
 	// Profile whether or not to include a http server that profiles the code
 	Profile bool `yaml:"profile"`
 	// StubWg whether or not to stub the WireGuard types
@@ -145,9 +148,15 @@ func ValidateConfiguration(c *WgMeshConfiguration) error {
 		}
 	}
 
-	if c.PruneTime <= 1 {
+	if c.PruneTime < 1 {
 		return &WgMeshConfigurationError{
-			msg: "Prune time cannot be <= 1",
+			msg: "Prune time cannot be < 1",
+		}
+	}
+
+	if c.DeadTime < 1 {
+		return &WgMeshConfigurationError{
+			msg: "Dead time cannot be < 1",
 		}
 	}
 

pkg/ctrlserver/ctrlserver.go

@@ -31,7 +31,7 @@ func NewCtrlServer(params *NewCtrlServerParams) (*MeshCtrlServer, error) {
 	nodeFactory := crdt.MeshNodeFactory{
 		Config: *params.Conf,
 	}
-	idGenerator := &lib.UUIDGenerator{}
+	idGenerator := &lib.IDNameGenerator{}
 	ipAllocator := &ip.ULABuilder{}
 	interfaceManipulator := wg.NewWgInterfaceManipulator(params.Client)
 

pkg/ctrlserver/ctrltypes.go

@@ -9,6 +9,11 @@ import (
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
+type MeshRoute struct {
+	Destination string
+	Path        []string
+}
+
 // Represents a WireGuard MeshNode
 type MeshNode struct {
 	HostEndpoint string
@@ -16,7 +21,7 @@ type MeshNode struct {
 	PublicKey    string
 	WgHost       string
 	Timestamp    int64
-	Routes       []string
+	Routes       []MeshRoute
 	Description  string
 	Alias        string
 	Services     map[string]string

pkg/dns/dns.go

@@ -0,0 +1,114 @@
+package smegdns
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/rpc"
+
+	"github.com/miekg/dns"
+	"github.com/tim-beatham/wgmesh/pkg/ipc"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
+	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"github.com/tim-beatham/wgmesh/pkg/query"
+)
+
+const SockAddr = "/tmp/wgmesh_ipc.sock"
+
+const MeshRegularExpression = `(?P<meshId>.+)\.(?P<alias>.+)\.smeg\.`
+
+type DNSHandler struct {
+	client *rpc.Client
+	server *dns.Server
+}
+
+// queryMesh: queries the mesh network for the given meshId and node
+// with alias
+func (d *DNSHandler) queryMesh(meshId, alias string) net.IP {
+	var reply string
+
+	err := d.client.Call("IpcHandler.Query", &ipc.QueryMesh{
+		MeshId: meshId,
+		Query:  fmt.Sprintf("[?alias == '%s'] | [0]", alias),
+	}, &reply)
+
+	if err != nil {
+		return nil
+	}
+
+	var node *query.QueryNode
+
+	err = json.Unmarshal([]byte(reply), &node)
+
+	if err != nil || node == nil {
+		return nil
+	}
+
+	ip, _, _ := net.ParseCIDR(node.WgHost)
+	return ip
+}
+
+func (d *DNSHandler) handleQuery(m *dns.Msg) {
+	for _, q := range m.Question {
+		switch q.Qtype {
+		case dns.TypeAAAA:
+			logging.Log.WriteInfof("Query for %s", q.Name)
+
+			groups := lib.MatchCaptureGroup(MeshRegularExpression, q.Name)
+
+			if len(groups) == 0 {
+				continue
+			}
+
+			ip := d.queryMesh(groups["meshId"], groups["alias"])
+
+			rr, err := dns.NewRR(fmt.Sprintf("%s AAAA %s", q.Name, ip))
+
+			if err != nil {
+				logging.Log.WriteErrorf(err.Error())
+			}
+
+			if err == nil {
+				m.Answer = append(m.Answer, rr)
+			}
+		}
+	}
+}
+
+func (h *DNSHandler) handleDnsRequest(w dns.ResponseWriter, r *dns.Msg) {
+	msg := new(dns.Msg)
+	msg.SetReply(r)
+	msg.Authoritative = true
+
+	switch r.Opcode {
+	case dns.OpcodeQuery:
+		h.handleQuery(msg)
+	}
+
+	w.WriteMsg(msg)
+}
+
+func (h *DNSHandler) Listen() error {
+	return h.server.ListenAndServe()
+}
+
+func (h *DNSHandler) Close() error {
+	return h.server.Shutdown()
+}
+
+func NewDns(udpPort int) (*DNSHandler, error) {
+	client, err := rpc.DialHTTP("unix", SockAddr)
+
+	if err != nil {
+		return nil, err
+	}
+
+	dnsHander := DNSHandler{
+		client: client,
+	}
+
+	dns.HandleFunc("smeg.", dnsHander.handleDnsRequest)
+
+	dnsHander.server = &dns.Server{Addr: fmt.Sprintf(":%d", udpPort), Net: "udp"}
+	return &dnsHander, nil
+}

pkg/ipc/ipc.go

@@ -62,7 +62,6 @@ type MeshIpc interface {
 	JoinMesh(args JoinMeshArgs, reply *string) error
 	LeaveMesh(meshId string, reply *string) error
 	GetMesh(meshId string, reply *GetMeshReply) error
-	EnableInterface(meshId string, reply *string) error
 	GetDOT(meshId string, reply *string) error
 	Query(query QueryMesh, reply *string) error
 	PutDescription(description string, reply *string) error

pkg/lib/conv.go

@@ -66,3 +66,13 @@ func Filter[V any](list []V, f filterFunc[V]) []V {
 
 	return newList
 }
+
+func Contains[V any](list []V, proposition func(V) bool) bool {
+	for _, elem := range list {
+		if proposition(elem) {
+			return true
+		}
+	}
+
+	return false
+}

pkg/lib/hashing.go

@@ -18,7 +18,7 @@ func HashString(value string) int {
 
 // ConsistentHash implementation. Traverse the values until we find a key
 // less than ours.
-func ConsistentHash[V any](values []V, client V, keyFunc func(V) int) V {
+func ConsistentHash[V any, K any](values []V, client K, bucketFunc func(V) int, keyFunc func(K) int) V {
 	if len(values) == 0 {
 		panic("values is empty")
 	}
@@ -26,7 +26,7 @@ func ConsistentHash[V any](values []V, client V, keyFunc func(V) int) V {
 	vs := Map(values, func(v V) consistentHashRecord[V] {
 		return consistentHashRecord[V]{
 			v,
-			keyFunc(v),
+			bucketFunc(v),
 		}
 	})
 

pkg/lib/id.go

@@ -1,6 +1,9 @@
 package lib
 
-import "github.com/google/uuid"
+import (
+	"github.com/anandvarma/namegen"
+	"github.com/google/uuid"
+)
 
 // IdGenerator generates unique ids
 type IdGenerator interface {
@@ -15,3 +18,11 @@ func (g *UUIDGenerator) GetId() (string, error) {
 	id := uuid.New()
 	return id.String(), nil
 }
+
+type IDNameGenerator struct {
+}
+
+func (i *IDNameGenerator) GetId() (string, error) {
+	name_schema := namegen.New()
+	return name_schema.Get(), nil
+}

pkg/lib/regex.go

@@ -0,0 +1,19 @@
+package lib
+
+import "regexp"
+
+func MatchCaptureGroup(pattern, payload string) map[string]string {
+	patterns := make(map[string]string)
+
+	expr := regexp.MustCompile(pattern)
+
+	match := expr.FindStringSubmatch(payload)
+
+	for i, name := range expr.SubexpNames() {
+		if i != 0 && name != "" {
+			patterns[name] = match[i]
+		}
+	}
+
+	return patterns
+}

pkg/lib/rtnetlink.go

@@ -201,7 +201,7 @@ func (c *RtNetlinkConfig) DeleteRoute(ifName string, route Route) error {
 	})
 
 	if err != nil {
-		return fmt.Errorf("failed to delete route %w", err)
+		return fmt.Errorf("failed to delete route %s", dst.IP.String())
 	}
 
 	return nil
@@ -219,22 +219,15 @@ func (r1 Route) equal(r2 Route) bool {
 
 // DeleteRoutes deletes all routes not in exclude
 func (c *RtNetlinkConfig) DeleteRoutes(ifName string, family uint8, exclude ...Route) error {
-	routes := make([]rtnetlink.RouteMessage, 0)
+	routes, err := c.listRoutes(ifName, family)
 
-	if len(exclude) != 0 {
+	if err != nil {
-		lRoutes, err := c.listRoutes(ifName, family, exclude[0].Gateway)
+		return err
-
-		if err != nil {
-			return err
-		}
-
-		routes = lRoutes
 	}
 
 	ifRoutes := make([]Route, 0)
 
 	for _, rtRoute := range routes {
-		logging.Log.WriteInfof("Routes: %s", rtRoute.Attributes.Dst.String())
 		maskSize := 128
 
 		if family == unix.AF_INET {
@@ -262,7 +255,7 @@ func (c *RtNetlinkConfig) DeleteRoutes(ifName string, family uint8, exclude ...R
 	toDelete := Filter(ifRoutes, shouldExclude)
 
 	for _, route := range toDelete {
-		logging.Log.WriteInfof("Deleting route %s", route.Destination.String())
+		logging.Log.WriteInfof("Deleting route: %s", route.Gateway.String())
 		err := c.DeleteRoute(ifName, route)
 
 		if err != nil {
@@ -274,7 +267,7 @@ func (c *RtNetlinkConfig) DeleteRoutes(ifName string, family uint8, exclude ...R
 }
 
 // listRoutes lists all routes on the interface
-func (c *RtNetlinkConfig) listRoutes(ifName string, family uint8, gateway net.IP) ([]rtnetlink.RouteMessage, error) {
+func (c *RtNetlinkConfig) listRoutes(ifName string, family uint8) ([]rtnetlink.RouteMessage, error) {
 	iface, err := net.InterfaceByName(ifName)
 
 	if err != nil {
@@ -288,7 +281,7 @@ func (c *RtNetlinkConfig) listRoutes(ifName string, family uint8, gateway net.IP
 	}
 
 	filterFunc := func(r rtnetlink.RouteMessage) bool {
-		return r.Attributes.Gateway.Equal(gateway) && r.Attributes.OutIface == uint32(iface.Index)
+		return r.Attributes.Gateway != nil && r.Attributes.OutIface == uint32(iface.Index)
 	}
 
 	routes = Filter(routes, filterFunc)

pkg/mesh/config.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/wgmesh/pkg/ip"
 	"github.com/tim-beatham/wgmesh/pkg/lib"
 	"github.com/tim-beatham/wgmesh/pkg/route"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
@@ -26,7 +27,19 @@ type WgMeshConfigApplyer struct {
 	routeInstaller route.RouteInstaller
 }
 
-func (m *WgMeshConfigApplyer) convertMeshNode(node MeshNode, device *wgtypes.Device, peerToClients map[string][]net.IPNet) (*wgtypes.PeerConfig, error) {
+type routeNode struct {
+	gateway string
+	route   Route
+}
+
+func (r *routeNode) equals(route2 *routeNode) bool {
+	return r.gateway == route2.gateway && RouteEquals(r.route, route2.route)
+}
+
+func (m *WgMeshConfigApplyer) convertMeshNode(node MeshNode, device *wgtypes.Device,
+	peerToClients map[string][]net.IPNet,
+	routes map[string][]routeNode) (*wgtypes.PeerConfig, error) {
+
 	endpoint, err := net.ResolveUDPAddr("udp", node.GetWgEndpoint())
 
 	if err != nil {
@@ -42,17 +55,36 @@ func (m *WgMeshConfigApplyer) convertMeshNode(node MeshNode, device *wgtypes.Dev
 	allowedips := make([]net.IPNet, 1)
 	allowedips[0] = *node.GetWgHost()
 
-	for _, route := range node.GetRoutes() {
-		_, ipnet, _ := net.ParseCIDR(route)
-		allowedips = append(allowedips, *ipnet)
-	}
-
 	clients, ok := peerToClients[node.GetWgHost().String()]
 
 	if ok {
 		allowedips = append(allowedips, clients...)
 	}
 
+	for _, route := range node.GetRoutes() {
+		bestRoutes := routes[route.GetDestination().String()]
+
+		if len(bestRoutes) == 1 {
+			allowedips = append(allowedips, *route.GetDestination())
+		} else if len(bestRoutes) > 1 {
+			keyFunc := func(mn MeshNode) int {
+				pubKey, _ := mn.GetPublicKey()
+				return lib.HashString(pubKey.String())
+			}
+
+			bucketFunc := func(rn routeNode) int {
+				return lib.HashString(rn.gateway)
+			}
+
+			// Else there is more than one candidate so consistently hash
+			pickedRoute := lib.ConsistentHash(bestRoutes, node, bucketFunc, keyFunc)
+
+			if pickedRoute.gateway == pubKey.String() {
+				allowedips = append(allowedips, *route.GetDestination())
+			}
+		}
+	}
+
 	keepAlive := time.Duration(m.config.KeepAliveWg) * time.Second
 
 	existing := slices.IndexFunc(device.Peers, func(p wgtypes.Peer) bool {
@@ -74,6 +106,58 @@ func (m *WgMeshConfigApplyer) convertMeshNode(node MeshNode, device *wgtypes.Dev
 	return &peerConfig, nil
 }
 
+// getRoutes: finds the routes with the least hop distance. If more than one route exists
+// consistently hash to evenly spread the distribution of traffic
+func (m *WgMeshConfigApplyer) getRoutes(meshProvider MeshProvider) map[string][]routeNode {
+	mesh, _ := meshProvider.GetMesh()
+
+	routes := make(map[string][]routeNode)
+
+	meshPrefixes := lib.Map(lib.MapValues(m.meshManager.GetMeshes()), func(mesh MeshProvider) *net.IPNet {
+		ula := &ip.ULABuilder{}
+		ipNet, _ := ula.GetIPNet(mesh.GetMeshId())
+
+		return ipNet
+	})
+
+	for _, node := range mesh.GetNodes() {
+		pubKey, _ := node.GetPublicKey()
+		meshRoutes, _ := meshProvider.GetRoutes(pubKey.String())
+
+		for _, route := range meshRoutes {
+			if lib.Contains(meshPrefixes, func(prefix *net.IPNet) bool {
+				if prefix == nil || route == nil || route.GetDestination() == nil {
+					return false
+				}
+
+				return prefix.Contains(route.GetDestination().IP)
+			}) {
+				continue
+			}
+
+			destination := route.GetDestination().String()
+			otherRoute, ok := routes[destination]
+
+			rn := routeNode{
+				gateway: pubKey.String(),
+				route:   route,
+			}
+
+			if !ok {
+				otherRoute = make([]routeNode, 1)
+				otherRoute[0] = rn
+				routes[destination] = otherRoute
+			} else if route.GetHopCount() < otherRoute[0].route.GetHopCount() {
+				otherRoute[0] = rn
+			} else if otherRoute[0].route.GetHopCount() == route.GetHopCount() {
+				routes[destination] = append(otherRoute, rn)
+			}
+		}
+	}
+
+	return routes
+}
+
 func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 	snap, err := mesh.GetMesh()
 
@@ -96,13 +180,9 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 		return err
 	}
 
-	rtnl, err := lib.NewRtNetlinkConfig()
-
-	if err != nil {
-		return err
-	}
-
 	peerToClients := make(map[string][]net.IPNet)
+	routes := m.getRoutes(mesh)
+	installedRoutes := make([]lib.Route, 0)
 
 	for _, n := range nodes {
 		if NodeEquals(n, self) {
@@ -110,24 +190,10 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 		}
 
 		if n.GetType() == conf.CLIENT_ROLE && len(peers) > 0 && self.GetType() == conf.CLIENT_ROLE {
-			peer := lib.ConsistentHash(peers, n, func(mn MeshNode) int {
+			hashFunc := func(mn MeshNode) int {
 				return lib.HashString(mn.GetWgHost().String())
-			})
-
-			dev, err := mesh.GetDevice()
-
-			if err != nil {
-				return err
-			}
-
-			rtnl.AddRoute(dev.Name, lib.Route{
-				Gateway:     peer.GetWgHost().IP,
-				Destination: *n.GetWgHost(),
-			})
-
-			if err != nil {
-				return err
 			}
+			peer := lib.ConsistentHash(peers, n, hashFunc, hashFunc)
 
 			clients, ok := peerToClients[peer.GetWgHost().String()]
 
@@ -141,13 +207,25 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 		}
 
 		dev, _ := mesh.GetDevice()
-
+		peer, err := m.convertMeshNode(n, dev, peerToClients, routes)
-		peer, err := m.convertMeshNode(n, dev, peerToClients)
 
 		if err != nil {
 			return err
 		}
 
+		for _, route := range peer.AllowedIPs {
+			ula := &ip.ULABuilder{}
+			ipNet, _ := ula.GetIPNet(mesh.GetMeshId())
+
+			if !ipNet.Contains(route.IP) {
+
+				installedRoutes = append(installedRoutes, lib.Route{
+					Gateway:     n.GetWgHost().IP,
+					Destination: route,
+				})
+			}
+		}
+
 		peerConfigs[count] = *peer
 		count++
 	}
@@ -162,6 +240,12 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 		return err
 	}
 
+	err = m.routeInstaller.InstallRoutes(dev.Name, installedRoutes...)
+
+	if err != nil {
+		return err
+	}
+
 	return m.meshManager.GetClient().ConfigureDevice(dev.Name, cfg)
 }
 

pkg/mesh/graph.go

@@ -61,7 +61,7 @@ func (c *MeshDOTConverter) graphNode(g *graph.Graph, node MeshNode, meshId strin
 
 	self, _ := c.manager.GetSelf(meshId)
 
-	if node.GetHostEndpoint() == self.GetHostEndpoint() {
+	if NodeEquals(self, node) {
 		return
 	}
 

pkg/mesh/manager.go

@@ -18,7 +18,6 @@ type MeshManager interface {
 	AddMesh(params *AddMeshParams) error
 	HasChanges(meshid string) bool
 	GetMesh(meshId string) MeshProvider
-	EnableInterface(meshId string) error
 	GetPublicKey(meshId string) (*wgtypes.Key, error)
 	AddSelf(params *AddSelfParams) error
 	LeaveMesh(meshId string) error
@@ -35,6 +34,7 @@ type MeshManager interface {
 	Close() error
 	GetMonitor() MeshMonitor
 	GetNode(string, string) MeshNode
+	GetRouteManager() RouteManager
 }
 
 type MeshManagerImpl struct {
@@ -54,6 +54,11 @@ type MeshManagerImpl struct {
 	Monitor              MeshMonitor
 }
 
+// GetRouteManager implements MeshManager.
+func (m *MeshManagerImpl) GetRouteManager() RouteManager {
+	return m.RouteManager
+}
+
 // RemoveService implements MeshManager.
 func (m *MeshManagerImpl) RemoveService(service string) error {
 	for _, mesh := range m.Meshes {
@@ -200,23 +205,6 @@ func (m *MeshManagerImpl) GetMesh(meshId string) MeshProvider {
 	return theMesh
 }
 
-// EnableInterface: Enables the given WireGuard interface.
-func (s *MeshManagerImpl) EnableInterface(meshId string) error {
-	err := s.configApplyer.ApplyConfig()
-
-	if err != nil {
-		return err
-	}
-
-	err = s.RouteManager.InstallRoutes()
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // GetPublicKey: Gets the public key of the WireGuard mesh
 func (s *MeshManagerImpl) GetPublicKey(meshId string) (*wgtypes.Key, error) {
 	if s.conf.StubWg {
@@ -266,20 +254,16 @@ func (s *MeshManagerImpl) AddSelf(params *AddSelfParams) error {
 		params.WgPort = device.ListenPort
 	}
 
-	pubKey, err := s.GetPublicKey(params.MeshId)
+	pubKey := s.HostParameters.PrivateKey.PublicKey()
 
-	if err != nil {
+	nodeIP, err := s.ipAllocator.GetIP(pubKey, params.MeshId)
-		return err
-	}
-
-	nodeIP, err := s.ipAllocator.GetIP(*pubKey, params.MeshId)
 
 	if err != nil {
 		return err
 	}
 
 	node := s.nodeFactory.Build(&MeshNodeFactoryParams{
-		PublicKey: pubKey,
+		PublicKey: &pubKey,
 		NodeIP:    nodeIP,
 		WgPort:    params.WgPort,
 		Endpoint:  params.Endpoint,
@@ -311,22 +295,23 @@ func (s *MeshManagerImpl) LeaveMesh(meshId string) error {
 		return fmt.Errorf("mesh %s does not exist", meshId)
 	}
 
-	err := s.RouteManager.RemoveRoutes(meshId)
+	var err error
-
-	if err != nil {
-		return err
-	}
 
 	if !s.conf.StubWg {
-		device, e := mesh.GetDevice()
+		device, err := mesh.GetDevice()
 
-		if e != nil {
+		if err != nil {
 			return err
 		}
 
 		err = s.interfaceManipulator.RemoveInterface(device.Name)
+
+		if err != nil {
+			return err
+		}
 	}
 
+	err = s.RouteManager.RemoveRoutes(meshId)
 	delete(s.Meshes, meshId)
 	return err
 }

pkg/mesh/manager_test.go

@@ -64,7 +64,6 @@ func TestAddMeshAddsAMesh(t *testing.T) {
 
 	manager.AddMesh(&AddMeshParams{
 		MeshId:    meshId,
-		DevName:   "wg0",
 		WgPort:    6000,
 		MeshBytes: make([]byte, 0),
 	})
@@ -83,7 +82,6 @@ func TestAddMeshMeshAlreadyExistsReplacesIt(t *testing.T) {
 	for i := 0; i < 2; i++ {
 		err := manager.AddMesh(&AddMeshParams{
 			MeshId:    meshId,
-			DevName:   "wg0",
 			WgPort:    6000,
 			MeshBytes: make([]byte, 0),
 		})
@@ -106,7 +104,6 @@ func TestAddSelfAddsSelfToTheMesh(t *testing.T) {
 
 	err := manager.AddMesh(&AddMeshParams{
 		MeshId:    meshId,
-		DevName:   "wg0",
 		WgPort:    6000,
 		MeshBytes: make([]byte, 0),
 	})
@@ -175,7 +172,6 @@ func TestLeaveMeshDeletesMesh(t *testing.T) {
 
 	err := manager.AddMesh(&AddMeshParams{
 		MeshId:    meshId,
-		DevName:   "wg0",
 		WgPort:    6000,
 		MeshBytes: make([]byte, 0),
 	})

pkg/mesh/route.go

@@ -1,25 +1,18 @@
 package mesh
 
 import (
-	"fmt"
-	"net"
-
 	"github.com/tim-beatham/wgmesh/pkg/ip"
 	"github.com/tim-beatham/wgmesh/pkg/lib"
 	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/route"
-	"golang.org/x/sys/unix"
 )
 
 type RouteManager interface {
 	UpdateRoutes() error
-	InstallRoutes() error
 	RemoveRoutes(meshId string) error
 }
 
 type RouteManagerImpl struct {
-	meshManager    MeshManager
+	meshManager MeshManager
-	routeInstaller route.RouteInstaller
 }
 
 func (r *RouteManagerImpl) UpdateRoutes() error {
@@ -27,6 +20,24 @@ func (r *RouteManagerImpl) UpdateRoutes() error {
 	ulaBuilder := new(ip.ULABuilder)
 
 	for _, mesh1 := range meshes {
+		self, err := r.meshManager.GetSelf(mesh1.GetMeshId())
+
+		if err != nil {
+			return err
+		}
+
+		pubKey, err := self.GetPublicKey()
+
+		if err != nil {
+			return err
+		}
+
+		routes, err := mesh1.GetRoutes(pubKey.String())
+
+		if err != nil {
+			return err
+		}
+
 		for _, mesh2 := range meshes {
 			if mesh1 == mesh2 {
 				continue
@@ -39,13 +50,11 @@ func (r *RouteManagerImpl) UpdateRoutes() error {
 				return err
 			}
 
-			self, err := r.meshManager.GetSelf(mesh1.GetMeshId())
+			err = mesh2.AddRoutes(NodeID(self), append(lib.MapValues(routes), &RouteStub{
-
+				Destination: ipNet,
-			if err != nil {
+				HopCount:    0,
-				return err
+				Path:        make([]string, 0),
-			}
+			})...)
-
-			err = mesh1.AddRoutes(self.GetHostEndpoint(), ipNet.String())
 
 			if err != nil {
 				return err
@@ -74,111 +83,11 @@ func (r *RouteManagerImpl) RemoveRoutes(meshId string) error {
 			return err
 		}
 
-		mesh1.RemoveRoutes(self.GetHostEndpoint(), ipNet.String())
+		mesh1.RemoveRoutes(NodeID(self), ipNet.String())
 	}
 	return nil
 }
 
-// AddRoute adds a route to the given interface
-func (m *RouteManagerImpl) addRoute(ifName string, meshPrefix string, routes ...lib.Route) error {
-	rtnl, err := lib.NewRtNetlinkConfig()
-
-	if err != nil {
-		return fmt.Errorf("failed to create config: %w", err)
-	}
-	defer rtnl.Close()
-
-	// Delete any routes that may be vacant
-	err = rtnl.DeleteRoutes(ifName, unix.AF_INET6, routes...)
-
-	if err != nil {
-		return err
-	}
-
-	for _, route := range routes {
-		if route.Destination.String() == meshPrefix {
-			continue
-		}
-
-		err = rtnl.AddRoute(ifName, route)
-
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (m *RouteManagerImpl) installRoute(ifName string, meshid string, node MeshNode) error {
-	routeMapFunc := func(route string) lib.Route {
-		_, cidr, _ := net.ParseCIDR(route)
-
-		r := lib.Route{
-			Destination: *cidr,
-			Gateway:     node.GetWgHost().IP,
-		}
-		return r
-	}
-
-	ipBuilder := &ip.ULABuilder{}
-	ipNet, err := ipBuilder.GetIPNet(meshid)
-
-	if err != nil {
-		return err
-	}
-
-	routes := lib.Map(append(node.GetRoutes(), ipNet.String()), routeMapFunc)
-	return m.addRoute(ifName, ipNet.String(), routes...)
-}
-
-func (m *RouteManagerImpl) installRoutes(meshProvider MeshProvider) error {
-	mesh, err := meshProvider.GetMesh()
-
-	if err != nil {
-		return err
-	}
-
-	dev, err := meshProvider.GetDevice()
-
-	if err != nil {
-		return err
-	}
-
-	self, err := m.meshManager.GetSelf(meshProvider.GetMeshId())
-
-	if err != nil {
-		return err
-	}
-
-	for _, node := range mesh.GetNodes() {
-		if self.GetHostEndpoint() == node.GetHostEndpoint() {
-			continue
-		}
-
-		err = m.installRoute(dev.Name, meshProvider.GetMeshId(), node)
-
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// InstallRoutes installs all routes to the RIB
-func (r *RouteManagerImpl) InstallRoutes() error {
-	for _, mesh := range r.meshManager.GetMeshes() {
-		err := r.installRoutes(mesh)
-
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 func NewRouteManager(m MeshManager) RouteManager {
-	return &RouteManagerImpl{meshManager: m, routeInstaller: route.NewRouteInstaller()}
+	return &RouteManagerImpl{meshManager: m}
 }

pkg/mesh/stub_types.go

@@ -16,14 +16,14 @@ type MeshNodeStub struct {
 	wgEndpoint   string
 	wgHost       *net.IPNet
 	timeStamp    int64
-	routes       []string
+	routes       []Route
 	identifier   string
 	description  string
 }
 
 // GetType implements MeshNode.
 func (*MeshNodeStub) GetType() conf.NodeType {
-	return PEER
+	return conf.PEER_ROLE
 }
 
 // GetServices implements MeshNode.
@@ -56,7 +56,7 @@ func (m *MeshNodeStub) GetTimeStamp() int64 {
 	return m.timeStamp
 }
 
-func (m *MeshNodeStub) GetRoutes() []string {
+func (m *MeshNodeStub) GetRoutes() []Route {
 	return m.routes
 }
 
@@ -81,6 +81,10 @@ type MeshProviderStub struct {
 	snapshot *MeshSnapshotStub
 }
 
+func (*MeshProviderStub) GetRoutes(targetId string) (map[string]Route, error) {
+	return nil, nil
+}
+
 // GetNodeIds implements MeshProvider.
 func (*MeshProviderStub) GetPeers() []string {
 	return make([]string, 0)
@@ -159,7 +163,7 @@ func (s *MeshProviderStub) HasChanges() bool {
 	return false
 }
 
-func (s *MeshProviderStub) AddRoutes(nodeId string, route ...string) error {
+func (s *MeshProviderStub) AddRoutes(nodeId string, route ...Route) error {
 	return nil
 }
 
@@ -193,7 +197,7 @@ func (s *StubNodeFactory) Build(params *MeshNodeFactoryParams) MeshNode {
 		wgEndpoint:   fmt.Sprintf("%s:%s", params.Endpoint, s.Config.GrpcPort),
 		wgHost:       wgHost,
 		timeStamp:    time.Now().Unix(),
-		routes:       make([]string, 0),
+		routes:       make([]Route, 0),
 		identifier:   "abc",
 		description:  "A Mesh Node Stub",
 	}
@@ -216,6 +220,11 @@ type MeshManagerStub struct {
 	meshes map[string]MeshProvider
 }
 
+// GetRouteManager implements MeshManager.
+func (*MeshManagerStub) GetRouteManager() RouteManager {
+	panic("unimplemented")
+}
+
 // GetNode implements MeshManager.
 func (*MeshManagerStub) GetNode(string, string) MeshNode {
 	panic("unimplemented")
@@ -278,10 +287,6 @@ func (m *MeshManagerStub) GetMesh(meshId string) MeshProvider {
 		snapshot: &MeshSnapshotStub{nodes: make(map[string]MeshNode)}}
 }
 
-func (m *MeshManagerStub) EnableInterface(meshId string) error {
-	return nil
-}
-
 func (m *MeshManagerStub) GetPublicKey(meshId string) (*wgtypes.Key, error) {
 	key, _ := wgtypes.GenerateKey()
 	return &key, nil

pkg/mesh/types.go

@@ -10,12 +10,32 @@ import (
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
-const (
+type Route interface {
-	// Data Exchanged Between Peers
+	// GetDestination: returns the destination of the route
-	PEER conf.NodeType = "peer"
+	GetDestination() *net.IPNet
-	// Data Exchanged Between Clients
+	// GetHopCount: get the total hopcount of the prefix
-	CLIENT conf.NodeType = "client"
+	GetHopCount() int
-)
+	// GetPath: get a list of AS paths to get to the destination
+	GetPath() []string
+}
+
+type RouteStub struct {
+	Destination *net.IPNet
+	HopCount    int
+	Path        []string
+}
+
+func (r *RouteStub) GetDestination() *net.IPNet {
+	return r.Destination
+}
+
+func (r *RouteStub) GetHopCount() int {
+	return r.HopCount
+}
+
+func (r *RouteStub) GetPath() []string {
+	return r.Path
+}
 
 // MeshNode represents an implementation of a node in a mesh
 type MeshNode interface {
@@ -30,7 +50,7 @@ type MeshNode interface {
 	// GetTimestamp: get the UNIX time stamp of the ndoe
 	GetTimeStamp() int64
 	// GetRoutes: returns the routes that the nodes provides
-	GetRoutes() []string
+	GetRoutes() []Route
 	// GetIdentifier: returns the identifier of the node
 	GetIdentifier() string
 	// GetDescription: returns the description for this node
@@ -45,7 +65,20 @@ type MeshNode interface {
 
 // NodeEquals: determines if two mesh nodes are equivalent to one another
 func NodeEquals(node1, node2 MeshNode) bool {
-	return node1.GetHostEndpoint() == node2.GetHostEndpoint()
+	key1, _ := node1.GetPublicKey()
+	key2, _ := node2.GetPublicKey()
+
+	return key1.String() == key2.String()
+}
+
+func RouteEquals(route1, route2 Route) bool {
+	return route1.GetDestination().String() == route2.GetDestination().String() &&
+		route1.GetHopCount() == route2.GetHopCount()
+}
+
+func NodeID(node MeshNode) string {
+	key, _ := node.GetPublicKey()
+	return key.String()
 }
 
 type MeshSnapshot interface {
@@ -81,7 +114,7 @@ type MeshProvider interface {
 	// UpdateTimeStamp: update the timestamp of the given node
 	UpdateTimeStamp(nodeId string) error
 	// AddRoutes: adds routes to the given node
-	AddRoutes(nodeId string, route ...string) error
+	AddRoutes(nodeId string, route ...Route) error
 	// DeleteRoutes: deletes the routes from the node
 	RemoveRoutes(nodeId string, route ...string) error
 	// GetSyncer: returns the automerge syncer for sync
@@ -101,7 +134,10 @@ type MeshProvider interface {
 	// Prune: prunes all nodes that have not updated their timestamp in
 	// pruneAmount seconds
 	Prune(pruneAmount int) error
+	// GetPeers: get a list of contactable peers
 	GetPeers() []string
+	// GetRoutes(): Get all unique routes. Where the route with the least hop count is chosen
+	GetRoutes(targetNode string) (map[string]Route, error)
 }
 
 // HostParameters contains the IDs of a node

pkg/query/query.go

@@ -3,6 +3,7 @@ package query
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/jmespath/go-jmespath"
 	"github.com/tim-beatham/wgmesh/pkg/conf"
@@ -24,6 +25,12 @@ type QueryError struct {
 	msg string
 }
 
+type QueryRoute struct {
+	Destination string `json:"destination"`
+	HopCount    int    `json:"hopCount"`
+	Path        string `json:"path"`
+}
+
 type QueryNode struct {
 	HostEndpoint string            `json:"hostEndpoint"`
 	PublicKey    string            `json:"publicKey"`
@@ -31,7 +38,7 @@ type QueryNode struct {
 	WgHost       string            `json:"wgHost"`
 	Timestamp    int64             `json:"timestamp"`
 	Description  string            `json:"description"`
-	Routes       []string          `json:"routes"`
+	Routes       []QueryRoute      `json:"routes"`
 	Alias        string            `json:"alias"`
 	Services     map[string]string `json:"services"`
 	Type         conf.NodeType     `json:"type"`
@@ -78,7 +85,13 @@ func MeshNodeToQueryNode(node mesh.MeshNode) *QueryNode {
 	queryNode.WgHost = node.GetWgHost().String()
 
 	queryNode.Timestamp = node.GetTimeStamp()
-	queryNode.Routes = node.GetRoutes()
+	queryNode.Routes = lib.Map(node.GetRoutes(), func(r mesh.Route) QueryRoute {
+		return QueryRoute{
+			Destination: r.GetDestination().String(),
+			HopCount:    r.GetHopCount(),
+			Path:        strings.Join(r.GetPath(), ","),
+		}
+	})
 	queryNode.Description = node.GetDescription()
 	queryNode.Alias = node.GetAlias()
 	queryNode.Services = node.GetServices()

pkg/robin/requester.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
 	"github.com/tim-beatham/wgmesh/pkg/ipc"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
 	"github.com/tim-beatham/wgmesh/pkg/mesh"
 	"github.com/tim-beatham/wgmesh/pkg/query"
 	"github.com/tim-beatham/wgmesh/pkg/rpc"
@@ -119,19 +120,19 @@ func (n *IpcHandler) LeaveMesh(meshId string, reply *string) error {
 }
 
 func (n *IpcHandler) GetMesh(meshId string, reply *ipc.GetMeshReply) error {
-	mesh := n.Server.GetMeshManager().GetMesh(meshId)
+	theMesh := n.Server.GetMeshManager().GetMesh(meshId)
 
-	if mesh == nil {
+	if theMesh == nil {
 		return fmt.Errorf("mesh %s does not exist", meshId)
 	}
 
-	meshSnapshot, err := mesh.GetMesh()
+	meshSnapshot, err := theMesh.GetMesh()
 
 	if err != nil {
 		return err
 	}
 
-	if mesh == nil {
+	if theMesh == nil {
 		return errors.New("mesh does not exist")
 	}
 
@@ -151,10 +152,15 @@ func (n *IpcHandler) GetMesh(meshId string, reply *ipc.GetMeshReply) error {
 			PublicKey:    pubKey.String(),
 			WgHost:       node.GetWgHost().String(),
 			Timestamp:    node.GetTimeStamp(),
-			Routes:       node.GetRoutes(),
+			Routes: lib.Map(node.GetRoutes(), func(r mesh.Route) ctrlserver.MeshRoute {
-			Description:  node.GetDescription(),
+				return ctrlserver.MeshRoute{
-			Alias:        node.GetAlias(),
+					Destination: r.GetDestination().String(),
-			Services:     node.GetServices(),
+					Path:        r.GetPath(),
+				}
+			}),
+			Description: node.GetDescription(),
+			Alias:       node.GetAlias(),
+			Services:    node.GetServices(),
 		}
 
 		nodes[i] = node
@@ -165,18 +171,6 @@ func (n *IpcHandler) GetMesh(meshId string, reply *ipc.GetMeshReply) error {
 	return nil
 }
 
-func (n *IpcHandler) EnableInterface(meshId string, reply *string) error {
-	err := n.Server.GetMeshManager().EnableInterface(meshId)
-
-	if err != nil {
-		*reply = err.Error()
-		return err
-	}
-
-	*reply = "up"
-	return nil
-}
-
 func (n *IpcHandler) GetDOT(meshId string, reply *string) error {
 	g := mesh.NewMeshDotConverter(n.Server.GetMeshManager())
 

pkg/route/route.go

@@ -1,22 +1,32 @@
 package route
 
 import (
-	"net"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"os/exec"
+	"golang.org/x/sys/unix"
-
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
 )
 
 type RouteInstaller interface {
-	InstallRoutes(devName string, routes ...*net.IPNet) error
+	InstallRoutes(devName string, routes ...lib.Route) error
 }
 
 type RouteInstallerImpl struct{}
 
 // InstallRoutes: installs a route into the routing table
-func (r *RouteInstallerImpl) InstallRoutes(devName string, routes ...*net.IPNet) error {
+func (r *RouteInstallerImpl) InstallRoutes(devName string, routes ...lib.Route) error {
+	rtnl, err := lib.NewRtNetlinkConfig()
+
+	if err != nil {
+		return err
+	}
+
+	err = rtnl.DeleteRoutes(devName, unix.AF_INET6, routes...)
+
+	if err != nil {
+		return err
+	}
+
 	for _, route := range routes {
-		err := r.installRoute(devName, route)
+		err := rtnl.AddRoute(devName, route)
 
 		if err != nil {
 			return err
@@ -26,22 +36,6 @@ func (r *RouteInstallerImpl) InstallRoutes(devName string, routes ...*net.IPNet)
 	return nil
 }
 
-// installRoute: installs a route into the linux table
-func (r *RouteInstallerImpl) installRoute(devName string, route *net.IPNet) error {
-	// TODO: Find a library that automates this
-	cmd := exec.Command("/usr/bin/ip", "-6", "route", "add", route.String(), "dev", devName)
-
-	logging.Log.WriteInfof("%s %s", route.String(), devName)
-
-	if msg, err := cmd.CombinedOutput(); err != nil {
-		logging.Log.WriteErrorf(err.Error())
-		logging.Log.WriteErrorf(string(msg))
-		return err
-	}
-
-	return nil
-}
-
 func NewRouteInstaller() RouteInstaller {
 	return &RouteInstallerImpl{}
 }

pkg/timers/timers.go

@@ -1,4 +1,4 @@
-package timestamp
+package timer
 
 import (
 	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
@@ -12,3 +12,11 @@ func NewTimestampScheduler(ctrlServer *ctrlserver.MeshCtrlServer) lib.Timer {
 
 	return *lib.NewTimer(timerFunc, ctrlServer.Conf.KeepAliveTime)
 }
+
+func NewRouteScheduler(ctrlServer *ctrlserver.MeshCtrlServer) lib.Timer {
+	timerFunc := func() error {
+		return ctrlServer.MeshManager.GetRouteManager().UpdateRoutes()
+	}
+
+	return *lib.NewTimer(timerFunc, 10)
+}