Removed interface manipulation via os.Exec into

rtnetlink calls
Merge pull request #12 from tim-beatham/11-health-system
2025-07-04 14:30:38 +02:00 · 2023-11-07 19:48:53 +00:00 · 2023-11-06 13:40:04 +00:00 · 2023-11-06 13:37:28 +00:00 · 2023-11-06 10:05:23 +00:00 · 2023-11-06 09:54:06 +00:00
56 changed files with 3296 additions and 415 deletions
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@ -0,0 +1,31 @@
+# This workflow will build a golang project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
+
+name: Go
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.21'
+
+    - name: Tidy
+      run: go mod tidy
+      
+    - name: Build
+      run: go build -v ./...
+
+    - name: Test
+      run: go test -v ./...
--- a/cmd/wg-mesh/main.go
+++ b/cmd/wg-mesh/main.go
@ -157,6 +157,20 @@ func queryMesh(client *ipcRpc.Client, meshId, query string) {
 	fmt.Println(reply)
 }

+// putDescription: puts updates the description about the node to the meshes
+func putDescription(client *ipcRpc.Client, description string) {
+	var reply string
+
+	err := client.Call("IpcHandler.PutDescription", &description, &reply)
+
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+
+	fmt.Println(reply)
+}
+
 func main() {
 	parser := argparse.NewParser("wg-mesh",
 		"wg-mesh Manipulate WireGuard meshes")
@ -164,11 +178,12 @@ func main() {
 	newMeshCmd := parser.NewCommand("new-mesh", "Create a new mesh")
 	listMeshCmd := parser.NewCommand("list-meshes", "List meshes the node is connected to")
 	joinMeshCmd := parser.NewCommand("join-mesh", "Join a mesh network")
-	getMeshCmd := parser.NewCommand("get-mesh", "Get a mesh network")
+	// getMeshCmd := parser.NewCommand("get-mesh", "Get a mesh network")
 	enableInterfaceCmd := parser.NewCommand("enable-interface", "Enable A Specific Mesh Interface")
 	getGraphCmd := parser.NewCommand("get-graph", "Convert a mesh into DOT format")
 	leaveMeshCmd := parser.NewCommand("leave-mesh", "Leave a mesh network")
 	queryMeshCmd := parser.NewCommand("query-mesh", "Query a mesh network using JMESPath")
+	putDescriptionCmd := parser.NewCommand("put-description", "Place a description for the node")

 	var newMeshIfName *string = newMeshCmd.String("f", "ifname", &argparse.Options{Required: true})
 	var newMeshPort *int = newMeshCmd.Int("p", "wgport", &argparse.Options{Required: true})
@ -180,8 +195,10 @@ func main() {
 	var joinMeshPort *int = joinMeshCmd.Int("p", "wgport", &argparse.Options{Required: true})
 	var joinMeshEndpoint *string = joinMeshCmd.String("e", "endpoint", &argparse.Options{})

-	var getMeshId *string = getMeshCmd.String("m", "mesh", &argparse.Options{Required: true})
+	// var getMeshId *string = getMeshCmd.String("m", "mesh", &argparse.Options{Required: true})
+
 	var enableInterfaceMeshId *string = enableInterfaceCmd.String("m", "mesh", &argparse.Options{Required: true})
+
 	var getGraphMeshId *string = getGraphCmd.String("m", "mesh", &argparse.Options{Required: true})

 	var leaveMeshMeshId *string = leaveMeshCmd.String("m", "mesh", &argparse.Options{Required: true})
@ -189,6 +206,8 @@ func main() {
 	var queryMeshMeshId *string = queryMeshCmd.String("m", "mesh", &argparse.Options{Required: true})
 	var queryMeshQuery *string = queryMeshCmd.String("q", "query", &argparse.Options{Required: true})

+	var description *string = putDescriptionCmd.String("d", "description", &argparse.Options{Required: true})
+
 	err := parser.Parse(os.Args)

 	if err != nil {
@ -226,9 +245,9 @@ func main() {
 		}))
 	}

-	if getMeshCmd.Happened() {
-		getMesh(client, *getMeshId)
-	}
+	// if getMeshCmd.Happened() {
+	// getMesh(client, *getMeshId)
+	// }

 	if getGraphCmd.Happened() {
 		getGraph(client, *getGraphMeshId)
@ -245,4 +264,8 @@ func main() {
 	if queryMeshCmd.Happened() {
 		queryMesh(client, *queryMeshMeshId, *queryMeshQuery)
 	}
+
+	if putDescriptionCmd.Happened() {
+		putDescription(client, *description)
+	}
 }
--- a/cmd/wgmeshd/configuration.yaml
+++ b/cmd/wgmeshd/configuration.yaml
@ -2,5 +2,13 @@ certificatePath: "/wgmesh/cert/cert.pem"
 privateKeyPath: "/wgmesh/cert/priv.pem"
 caCertificatePath: "/wgmesh/cert/cacert.pem"
 skipCertVerification: true
-gRPCPort: "8080"
-advertiseRoutes: true
+timeout: 5
+gRPCPort: "21906"
+advertiseRoutes: true
+clusterSize: 32
+syncRate: 1
+interClusterChance: 0.15
+branchRate: 3
+infectionCount: 3
+keepAliveTime: 10
+pruneTime: 20
--- a/cmd/wgmeshd/main.go
+++ b/cmd/wgmeshd/main.go
@ -3,12 +3,13 @@ package main
 import (
 	"log"
 	"os"
+	"os/signal"

 	"github.com/tim-beatham/wgmesh/pkg/conf"
 	ctrlserver "github.com/tim-beatham/wgmesh/pkg/ctrlserver"
 	"github.com/tim-beatham/wgmesh/pkg/ipc"
 	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/middleware"
+	"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"
@ -36,22 +37,21 @@ func main() {

 	var robinRpc robin.WgRpc
 	var robinIpc robin.IpcHandler
-	var authProvider middleware.AuthRpcProvider
 	var syncProvider sync.SyncServiceImpl

 	ctrlServerParams := ctrlserver.NewCtrlServerParams{
 		Conf:         conf,
-		AuthProvider: &authProvider,
 		CtrlProvider: &robinRpc,
 		SyncProvider: &syncProvider,
 		Client:       client,
 	}
-
 	ctrlServer, err := ctrlserver.NewCtrlServer(&ctrlServerParams)
+
 	syncProvider.Server = ctrlServer
 	syncRequester := sync.NewSyncRequester(ctrlServer)
-	syncScheduler := sync.NewSyncScheduler(ctrlServer, syncRequester, 2)
-	timestampScheduler := timestamp.NewTimestampScheduler(ctrlServer, 60)
+	syncScheduler := sync.NewSyncScheduler(ctrlServer, syncRequester)
+	timestampScheduler := timestamp.NewTimestampScheduler(ctrlServer)
+	pruneScheduler := mesh.NewPruner(ctrlServer.MeshManager, *conf)

 	robinIpcParams := robin.RobinIpcParams{
 		CtrlServer: ctrlServer,
@ -70,17 +70,32 @@ func main() {
 	go ipc.RunIpcHandler(&robinIpc)
 	go syncScheduler.Run()
 	go timestampScheduler.Run()
+	go pruneScheduler.Run()
+
+	closeResources := func() {
+		logging.Log.WriteInfof("Closing resources")
+		syncScheduler.Stop()
+		timestampScheduler.Stop()
+		ctrlServer.Close()
+		client.Close()
+	}
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+
+	go func() {
+		for range c {
+			closeResources()
+			os.Exit(0)
+		}
+	}()

 	err = ctrlServer.ConnectionServer.Listen()

 	if err != nil {
 		logging.Log.WriteErrorf(err.Error())
-
 		return
 	}

-	defer syncScheduler.Stop()
-	defer timestampScheduler.Stop()
-	defer ctrlServer.Close()
-	defer client.Close()
+	go closeResources()
 }
--- a/go.mod
+++ b/go.mod
@ -1,11 +1,12 @@
 module github.com/tim-beatham/wgmesh

-go 1.21.1
+go 1.21.3

 require (
 	github.com/akamensky/argparse v1.4.0
 	github.com/automerge/automerge-go v0.0.0-20230903201930-b80ce8aadbb9
 	github.com/google/uuid v1.3.0
+	github.com/jmespath/go-jmespath v0.4.0
 	github.com/sirupsen/logrus v1.9.3
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6
 	google.golang.org/grpc v1.58.1
@ -16,11 +17,12 @@ require (
 require (
 	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/google/go-cmp v0.5.9 // indirect
-	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/josharian/native v1.1.0 // indirect
+	github.com/jsimonetti/rtnetlink v1.3.5 // indirect
 	github.com/mdlayher/genetlink v1.3.2 // indirect
 	github.com/mdlayher/netlink v1.7.2 // indirect
 	github.com/mdlayher/socket v0.5.0 // indirect
+	github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df // indirect
 	golang.org/x/crypto v0.13.0 // indirect
 	golang.org/x/net v0.15.0 // indirect
 	golang.org/x/sync v0.3.0 // indirect
--- a/go.sum
+++ b/go.sum
@ -1,62 +0,0 @@
-github.com/akamensky/argparse v1.4.0 h1:YGzvsTqCvbEZhL8zZu2AiA5nq805NZh75JNj4ajn1xc=
-github.com/akamensky/argparse v1.4.0/go.mod h1:S5kwC7IuDcEr5VeXtGPRVZ5o/FdhcMlQz4IZQuw64xA=
-github.com/automerge/automerge-go v0.0.0-20230903201930-b80ce8aadbb9 h1:+6JSfuxZgmURoIlGdnYnY/FLRGWGagLyiBjt/VLtwi4=
-github.com/automerge/automerge-go v0.0.0-20230903201930-b80ce8aadbb9/go.mod h1:6UxoDE+thWsISXK93pxaOuOfkcAfCvDbg0eAnFmxL5E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/josharian/native v1.1.0 h1:uuaP0hAbW7Y4l0ZRQ6C9zfb7Mg1mbFKry/xzDAfmtLA=
-github.com/josharian/native v1.1.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w=
-github.com/mdlayher/genetlink v1.3.2 h1:KdrNKe+CTu+IbZnm/GVUMXSqBBLqcGpRDa0xkQy56gw=
-github.com/mdlayher/genetlink v1.3.2/go.mod h1:tcC3pkCrPUGIKKsCsp0B3AdaaKuHtaxoJRz3cc+528o=
-github.com/mdlayher/netlink v1.7.2 h1:/UtM3ofJap7Vl4QWCPDGXY8d3GIY2UGSDbK+QWmY8/g=
-github.com/mdlayher/netlink v1.7.2/go.mod h1:xraEF7uJbxLhc5fpHL4cPe221LI2bdttWlU+ZGLfQSw=
-github.com/mdlayher/socket v0.5.0 h1:ilICZmJcQz70vrWVes1MFera4jGiWNocSkykwwoy3XI=
-github.com/mdlayher/socket v0.5.0/go.mod h1:WkcBFfvyG8QENs5+hfQPl1X6Jpd2yeLIYgrGFmJiJxI=
-github.com/mikioh/ipaddr v0.0.0-20190404000644-d465c8ab6721 h1:RlZweED6sbSArvlE924+mUcZuXKLBHA35U7LN621Bws=
-github.com/mikioh/ipaddr v0.0.0-20190404000644-d465c8ab6721/go.mod h1:Ickgr2WtCLZ2MDGd4Gr0geeCH5HybhRJbonOgQpvSxc=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
-golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
-golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.zx2c4.com/wireguard v0.0.0-20230704135630-469159ecf7d1 h1:EY138uSo1JYlDq+97u1FtcOUwPpIU6WL1Lkt7WpYjPA=
-golang.zx2c4.com/wireguard v0.0.0-20230704135630-469159ecf7d1/go.mod h1:tqur9LnfstdR9ep2LaJT4lFUl0EjlHtge+gAjmsHUG4=
-golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6 h1:CawjfCvYQH2OU3/TnxLx97WDSUDRABfT18pCOYwc2GE=
-golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6/go.mod h1:3rxYc4HtVcSG9gVaTs2GEBdehh+sYPOwKtyUWEOTb80=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 h1:bVf09lpb+OJbByTj913DRJioFFAjf/ZGxEz7MajTp2U=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM=
-google.golang.org/grpc v1.58.1 h1:OL+Vz23DTtrrldqHK49FUOPHyY75rvFqJfXC84NYW58=
-google.golang.org/grpc v1.58.1/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/pkg/automerge/automerge.go
+++ b/pkg/automerge/automerge.go
@ -2,6 +2,7 @@ package crdt

 import (
 	"errors"
+	"fmt"
 	"net"
 	"strings"
 	"time"
@ -33,10 +34,10 @@ func (c *CrdtMeshManager) AddNode(node mesh.MeshNode) {
 		panic("node must be of type *MeshNodeCrdt")
 	}

+	crdt.Routes = make(map[string]interface{})
+
 	crdt.Timestamp = time.Now().Unix()
 	c.doc.Path("nodes").Map().Set(crdt.HostEndpoint, crdt)
-	nodeVal, _ := c.doc.Path("nodes").Map().Get(crdt.HostEndpoint)
-	nodeVal.Map().Set("routes", automerge.NewMap())
 }

 // GetMesh(): Converts the document into a struct
@ -84,16 +85,6 @@ func NewCrdtNodeManager(params *NewCrdtNodeMangerParams) (*CrdtMeshManager, erro
 	return &manager, nil
 }

-func (c *CrdtMeshManager) removeNode(endpoint string) error {
-	err := c.doc.Path("nodes").Map().Delete(endpoint)
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // GetNode: returns a mesh node crdt.Close releases resources used by a Client.
 func (m *CrdtMeshManager) GetNode(endpoint string) (*MeshNodeCrdt, error) {
 	node, err := m.doc.Path("nodes").Map().Get(endpoint)
@ -161,7 +152,27 @@ func (m *CrdtMeshManager) UpdateTimeStamp(nodeId string) error {
 	err = node.Map().Set("timestamp", time.Now().Unix())

 	if err == nil {
-		logging.Log.WriteInfof("Timestamp Updated for %s", m.MeshId)
+		logging.Log.WriteInfof("Timestamp Updated for %s", nodeId)
+	}
+
+	return err
+}
+
+func (m *CrdtMeshManager) SetDescription(nodeId string, description string) error {
+	node, err := m.doc.Path("nodes").Map().Get(nodeId)
+
+	if err != nil {
+		return err
+	}
+
+	if node.Kind() != automerge.KindMap {
+		return fmt.Errorf("%s does not exist", nodeId)
+	}
+
+	err = node.Map().Set("description", description)
+
+	if err == nil {
+		logging.Log.WriteInfof("Description Updated for %s", nodeId)
 	}

 	return err
@ -176,6 +187,10 @@ func (m *CrdtMeshManager) AddRoutes(nodeId string, routes ...string) error {
 		return err
 	}

+	if nodeVal.Kind() != automerge.KindMap {
+		return fmt.Errorf("node does not exist")
+	}
+
 	routeMap, err := nodeVal.Map().Get("routes")

 	if err != nil {
@ -189,14 +204,90 @@ func (m *CrdtMeshManager) AddRoutes(nodeId string, routes ...string) error {
 			return err
 		}
 	}
-
 	return nil
 }

+// DeleteRoutes deletes the specified routes
+func (m *CrdtMeshManager) RemoveRoutes(nodeId string, routes ...string) error {
+	nodeVal, err := m.doc.Path("nodes").Map().Get(nodeId)
+
+	if err != nil {
+		return err
+	}
+
+	if nodeVal.Kind() != automerge.KindMap {
+		return fmt.Errorf("node is not a map")
+	}
+
+	routeMap, err := nodeVal.Map().Get("routes")
+
+	if err != nil {
+		return err
+	}
+
+	for _, route := range routes {
+		err = routeMap.Map().Delete(route)
+	}
+
+	return err
+}
+
 func (m *CrdtMeshManager) GetSyncer() mesh.MeshSyncer {
 	return NewAutomergeSync(m)
 }

+func (m *CrdtMeshManager) Prune(pruneTime int) error {
+	nodes, err := m.doc.Path("nodes").Get()
+
+	if err != nil {
+		return err
+	}
+
+	if nodes.Kind() != automerge.KindMap {
+		return errors.New("node must be a map")
+	}
+
+	values, err := nodes.Map().Values()
+
+	if err != nil {
+		return err
+	}
+
+	deletionNodes := make([]string, 0)
+
+	for nodeId, node := range values {
+		if node.Kind() != automerge.KindMap {
+			return errors.New("node must be a map")
+		}
+
+		nodeMap := node.Map()
+
+		timeStamp, err := nodeMap.Get("timestamp")
+
+		if err != nil {
+			return err
+		}
+
+		if timeStamp.Kind() != automerge.KindInt64 {
+			return errors.New("timestamp is not int64")
+		}
+
+		timeValue := timeStamp.Int64()
+		nowValue := time.Now().Unix()
+
+		if nowValue-timeValue >= int64(pruneTime) {
+			deletionNodes = append(deletionNodes, nodeId)
+		}
+	}
+
+	for _, node := range deletionNodes {
+		logging.Log.WriteInfof("Pruning %s", node)
+		nodes.Map().Delete(node)
+	}
+
+	return nil
+}
+
 func (m1 *MeshNodeCrdt) Compare(m2 *MeshNodeCrdt) int {
 	return strings.Compare(m1.PublicKey, m2.PublicKey)
 }
@ -232,6 +323,10 @@ func (m *MeshNodeCrdt) GetRoutes() []string {
 	return lib.MapKeys(m.Routes)
 }

+func (m *MeshNodeCrdt) GetDescription() string {
+	return m.Description
+}
+
 func (m *MeshNodeCrdt) GetIdentifier() string {
 	ipv6 := m.WgHost[:len(m.WgHost)-4]

@ -252,6 +347,7 @@ func (m *MeshCrdt) GetNodes() map[string]mesh.MeshNode {
 			WgHost:       node.WgHost,
 			Timestamp:    node.Timestamp,
 			Routes:       node.Routes,
+			Description:  node.Description,
 		}
 	}

--- a/pkg/automerge/automerge_test.go
+++ b/pkg/automerge/automerge_test.go
@ -0,0 +1,366 @@
+package crdt
+
+import (
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
+)
+
+type TestParams struct {
+	manager *CrdtMeshManager
+}
+
+func setUpTests() *TestParams {
+	manager, _ := NewCrdtNodeManager(&NewCrdtNodeMangerParams{
+		MeshId:  "timsmesh123",
+		DevName: "wg0",
+		Port:    5000,
+		Client:  nil,
+		Conf:    conf.WgMeshConfiguration{},
+	})
+
+	return &TestParams{
+		manager: manager,
+	}
+}
+
+func getTestNode() mesh.MeshNode {
+	return &MeshNodeCrdt{
+		HostEndpoint: "public-endpoint:8080",
+		WgEndpoint:   "public-endpoint:21906",
+		WgHost:       "3e9a:1fb3:5e50:8173:9690:f917:b1ab:d218/128",
+		PublicKey:    "AAAAAAAAAAAA",
+		Timestamp:    time.Now().Unix(),
+		Description:  "A node that we are adding",
+	}
+}
+
+func getTestNode2() mesh.MeshNode {
+	return &MeshNodeCrdt{
+		HostEndpoint: "public-endpoint:8081",
+		WgEndpoint:   "public-endpoint:21907",
+		WgHost:       "3e9a:1fb3:5e50:8173:9690:f917:b1ab:d219/128",
+		PublicKey:    "BBBBBBBBB",
+		Timestamp:    time.Now().Unix(),
+		Description:  "A node that we are adding",
+	}
+}
+
+func TestAddNodeNodeExists(t *testing.T) {
+	testParams := setUpTests()
+	testParams.manager.AddNode(getTestNode())
+
+	node, err := testParams.manager.GetNode("public-endpoint:8080")
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if node == nil {
+		t.Fatalf(`node not added to the mesh when it should be`)
+	}
+}
+
+func TestAddNodeAddRoute(t *testing.T) {
+	testParams := setUpTests()
+	testNode := getTestNode()
+	testParams.manager.AddNode(testNode)
+	testParams.manager.AddRoutes(testNode.GetHostEndpoint(), "fd:1c64:1d00::/48")
+
+	updatedNode, err := testParams.manager.GetNode(testNode.GetHostEndpoint())
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if updatedNode == nil {
+		t.Fatalf(`Node does not exist in the mesh`)
+	}
+
+	routes := updatedNode.GetRoutes()
+
+	if !slices.Contains(routes, "fd:1c64:1d00::/48") {
+		t.Fatal("Route node not added")
+	}
+
+	if len(routes) != 1 {
+		t.Fatal(`Route length mismatch`)
+	}
+}
+
+func TestGetMeshIdReturnsTheMeshId(t *testing.T) {
+	testParams := setUpTests()
+
+	if len(testParams.manager.GetMeshId()) == 0 {
+		t.Fatal(`Meshid is less than 0`)
+	}
+}
+
+// Add 2 nodes to the mesh and then get the mesh.s
+// It should return the 2 nodes that have been added to the mesh
+func TestAdd2NodesGetMesh(t *testing.T) {
+	testParams := setUpTests()
+	node1 := getTestNode()
+	node2 := getTestNode2()
+
+	testParams.manager.AddNode(node1)
+	testParams.manager.AddNode(node2)
+
+	mesh, err := testParams.manager.GetMesh()
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	nodes := mesh.GetNodes()
+
+	if len(nodes) != 2 {
+		t.Fatalf(`Mismatch in node slice`)
+	}
+
+	for _, node := range nodes {
+		if node.GetHostEndpoint() != node1.GetHostEndpoint() && node.GetHostEndpoint() != node2.GetHostEndpoint() {
+			t.Fatalf(`Node should not exist`)
+		}
+	}
+}
+
+func TestSaveMeshReturnsMeshBytes(t *testing.T) {
+	testParams := setUpTests()
+	node1 := getTestNode()
+
+	testParams.manager.AddNode(node1)
+
+	bytes := testParams.manager.Save()
+
+	if len(bytes) <= 0 {
+		t.Fatalf(`bytes in the mesh is less than 0`)
+	}
+}
+
+func TestSaveMeshThenLoad(t *testing.T) {
+	testParams := setUpTests()
+	testParams2 := setUpTests()
+
+	node1 := getTestNode()
+	testParams.manager.AddNode(node1)
+
+	bytes := testParams.manager.Save()
+
+	err := testParams2.manager.Load(bytes)
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(bytes) <= 0 {
+		t.Fatalf(`bytes in the mesh is less than 0`)
+	}
+
+	mesh2, err := testParams2.manager.GetMesh()
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	nodes := mesh2.GetNodes()
+
+	if lib.MapValues(nodes)[0].GetHostEndpoint() != node1.GetHostEndpoint() {
+		t.Fatalf(`Node should be in the list of nodes`)
+	}
+}
+
+func TestLengthNoNodes(t *testing.T) {
+	testParams := setUpTests()
+
+	if testParams.manager.Length() != 0 {
+		t.Fatalf(`Number of nodes should be 0`)
+	}
+}
+
+func TestLength1Node(t *testing.T) {
+	testParams := setUpTests()
+	node := getTestNode()
+	testParams.manager.AddNode(node)
+
+	if testParams.manager.Length() != 1 {
+		t.Fatalf(`Number of nodes should be 1`)
+	}
+}
+
+func TestLengthMultipleNodes(t *testing.T) {
+	testParams := setUpTests()
+	node := getTestNode()
+	node1 := getTestNode2()
+
+	testParams.manager.AddNode(node)
+	testParams.manager.AddNode(node1)
+
+	if testParams.manager.Length() != 2 {
+		t.Fatalf(`Number of nodes should be 2`)
+	}
+}
+
+func TestHasChangesNoChanges(t *testing.T) {
+	testParams := setUpTests()
+
+	if testParams.manager.HasChanges() {
+		t.Fatalf(`Should not have changes just created document`)
+	}
+}
+
+func TestHasChangesChanges(t *testing.T) {
+	testParams := setUpTests()
+	node := getTestNode()
+
+	testParams.manager.AddNode(node)
+
+	if !testParams.manager.HasChanges() {
+		t.Fatalf(`Should have changes just added node`)
+	}
+}
+
+func TestHasChangesSavedChanges(t *testing.T) {
+	testParams := setUpTests()
+	node := getTestNode()
+
+	testParams.manager.AddNode(node)
+
+	testParams.manager.SaveChanges()
+
+	if testParams.manager.HasChanges() {
+		t.Fatalf(`Should not have changes just saved document`)
+	}
+}
+
+func TestUpdateTimeStampNodeDoesNotExist(t *testing.T) {
+	testParams := setUpTests()
+	err := testParams.manager.UpdateTimeStamp("AAAAAA")
+
+	if err == nil {
+		t.Fatalf(`Error should have returned`)
+	}
+}
+
+func TestUpdateTimeStampNodeExists(t *testing.T) {
+	testParams := setUpTests()
+	node := getTestNode()
+
+	testParams.manager.AddNode(node)
+	err := testParams.manager.UpdateTimeStamp(node.GetHostEndpoint())
+
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestSetDescriptionNodeDoesNotExist(t *testing.T) {
+	testParams := setUpTests()
+	err := testParams.manager.SetDescription("AAAAA", "Bob 123")
+
+	if err == nil {
+		t.Fatalf(`Error should have returned`)
+	}
+}
+
+func TestSetDescriptionNodeExists(t *testing.T) {
+	testParams := setUpTests()
+	node := getTestNode()
+	err := testParams.manager.SetDescription(node.GetHostEndpoint(), "Bob 123")
+
+	if err == nil {
+		t.Fatalf(`Error should have returned`)
+	}
+}
+
+func TestAddRoutesNodeDoesNotExist(t *testing.T) {
+	testParams := setUpTests()
+
+	err := testParams.manager.AddRoutes("AAAAA", "fd:1c64:1d00::/48")
+
+	if err == nil {
+		t.Error(err)
+	}
+}
+
+func TestCompareComparesByPublicKey(t *testing.T) {
+	node := getTestNode().(*MeshNodeCrdt)
+	node2 := getTestNode2().(*MeshNodeCrdt)
+
+	if node.Compare(node2) != -1 {
+		t.Fatalf(`node is alphabetically before node2`)
+	}
+
+	if node2.Compare(node) != 1 {
+		t.Fatalf(`node is alphabetical;y before node2`)
+	}
+
+	if node.Compare(node) != 0 {
+		t.Fatalf(`node is equal to node`)
+	}
+}
+
+func TestGetHostEndpoint(t *testing.T) {
+	node := getTestNode()
+
+	if (node.(*MeshNodeCrdt)).HostEndpoint != node.GetHostEndpoint() {
+		t.Fatalf(`get hostendpoint should get the host endpoint`)
+	}
+}
+
+func TestGetPublicKey(t *testing.T) {
+	key1, _ := wgtypes.GenerateKey()
+
+	node := getTestNode()
+	node.(*MeshNodeCrdt).PublicKey = key1.String()
+
+	pubKey, err := node.GetPublicKey()
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if pubKey.String() != key1.String() {
+		t.Fatalf(`Expected %s got %s`, key1.String(), pubKey.String())
+	}
+}
+
+func TestGetWgEndpoint(t *testing.T) {
+	node := getTestNode()
+
+	if node.(*MeshNodeCrdt).WgEndpoint != node.GetWgEndpoint() {
+		t.Fatal(`Did not return the correct wgEndpoint`)
+	}
+}
+
+func TestGetWgHost(t *testing.T) {
+	node := getTestNode()
+
+	ip := node.GetWgHost()
+
+	if node.(*MeshNodeCrdt).WgHost != ip.String() {
+		t.Fatal(`Did not parse WgHost correctly`)
+	}
+}
+
+func TestGetTimeStamp(t *testing.T) {
+	node := getTestNode()
+
+	if node.(*MeshNodeCrdt).Timestamp != node.GetTimeStamp() {
+		t.Fatal(`Did not return return the correct timestamp`)
+	}
+}
+
+func TestGetIdentifierDoesNotContainPrefix(t *testing.T) {
+	node := getTestNode()
+
+	if strings.Contains(node.GetIdentifier(), "/128") {
+		t.Fatal(`Identifier should not contain prefix`)
+	}
+}
--- a/pkg/automerge/types.go
+++ b/pkg/automerge/types.go
@ -8,6 +8,7 @@ type MeshNodeCrdt struct {
 	WgHost       string                 `automerge:"wgHost"`
 	Timestamp    int64                  `automerge:"timestamp"`
 	Routes       map[string]interface{} `automerge:"routes"`
+	Description  string                 `automerge:"description"`
 }

 // MeshCrdt: Represents the mesh network as a whole
--- a/pkg/conf/conf.go
+++ b/pkg/conf/conf.go
@ -8,6 +8,14 @@ import (
 	"gopkg.in/yaml.v3"
 )

+type WgMeshConfigurationError struct {
+	msg string
+}
+
+func (m *WgMeshConfigurationError) Error() string {
+	return m.msg
+}
+
 type WgMeshConfiguration struct {
 	// CertificatePath is the path to the certificate to use in mTLS
 	CertificatePath string `yaml:"certificatePath"`
@ -25,6 +33,104 @@ type WgMeshConfiguration struct {
 	// Endpoint is the IP in which this computer is publicly reachable.
 	// usecase is when the node has multiple IP addresses
 	Endpoint string `yaml:"publicEndpoint"`
+	// ClusterSize size of the cluster to split on
+	ClusterSize int `yaml:"clusterSize"`
+	// SyncRate number of times per second to perform a sync
+	SyncRate float64 `yaml:"syncRate"`
+	// InterClusterChance proability of inter-cluster communication in a sync round
+	InterClusterChance float64 `yaml:"interClusterChance"`
+	// BranchRate number of nodes to randomly communicate with
+	BranchRate int `yaml:"branchRate"`
+	// InfectionCount number of times we sync before we can no longer catch the udpate
+	InfectionCount int `yaml:"infectionCount"`
+	// KeepAliveTime number of seconds before we update node indicating that we are still alive
+	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 int `yaml:"pruneTime"`
+}
+
+func ValidateConfiguration(c *WgMeshConfiguration) error {
+	if len(c.CertificatePath) == 0 {
+		return &WgMeshConfigurationError{
+			msg: "A public certificate must be specified for mTLS",
+		}
+	}
+
+	if len(c.PrivateKeyPath) == 0 {
+		return &WgMeshConfigurationError{
+			msg: "A private key must be specified for mTLS",
+		}
+	}
+
+	if len(c.CaCertificatePath) == 0 {
+		return &WgMeshConfigurationError{
+			msg: "A ca certificate must be specified for mTLS",
+		}
+	}
+
+	if len(c.GrpcPort) == 0 {
+		return &WgMeshConfigurationError{
+			msg: "A grpc port must be specified",
+		}
+	}
+
+	if c.ClusterSize <= 0 {
+		return &WgMeshConfigurationError{
+			msg: "A cluster size must not be 0",
+		}
+	}
+
+	if c.SyncRate <= 0 {
+		return &WgMeshConfigurationError{
+			msg: "SyncRate cannot be negative",
+		}
+	}
+
+	if c.BranchRate <= 0 {
+		return &WgMeshConfigurationError{
+			msg: "Branch rate cannot be negative",
+		}
+	}
+
+	if c.InfectionCount <= 0 {
+		return &WgMeshConfigurationError{
+			msg: "Infection count cannot be less than 1",
+		}
+	}
+
+	if c.KeepAliveTime <= 0 {
+		return &WgMeshConfigurationError{
+			msg: "KeepAliveRate cannot be less than negative",
+		}
+	}
+
+	if c.InterClusterChance <= 0 {
+		return &WgMeshConfigurationError{
+			msg: "Intercluster chance cannot be less than 0",
+		}
+	}
+
+	if c.Timeout < 1 {
+		return &WgMeshConfigurationError{
+			msg: "Timeout should be greater than or equal to 1",
+		}
+	}
+
+	if c.PruneTime <= 1 {
+		return &WgMeshConfigurationError{
+			msg: "Prune time cannot be <= 1",
+		}
+	}
+
+	if c.KeepAliveTime <= 1 {
+		return &WgMeshConfigurationError{
+			msg: "Prune time cannot be less than keep alive time",
+		}
+	}
+
+	return nil
 }

 // ParseConfiguration parses the mesh configuration
@ -45,5 +151,5 @@ func ParseConfiguration(filePath string) (*WgMeshConfiguration, error) {
 		return nil, err
 	}

-	return &conf, nil
+	return &conf, ValidateConfiguration(&conf)
 }
--- a/pkg/conf/conf_test.go
+++ b/pkg/conf/conf_test.go
@ -0,0 +1,165 @@
+package conf
+
+import "testing"
+
+func getExampleConfiguration() *WgMeshConfiguration {
+	return &WgMeshConfiguration{
+		CertificatePath:      "./cert/cert.pem",
+		PrivateKeyPath:       "./cert/key.pem",
+		CaCertificatePath:    "./cert/ca.pems",
+		SkipCertVerification: true,
+		GrpcPort:             "8080",
+		AdvertiseRoutes:      true,
+		Endpoint:             "localhost",
+		ClusterSize:          1,
+		SyncRate:             1,
+		InterClusterChance:   0.1,
+		BranchRate:           2,
+		KeepAliveTime:        4,
+		InfectionCount:       1,
+		Timeout:              2,
+		PruneTime:            20,
+	}
+}
+
+func TestConfigurationCertificatePathEmpty(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.CertificatePath = ""
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func TestConfigurationPrivateKeyPathEmpty(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.PrivateKeyPath = ""
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func TestConfigurationCaCertificatePathEmpty(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.CaCertificatePath = ""
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func TestConfigurationGrpcPortEmpty(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.GrpcPort = ""
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func TestClusterSizeZero(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.ClusterSize = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func SyncRateZero(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.SyncRate = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func BranchRateZero(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.BranchRate = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func InfectionCountZero(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.InfectionCount = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func KeepAliveRateZero(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.KeepAliveTime = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func TestValidCOnfiguration(t *testing.T) {
+	conf := getExampleConfiguration()
+
+	err := ValidateConfiguration(conf)
+
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTimeout(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.Timeout = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
+func TestPruneTimeZero(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.PruneTime = 0
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatalf(`Error should be thrown`)
+	}
+}
+
+func TestPruneTimeLessThanKeepAliveTime(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.PruneTime = 1
+
+	err := ValidateConfiguration(conf)
+
+	if err == nil {
+		t.Fatalf(`Error should be thrown`)
+	}
+}
--- a/pkg/conn/cluster.go
+++ b/pkg/conn/cluster.go
@ -0,0 +1,75 @@
+package conn
+
+import (
+	"errors"
+	"math"
+	"math/rand"
+	"slices"
+)
+
+// ConnCluster splits nodes into clusters where nodes in a cluster communicate
+// frequently and nodes outside of a cluster communicate infrequently
+type ConnCluster interface {
+	GetNeighbours(global []string, selfId string) []string
+	GetInterCluster(global []string, selfId string) string
+}
+
+type ConnClusterImpl struct {
+	clusterSize int
+}
+
+func binarySearch(global []string, selfId string, groupSize int) (int, int) {
+	slices.Sort(global)
+
+	lower := 0
+	higher := len(global) - 1
+	mid := (lower + higher) / 2
+
+	for (higher+1)-lower > groupSize {
+		if global[mid] < selfId {
+			lower = mid + 1
+		} else if global[mid] > selfId {
+			higher = mid - 1
+		} else {
+			break
+		}
+
+		mid = (lower + higher) / 2
+	}
+
+	return lower, int(math.Min(float64(lower+groupSize), float64(len(global))))
+}
+
+// GetNeighbours return the neighbours 'nearest' to you. In this implementation the
+// neighbours aren't actually the ones nearest to you but just the ones nearest
+// to you alphabetically. Perform binary search to get the total group
+func (i *ConnClusterImpl) GetNeighbours(global []string, selfId string) []string {
+	slices.Sort(global)
+
+	lower, higher := binarySearch(global, selfId, i.clusterSize)
+	// slice the list to get the neighbours
+	return global[lower:higher]
+}
+
+// GetInterCluster get nodes not in your cluster. Every round there is a given chance
+// you will communicate with a random node that is not in your cluster.
+func (i *ConnClusterImpl) GetInterCluster(global []string, selfId string) string {
+	// Doesn't matter if not in it. Get index of where the node 'should' be
+	index, _ := binarySearch(global, selfId, 1)
+	numClusters := math.Ceil(float64(len(global)) / float64(i.clusterSize))
+
+	randomCluster := rand.Intn(int(numClusters)-1) + 1
+
+	neighbourIndex := (index + randomCluster) % len(global)
+	return global[neighbourIndex]
+}
+
+func NewConnCluster(clusterSize int) (ConnCluster, error) {
+	log2Cluster := math.Log2(float64(clusterSize))
+
+	if float64((log2Cluster))-log2Cluster != 0 {
+		return nil, errors.New("cluster must be a power of 2")
+	}
+
+	return &ConnClusterImpl{clusterSize: clusterSize}, nil
+}
--- a/pkg/conn/cluster_test.go
+++ b/pkg/conn/cluster_test.go
@ -0,0 +1,116 @@
+package conn
+
+import (
+	"math/rand"
+	"slices"
+	"testing"
+)
+
+func TestGetNeighboursClusterSizeTwo(t *testing.T) {
+	cluster := &ConnClusterImpl{
+		clusterSize: 2,
+	}
+	neighbours := []string{
+		"a",
+		"b",
+		"c",
+		"d",
+	}
+
+	result := cluster.GetNeighbours(neighbours, "b")
+
+	if len(result) != 2 {
+		t.Fatalf(`neighbour length should be 2`)
+	}
+
+	if result[0] != "a" && result[1] != "b" {
+		t.Fatalf(`Expected value b`)
+	}
+}
+
+func TestGetNeighboursGlobalListLessThanClusterSize(t *testing.T) {
+	cluster := &ConnClusterImpl{
+		clusterSize: 4,
+	}
+
+	neighbours := []string{
+		"a",
+		"b",
+		"c",
+	}
+
+	result := cluster.GetNeighbours(neighbours, "a")
+
+	if len(result) != 3 {
+		t.Fatalf(`neighbour length should be 3`)
+	}
+
+	slices.Sort(result)
+
+	if !slices.Equal(result, neighbours) {
+		t.Fatalf(`Cluster and neighbours should be equal`)
+	}
+}
+
+func TestGetNeighboursClusterSize4(t *testing.T) {
+	cluster := &ConnClusterImpl{
+		clusterSize: 4,
+	}
+
+	neighbours := []string{
+		"a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
+		"k", "l", "m", "n", "o",
+	}
+
+	result := cluster.GetNeighbours(neighbours, "k")
+
+	if len(result) != 4 {
+		t.Fatalf(`cluster size must be 4`)
+	}
+
+	slices.Sort(result)
+
+	if !slices.Equal(neighbours[8:12], result) {
+		t.Fatalf(`Cluster should be i, j, k, l`)
+	}
+}
+
+func TestGetNeighboursClusterSize4OneReturned(t *testing.T) {
+	cluster := &ConnClusterImpl{
+		clusterSize: 4,
+	}
+
+	neighbours := []string{
+		"a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
+		"k", "l", "m", "n", "o",
+	}
+
+	result := cluster.GetNeighbours(neighbours, "o")
+
+	if len(result) != 3 {
+		t.Fatalf(`Cluster should be of length 3`)
+	}
+
+	if !slices.Equal(neighbours[12:15], result) {
+		t.Fatalf(`Cluster should be m, n, o`)
+	}
+}
+
+func TestInterClusterNotInCluster(t *testing.T) {
+	rand.Seed(1)
+	cluster := &ConnClusterImpl{
+		clusterSize: 4,
+	}
+
+	global := []string{
+		"a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
+		"k", "l", "m", "n", "o",
+	}
+
+	neighbours := cluster.GetNeighbours(global, "c")
+	interCluster := cluster.GetInterCluster(global, "c")
+
+	if slices.Contains(neighbours, interCluster) {
+		t.Fatalf(`intercluster cannot be in your cluster`)
+	}
+}
--- a/pkg/conn/connection.go
+++ b/pkg/conn/connection.go
@ -5,12 +5,10 @@ package conn
 import (
 	"crypto/tls"
 	"errors"
-	"time"

 	logging "github.com/tim-beatham/wgmesh/pkg/log"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/keepalive"
 )

 // PeerConnection represents a client-side connection between two
@ -20,6 +18,8 @@ type PeerConnection interface {
 	GetClient() (*grpc.ClientConn, error)
 }

+type PeerConnectionFactory = func(clientConfig *tls.Config, server string) (PeerConnection, error)
+
 // WgCtrlConnection implements PeerConnection.
 type WgCtrlConnection struct {
 	clientConfig *tls.Config
@ -28,12 +28,12 @@ type WgCtrlConnection struct {
 }

 // NewWgCtrlConnection creates a new instance of a WireGuard control connection
-func NewWgCtrlConnection(clientConfig *tls.Config, server string) (*WgCtrlConnection, error) {
+func NewWgCtrlConnection(clientConfig *tls.Config, server string) (PeerConnection, error) {
 	var conn WgCtrlConnection
 	conn.clientConfig = clientConfig
 	conn.endpoint = server

-	if err := conn.createGrpcConn(); err != nil {
+	if err := conn.CreateGrpcConnection(); err != nil {
 		return nil, err
 	}

@ -41,13 +41,9 @@ func NewWgCtrlConnection(clientConfig *tls.Config, server string) (*WgCtrlConnec
 }

 // ConnectWithToken: Connects to a new gRPC peer given the address of the other server.
-func (c *WgCtrlConnection) createGrpcConn() error {
+func (c *WgCtrlConnection) CreateGrpcConnection() error {
 	conn, err := grpc.Dial(c.endpoint,
-		grpc.WithTransportCredentials(credentials.NewTLS(c.clientConfig)),
-		grpc.WithKeepaliveParams(keepalive.ClientParameters{
-			Time:    10 * time.Minute,
-			Timeout: 30 * time.Minute,
-		}))
+		grpc.WithTransportCredentials(credentials.NewTLS(c.clientConfig)))

 	if err != nil {
 		logging.Log.WriteErrorf("Could not connect: %s\n", err.Error())
@ -68,7 +64,7 @@ func (c *WgCtrlConnection) GetClient() (*grpc.ClientConn, error) {
 	var err error = nil

 	if c.conn == nil {
-		err = errors.New("The client's config does not exist")
+		err = errors.New("the client's config does not exist")
 	}

 	return c.conn, err
--- a/pkg/conn/connectionmanager.go
+++ b/pkg/conn/connectionmanager.go
@ -34,10 +34,11 @@ type ConnectionManagerImpl struct {
 	clientConnections map[string]PeerConnection
 	serverConfig      *tls.Config
 	clientConfig      *tls.Config
+	connFactory       PeerConnectionFactory
 }

 // Create a new instance of a connection manager.
-type NewConnectionManageParams struct {
+type NewConnectionManagerParams struct {
 	// The path to the certificate
 	CertificatePath string
 	// The private key of the node
@ -45,11 +46,12 @@ type NewConnectionManageParams struct {
 	// Whether or not to skip certificate verification
 	SkipCertVerification bool
 	CaCert               string
+	ConnFactory          PeerConnectionFactory
 }

 // NewConnectionManager: Creates a new instance of a ConnectionManager or an error
 // if something went wrong.
-func NewConnectionManager(params *NewConnectionManageParams) (ConnectionManager, error) {
+func NewConnectionManager(params *NewConnectionManagerParams) (ConnectionManager, error) {
 	cert, err := tls.LoadX509KeyPair(params.CertificatePath, params.PrivateKey)

 	if err != nil {
@ -94,7 +96,14 @@ func NewConnectionManager(params *NewConnectionManageParams) (ConnectionManager,
 	}

 	connections := make(map[string]PeerConnection)
-	connMgr := ConnectionManagerImpl{sync.RWMutex{}, connections, serverConfig, clientConfig}
+	connMgr := ConnectionManagerImpl{
+		sync.RWMutex{},
+		connections,
+		serverConfig,
+		clientConfig,
+		params.ConnFactory,
+	}
+
 	return &connMgr, nil
 }

@ -122,7 +131,7 @@ func (m *ConnectionManagerImpl) AddConnection(endPoint string) (PeerConnection,
 		return conn, nil
 	}

-	connections, err := NewWgCtrlConnection(m.clientConfig, endPoint)
+	connections, err := m.connFactory(m.clientConfig, endPoint)

 	if err != nil {
 		return nil, err
@ -131,6 +140,7 @@ func (m *ConnectionManagerImpl) AddConnection(endPoint string) (PeerConnection,
 	m.conLoc.Lock()
 	m.clientConnections[endPoint] = connections
 	m.conLoc.Unlock()
+
 	return connections, nil
 }

--- a/pkg/conn/connectionmanager_test.go
+++ b/pkg/conn/connectionmanager_test.go
@ -0,0 +1,145 @@
+package conn
+
+import (
+	"crypto/tls"
+	"errors"
+	"log"
+	"testing"
+)
+
+func getConnectionManagerParams() *NewConnectionManagerParams {
+	return &NewConnectionManagerParams{
+		CertificatePath:      "./test/cert.pem",
+		PrivateKey:           "./test/priv.pem",
+		CaCert:               "./test/cacert.pem",
+		SkipCertVerification: false,
+		ConnFactory:          MockFactory,
+	}
+}
+
+func TestNewConnectionManagerCertificatePathDoesNotExist(t *testing.T) {
+	params := getConnectionManagerParams()
+	params.CertificatePath = "./cert/sdfjdskjdsjkd.pem"
+
+	_, err := NewConnectionManager(params)
+
+	if err == nil {
+		t.Fatalf(`Expected error as certificate does not exist`)
+	}
+}
+
+func TestNewConnectionManagerPrivateKeyDoesNotExist(t *testing.T) {
+	params := getConnectionManagerParams()
+	params.PrivateKey = "./cert/sdjdjdks.pem"
+
+	_, err := NewConnectionManager(params)
+
+	if err == nil {
+		t.Fatalf(`Expected error as private key does not exist`)
+	}
+}
+
+func TestNewConnectionManagerCACertDoesNotExistAndVerify(t *testing.T) {
+	params := getConnectionManagerParams()
+	params.CaCert = "./cert/sdjdsjdksjdks.pem"
+	params.SkipCertVerification = false
+
+	_, err := NewConnectionManager(params)
+
+	if err == nil {
+		t.Fatal(`Expected error as ca cert does not exist and skip is false`)
+	}
+}
+
+func TestNewConnectionManagerCACertDoesNotExistAndNotVerify(t *testing.T) {
+	params := getConnectionManagerParams()
+	params.CaCert = ""
+	params.SkipCertVerification = true
+
+	_, err := NewConnectionManager(params)
+
+	if err != nil {
+		t.Fatal(`an error should not be thrown`)
+	}
+}
+
+func TestGetConnectionConnectionDoesNotExistAddsConnection(t *testing.T) {
+	params := getConnectionManagerParams()
+
+	m, _ := NewConnectionManager(params)
+
+	conn, err := m.GetConnection("abc-123.com")
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if conn == nil {
+		t.Fatal(`the connection should not be nil`)
+	}
+
+	conn2, _ := m.GetConnection("abc-123.com")
+
+	if conn != conn2 {
+		log.Fatalf(`should return the same connection instance`)
+	}
+}
+
+func TestAddConnectionThrowsAnErrorIfFactoryThrowsError(t *testing.T) {
+	params := getConnectionManagerParams()
+	params.ConnFactory = func(clientConfig *tls.Config, server string) (PeerConnection, error) {
+		return nil, errors.New("this is an error")
+	}
+
+	m, _ := NewConnectionManager(params)
+
+	_, err := m.AddConnection("abc-123.com")
+
+	if err == nil || err.Error() != "this is an error" {
+		t.Error(err)
+	}
+}
+
+func TestAddConnectionConnectionDoesNotExist(t *testing.T) {
+	params := getConnectionManagerParams()
+
+	m, _ := NewConnectionManager(params)
+
+	conn, err := m.AddConnection("abc-123.com")
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if conn == nil {
+		t.Fatal(`connection should not be nil`)
+	}
+
+	conn1, _ := m.GetConnection("abc-123.com")
+
+	if conn != conn1 {
+		t.Fatal(`underlying connections should be the same`)
+	}
+}
+
+func TestHasConnectionConnectionDoesNotExist(t *testing.T) {
+	params := getConnectionManagerParams()
+
+	m, _ := NewConnectionManager(params)
+
+	if m.HasConnection("abc-123.com") {
+		t.Fatal(`should return that the connection does not exist`)
+	}
+}
+
+func TestHasConnectionConnectionExists(t *testing.T) {
+	params := getConnectionManagerParams()
+
+	m, _ := NewConnectionManager(params)
+
+	m.AddConnection("abc-123.com")
+
+	if !m.HasConnection("abc-123.com") {
+		t.Fatal(`should return that the connection exists`)
+	}
+}
--- a/pkg/conn/connectionserver.go
+++ b/pkg/conn/connectionserver.go
@ -16,9 +16,7 @@ type ConnectionServer struct {
 	// tlsConfiguration of the server
 	serverConfig *tls.Config
 	// server an instance of the grpc server
-	server *grpc.Server
-	// the authentication service to authenticate nodes
-	authProvider rpc.AuthenticationServer
+	server *grpc.Server // the authentication service to authenticate nodes
 	// the ctrl service to manage node
 	ctrlProvider rpc.MeshCtrlServerServer
 	// the sync service to synchronise nodes
@ -30,7 +28,6 @@ type ConnectionServer struct {
 // NewConnectionServerParams contains params for creating a new connection server
 type NewConnectionServerParams struct {
 	Conf         *conf.WgMeshConfiguration
-	AuthProvider rpc.AuthenticationServer
 	CtrlProvider rpc.MeshCtrlServerServer
 	SyncProvider rpc.SyncServiceServer
 }
@ -59,14 +56,12 @@ func NewConnectionServer(params *NewConnectionServerParams) (*ConnectionServer,
 		grpc.Creds(credentials.NewTLS(serverConfig)),
 	)

-	authProvider := params.AuthProvider
 	ctrlProvider := params.CtrlProvider
 	syncProvider := params.SyncProvider

 	connServer := ConnectionServer{
 		serverConfig: serverConfig,
 		server:       server,
-		authProvider: authProvider,
 		ctrlProvider: ctrlProvider,
 		syncProvider: syncProvider,
 		Conf:         params.Conf,
@ -78,7 +73,6 @@ func NewConnectionServer(params *NewConnectionServerParams) (*ConnectionServer,
 // Listen for incoming requests. Returns an error if something went wrong.
 func (s *ConnectionServer) Listen() error {
 	rpc.RegisterMeshCtrlServerServer(s.server, s.ctrlProvider)
-	rpc.RegisterAuthenticationServer(s.server, s.authProvider)

 	rpc.RegisterSyncServiceServer(s.server, s.syncProvider)

--- a/pkg/conn/stub.go
+++ b/pkg/conn/stub.go
@ -0,0 +1,51 @@
+package conn
+
+import (
+	"crypto/tls"
+
+	"google.golang.org/grpc"
+)
+
+type ConnectionManagerStub struct {
+	Endpoints map[string]PeerConnection
+}
+
+func (s *ConnectionManagerStub) AddConnection(endPoint string) (PeerConnection, error) {
+	mock := &PeerConnectionMock{}
+	s.Endpoints[endPoint] = mock
+	return mock, nil
+}
+
+func (s *ConnectionManagerStub) GetConnection(endPoint string) (PeerConnection, error) {
+	endpoint, ok := s.Endpoints[endPoint]
+
+	if !ok {
+		return s.AddConnection(endPoint)
+	}
+
+	return endpoint, nil
+}
+
+func (s *ConnectionManagerStub) HasConnection(endPoint string) bool {
+	_, ok := s.Endpoints[endPoint]
+	return ok
+}
+
+func (s *ConnectionManagerStub) Close() error {
+	return nil
+}
+
+type PeerConnectionMock struct {
+}
+
+func (c *PeerConnectionMock) Close() error {
+	return nil
+}
+
+func (c *PeerConnectionMock) GetClient() (*grpc.ClientConn, error) {
+	return &grpc.ClientConn{}, nil
+}
+
+var MockFactory PeerConnectionFactory = func(clientConfig *tls.Config, server string) (PeerConnection, error) {
+	return &PeerConnectionMock{}, nil
+}
--- a/pkg/conn/test/cacert.pem
+++ b/pkg/conn/test/cacert.pem
@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDazCCAlOgAwIBAgIUDRIRI8UnHU2a4znsun0gxFwlrFQwDQYJKoZIhvcNAQEL
+BQAwRTELMAkGA1UEBhMCR0IxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMzEwMjcxNTIzMDZaFw0yNDEw
+MjYxNTIzMDZaMEUxCzAJBgNVBAYTAkdCMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
+HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDJ5hOmzilimA/zM5hYP7CQf4iRmICtSbVLgt6/rTDP
+p3JsGGQWZ4pZNofzGnGa7aEMoXS2Ztl7GzZbr1p4+rd6MBbVt8XZ/hP+X4zasCXi
+/YubG0TYyBuAt+JrcYb0cbsTBkMXXnFcNIXDfeYFsNq+pfyJwq2ElMUUZ6SQmVhH
+ovn1Wk9Fv4t2GJMhmUcObrSIoYdgo4Vf9CfQnn0PCaRf+RjspY/Kz33oyqDI6xJx
+I0rfJR7f9B6ZKosfAkt4oTTfT9P8w/d1I95oBENhDkalgkdJCuNJ/AwKGxZrYf/P
+aefcc91HheauObjBYPFrSn6bUj3LMJEfj4IeBK+fOZCfAgMBAAGjUzBRMB0GA1Ud
+DgQWBBSpcF7jtpd9n73VM3xhPmI1GMEkFjAfBgNVHSMEGDAWgBSpcF7jtpd9n73V
+M3xhPmI1GMEkFjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQCK
+GplAveP9nVo9zmg+/mkDpyVoo5rp64oJh4DFtm6X+EI31FmH6Cb71Kn2ZzXhQvSq
+qrP7+VoGeBDxk4guJtAs/fhnuDupJG2SjsctjiFnDbSrJjWJjGhC0kuL0wcjLU5G
+qUpCEJu13GkDlYHKKw0z+oLUOw+OHmvE5/sD23sKl2KxBWKItx0hwSCkGtm0RQld
+8mfjOsHqJ2V/FOcHK6X2DSV1728PAhu4l/PRSB0drBA+7kdeCuWIRZw5RA/OyxvU
+CuC5dfUh75MrK7KL6sZsXklsoXo8BZp4rRRUt/v1D3r/SMBJPULSGXh6QDjXQX1D
+km71c3DEDyKznHTpGxPt
+-----END CERTIFICATE-----
--- a/pkg/conn/test/caprivate.pem
+++ b/pkg/conn/test/caprivate.pem
@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDJ5hOmzilimA/z
+M5hYP7CQf4iRmICtSbVLgt6/rTDPp3JsGGQWZ4pZNofzGnGa7aEMoXS2Ztl7GzZb
+r1p4+rd6MBbVt8XZ/hP+X4zasCXi/YubG0TYyBuAt+JrcYb0cbsTBkMXXnFcNIXD
+feYFsNq+pfyJwq2ElMUUZ6SQmVhHovn1Wk9Fv4t2GJMhmUcObrSIoYdgo4Vf9CfQ
+nn0PCaRf+RjspY/Kz33oyqDI6xJxI0rfJR7f9B6ZKosfAkt4oTTfT9P8w/d1I95o
+BENhDkalgkdJCuNJ/AwKGxZrYf/Paefcc91HheauObjBYPFrSn6bUj3LMJEfj4Ie
+BK+fOZCfAgMBAAECggEADqAjoUxC9Dj2wtPkf9QRSs5qSr3E6Iiz4OX4k+MMa6aC
+I/F6YqMagw7vtz0dqK75ISybA1GdBI16mRaxU5056FiOdunqo7mDokQytG7ZN8HN
+OK23hYqtb1wiw0zEjXWlqyGjf5BgXuERJZG7tYLTvcbRbftTzYxnYGyHn8/z9LBp
+GsTJ5X8XMLM5+bTvg1Ovv5s0q31FCeqAuw+auHH4pBNP+ylV6dF5XOWq4HO3TJ2b
+grHxWB94JZChZnDC/K+HxQ6aHJfbZ5XCoXfIaIVkoXfnyPzgjvgK+/IpHEF8f/3I
+uT/NBiArTpRl29pX5flEO4R121VaW93eM1tuzL32VQKBgQD6Trctx9SYuhzgfiO7
+kdefvR43Kl9SFyEw3hN3HW1cxSNGCCFotjmdem+QdtMBtUd27UJ9tuiKJC0lcCER
+t3WRz4kVd/cb0eC1DPzpGHA81o1rUUR3nMr1o7aBfvQ06VAxFUrFAOPpF8nD7tI4
+0CiOh7/sL1ElThA3bOPUpXkYHQKBgQDOfYbP8dppIkC8pRTnHWe0qUY0G4YXxg7r
+UtTo4GYOLJeKH/MKoK8MjBDS5VN5n5TAHJ8yUVzhpWXZIPIGzNEhIRDMa56sRPgI
+9mLJNs5z/ZIxd/7ZQbDHrD4T3PKeTjzVUtjXrhLowokPlPB/RMQL6ZT+qMao+3bS
+fDITSfLG6wKBgBpbcZSDh1JxvpqxDagxqkfqzSS39IObZeZUbC5NzfdH1vgH4SS6
+k4SOoPLQYFW8tgLC5w5/1Sq+tnZLwV+xNtMczG2TTVUDm6rU7EjLRv5RBWE4lIIX
+45NMIuqt6J8ttkEE4fOurVEdLSTRoBdVa//eMYp4TQ4lkzWS5Ma+ierNAoGAYO3z
+1rFFQYzerq8ffM4E3H2JgvRYodhLMJQVdavAvG6aRDBzOk3rXgxx6U3VPYZ3oSbO
+ZCRlYVbu1FnuwtpqYQ7Qf+UU+vD1Ld/ax3F+wFwLwET/0KRRg6mLCm/xQ/ad/9WA
+DN6d6b1H8ZSMwHFbRexEELbRaomAYZYDO6K+4DkCgYEAv5De85hPnWtAvKhPzwQi
+9mtyWo/cfQgtwL8IKNu6hBHl5RXDpPgX/+pNbXLJfBPwVR3H62x1CMYJDkWVuE6/
+ZjtF7FSucZMz/mR6r1GhSOXy3YLwQ6JLPjjKzvnEjahGlKwALJNL0O2ZucjsZxHE
+PM4rmhRZT9opiapiltEhRm0=
+-----END PRIVATE KEY-----
--- a/pkg/conn/test/cert.pem
+++ b/pkg/conn/test/cert.pem
@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDCjCCAfICFB/Vd2eOXWdNdrakThJhFIRtZmhUMA0GCSqGSIb3DQEBCwUAMEUx
+CzAJBgNVBAYTAkdCMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQwHhcNMjMxMDI3MTUzNDM1WhcNMjMxMTI2MTUz
+NDM1WjA+MQswCQYDVQQGEwJHQjENMAsGA1UECAwERmlmZTENMAsGA1UEBwwEY2l0
+eTERMA8GA1UECgwITWVzaCBMdGQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQDVgcLtNU5AYfPML/mE5PyC7YYKvZn2mt6vEiJ7M/6EzYeTXFeYexD5ZqHg
+ewGEd1fwiQWQsATsWd+EM4OnCAXAaNiOH6gGY7FR8CThfT+k8yIGPrl1BovzHHYS
+Orekna17UFeIyFMHDPIjl4d2WiJPvmNn5PhLEppPHPBWPhl3J3sMrSbqyRuYbtta
+oFIzN8mFcikixLg0SnBPtwlLC72ah9G+MF5CwEcU/E0bYbLQZXv+WhG5aw5JEzes
+K2GLxVNgM0xXB7hSyLoX1wBc8DdQyLCMkOp55Hl04UKTxtVE82MiuAOVqMUuKFjR
+u2a1C+/Gbk/PS5SHgenGjdZ8sZGpAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAHMc
+jIFG5Rn9KaVmo7E+/UAq+3ld/3y2yMHg5wq7oG8b7/z0mlSGErHdFMzo75AFLN4r
+kOuiF5ItF6dRLNrG8IUFSNMGVH3b3ukw1EI8E89L8ak3CM+wpLT6GVP3BfV8ah+X
+4RRix40Tmx4C81l+Lf5W10rHIdlXBCanJy/Fa0ae+S+oXFc9jeXHlK9qlgszrECT
+Pa3VCR95LAIc6o9pDL2Z8tpEkSbyzvIWhp53fnC80PyXpSsFMfIw657shagBc/Ov
+e7/aPpPf3V3CafJlEIraQp24MDI5ZM59lT5vhRq2AC50gelL6UPV16mVVUlGVhWE
+vYyejod5i5ZbuLFOy2g=
+-----END CERTIFICATE-----
--- a/pkg/conn/test/priv.pem
+++ b/pkg/conn/test/priv.pem
@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDVgcLtNU5AYfPM
+L/mE5PyC7YYKvZn2mt6vEiJ7M/6EzYeTXFeYexD5ZqHgewGEd1fwiQWQsATsWd+E
+M4OnCAXAaNiOH6gGY7FR8CThfT+k8yIGPrl1BovzHHYSOrekna17UFeIyFMHDPIj
+l4d2WiJPvmNn5PhLEppPHPBWPhl3J3sMrSbqyRuYbttaoFIzN8mFcikixLg0SnBP
+twlLC72ah9G+MF5CwEcU/E0bYbLQZXv+WhG5aw5JEzesK2GLxVNgM0xXB7hSyLoX
+1wBc8DdQyLCMkOp55Hl04UKTxtVE82MiuAOVqMUuKFjRu2a1C+/Gbk/PS5SHgenG
+jdZ8sZGpAgMBAAECggEARJNAggLYhtpPPVp9WJ9ZsU3L+0AppujYND/tXkf1bD89
+V+nVYq7IZWp+/MRVWPAiCSphZLb8ZdN59JK9KtVrT4D9aSymwaKcjfZFSj15xyem
+Wn4j///hzGxsSe+dE1znnw9PhindbQrN7Pua8TsDATzj3bdPvoETmexwDysz765i
+u4zXvxP+xAessz1OYa5IUaDXdlWOf0e1zNXWwanjRggzCeWR3lTofG49GX087oVC
+Sb9ASy+AScnOlwpTdQ8sKy1r9gXmE5ey4AULVb0nJ8LDvrCoBBhKBtVE5mJHepE6
+bdC9l6poL6roGvHfMAo3SmiUUT5XceqUxBtHcyHX3wKBgQD1uh+Dv0PrH3CTW9cF
+bwHL1rmQNJrbDzDAaounGBe9mcot1RrBhyQAoGw1no4c+QWDAwYRuBP2+Rp6JLU/
+XnEXSyN85rJN6LajlrLEr+BNmKw6ghNsnAFUZBLaJ7epRi6OjACUwmtvH6hRIef8
+aMg4WiOyDT+Z4Xe81pdXb91HXwKBgQDebs3idgVEau3LCKGYnqvmUhzv8iiQiJmD
+R29o2G5Xrahf3r1O5gJdGLO1DaCBtdrI7J4xUOlM935KaEYFe5B7RVGXg23tNWgb
+2M+YQqu5qz61bDxhg7dGkegHrdvKNcSkV6GUSm5w9rdxJlY8+l45p/7QpSkatcbd
+IRiVzMNr9wKBgQC/+Z5fbpFgYxqvdaPicdxkZShqOj71f8OlwFfEvrTlgv4KmqAh
+rDP7bVm89leu2PpuZXFbbIXkgK8n1//mNyGBgkmCbjXFWlc+LSETOxixZuK/fxov
+0x3S0bBM0ZTSYatD4KsfjVkj4wa8BBJbB33NUNbsZx9WWGkUlk58mD+3XwKBgQDV
+mgR+n6WJQUIfwqckH+Ol517AkYSg33zEE9qKDaVQ74QMpKKY3MqSSkFw8agcR93V
+K1zysOeJsPYHUEFFzJY/up6S6HSs4aebbkZUylmMkEVFBa6qWkmrLDxs+2lgsuem
+hjy1YhDSzCn3L8CLCEdqCMjr5l8ltkBFZB3u5NcZmwKBgHE9ODedQm783JfvDNBb
+lB/IoUjMhMR0J2vHC3zxgTU4nIK+MR0vXvA7fmZebpaQNwYrHY9gvrL0/QevOrmG
+PtXlkQ9GITMxTlqfHWV5jXZuRBIGTqh1QW3tKbVAhUhNlM0XDNBmBvjKIFjxUIo3
+zMRw/o4R4cIaazyVxguZbsa2
+-----END PRIVATE KEY-----
--- a/pkg/conn/window.go
+++ b/pkg/conn/window.go
@ -0,0 +1,84 @@
+package conn
+
+import (
+	"errors"
+	"slices"
+
+	"github.com/tim-beatham/wgmesh/pkg/lib"
+)
+
+// ConnectionWindow maintains a sliding window of connections between users
+type ConnectionWindow interface {
+	// GetWindow is a list of connections to choose from
+	GetWindow() []string
+	// SlideConnection removes a node from the window and adds a random node
+	// not already in the window. connList represents the list of possible
+	// connections to choose from
+	SlideConnection(connList []string) error
+	// PushConneciton is used when connection list less than window size.
+	PutConnection(conn []string) error
+	// IsFull returns true if the window is full. In which case we must slide the window
+	IsFull() bool
+}
+
+type ConnectionWindowImpl struct {
+	window     []string
+	windowSize int
+}
+
+// GetWindow gets the current list of active connections in
+// the window
+func (c *ConnectionWindowImpl) GetWindow() []string {
+	return c.window
+}
+
+// SlideConnection slides the connection window by one shuffling items
+// in the windows
+func (c *ConnectionWindowImpl) SlideConnection(connList []string) error {
+	// If the number of peer connections is less than the length of the window
+	// then exit early. Can't slide the window it should contain all nodes!
+	if len(c.window) < c.windowSize {
+		return nil
+	}
+
+	filter := func(node string) bool {
+		return !slices.Contains(c.window, node)
+	}
+
+	pool := lib.Filter(connList, filter)
+	newNode := lib.RandomSubsetOfLength(pool, 1)
+
+	if len(newNode) == 0 {
+		return errors.New("could not slide window")
+	}
+
+	for i := len(c.window) - 1; i >= 1; i-- {
+		c.window[i] = c.window[i-1]
+	}
+
+	c.window[0] = newNode[0]
+	return nil
+}
+
+// PutConnection put random connections in the connection
+func (c *ConnectionWindowImpl) PutConnection(connList []string) error {
+	if len(c.window) >= c.windowSize {
+		return errors.New("cannot place connection. Window full need to slide")
+	}
+
+	c.window = lib.RandomSubsetOfLength(connList, c.windowSize)
+	return nil
+}
+
+func (c *ConnectionWindowImpl) IsFull() bool {
+	return len(c.window) >= c.windowSize
+}
+
+func NewConnectionWindow(windowLength int) ConnectionWindow {
+	window := &ConnectionWindowImpl{
+		window:     make([]string, 0),
+		windowSize: windowLength,
+	}
+
+	return window
+}
--- a/pkg/ctrlserver/ctrlserver.go
+++ b/pkg/ctrlserver/ctrlserver.go
@ -6,6 +6,7 @@ import (
 	"github.com/tim-beatham/wgmesh/pkg/conn"
 	"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/mesh"
 	"github.com/tim-beatham/wgmesh/pkg/query"
 	"github.com/tim-beatham/wgmesh/pkg/rpc"
@ -17,7 +18,6 @@ import (
 type NewCtrlServerParams struct {
 	Conf         *conf.WgMeshConfiguration
 	Client       *wgctrl.Client
-	AuthProvider rpc.AuthenticationServer
 	CtrlProvider rpc.MeshCtrlServerServer
 	SyncProvider rpc.SyncServiceServer
 	Querier      query.Querier
@ -35,6 +35,8 @@ func NewCtrlServer(params *NewCtrlServerParams) (*MeshCtrlServer, error) {
 	ipAllocator := &ip.ULABuilder{}
 	interfaceManipulator := wg.NewWgInterfaceManipulator(params.Client)

+	configApplyer := mesh.NewWgMeshConfigApplyer()
+
 	meshManagerParams := &mesh.NewMeshManagerParams{
 		Conf:                 *params.Conf,
 		Client:               params.Client,
@ -43,16 +45,19 @@ func NewCtrlServer(params *NewCtrlServerParams) (*MeshCtrlServer, error) {
 		IdGenerator:          idGenerator,
 		IPAllocator:          ipAllocator,
 		InterfaceManipulator: interfaceManipulator,
+		ConfigApplyer:        configApplyer,
 	}

 	ctrlServer.MeshManager = mesh.NewMeshManager(meshManagerParams)
+	configApplyer.SetMeshManager(ctrlServer.MeshManager)

 	ctrlServer.Conf = params.Conf
-	connManagerParams := conn.NewConnectionManageParams{
+	connManagerParams := conn.NewConnectionManagerParams{
 		CertificatePath:      params.Conf.CertificatePath,
 		PrivateKey:           params.Conf.PrivateKeyPath,
 		SkipCertVerification: params.Conf.SkipCertVerification,
 		CaCert:               params.Conf.CaCertificatePath,
+		ConnFactory:          conn.NewWgCtrlConnection,
 	}

 	connMgr, err := conn.NewConnectionManager(&connManagerParams)
@ -64,7 +69,6 @@ func NewCtrlServer(params *NewCtrlServerParams) (*MeshCtrlServer, error) {
 	ctrlServer.ConnectionManager = connMgr
 	connServerParams := conn.NewConnectionServerParams{
 		Conf:         params.Conf,
-		AuthProvider: params.AuthProvider,
 		CtrlProvider: params.CtrlProvider,
 		SyncProvider: params.SyncProvider,
 	}
@ -81,14 +85,38 @@ func NewCtrlServer(params *NewCtrlServerParams) (*MeshCtrlServer, error) {
 	return ctrlServer, nil
 }

+func (s *MeshCtrlServer) GetConfiguration() *conf.WgMeshConfiguration {
+	return s.Conf
+}
+
+func (s *MeshCtrlServer) GetClient() *wgctrl.Client {
+	return s.Client
+}
+
+func (s *MeshCtrlServer) GetQuerier() query.Querier {
+	return s.Querier
+}
+
+func (s *MeshCtrlServer) GetMeshManager() mesh.MeshManager {
+	return s.MeshManager
+}
+
+func (s *MeshCtrlServer) GetConnectionManager() conn.ConnectionManager {
+	return s.ConnectionManager
+}
+
 // Close closes the ctrl server tearing down any connections that exist
 func (s *MeshCtrlServer) Close() error {
 	if err := s.ConnectionManager.Close(); err != nil {
-		return err
+		logging.Log.WriteErrorf(err.Error())
+	}
+
+	if err := s.MeshManager.Close(); err != nil {
+		logging.Log.WriteErrorf(err.Error())
 	}

 	if err := s.ConnectionServer.Close(); err != nil {
-		return err
+		logging.Log.WriteErrorf(err.Error())
 	}

 	return nil
--- a/pkg/ctrlserver/ctrltypes.go
+++ b/pkg/ctrlserver/ctrltypes.go
@ -25,10 +25,19 @@ type Mesh struct {
 	Nodes     map[string]MeshNode
 }

+type CtrlServer interface {
+	GetConfiguration() *conf.WgMeshConfiguration
+	GetClient() *wgctrl.Client
+	GetQuerier() query.Querier
+	GetMeshManager() mesh.MeshManager
+	Close() error
+	GetConnectionManager() conn.ConnectionManager
+}
+
 // Represents a ctrlserver to be used in WireGuard
 type MeshCtrlServer struct {
 	Client            *wgctrl.Client
-	MeshManager       *mesh.MeshManager
+	MeshManager       mesh.MeshManager
 	ConnectionManager conn.ConnectionManager
 	ConnectionServer  *conn.ConnectionServer
 	Conf              *conf.WgMeshConfiguration
--- a/pkg/ctrlserver/stub.go
+++ b/pkg/ctrlserver/stub.go
@ -0,0 +1,51 @@
+package ctrlserver
+
+import (
+	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/wgmesh/pkg/conn"
+	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/wgmesh/pkg/query"
+	"golang.zx2c4.com/wireguard/wgctrl"
+)
+
+type CtrlServerStub struct {
+	manager           mesh.MeshManager
+	querier           query.Querier
+	connectionManager conn.ConnectionManager
+}
+
+func NewCtrlServerStub() *CtrlServerStub {
+	var manager mesh.MeshManager = mesh.NewMeshManagerStub()
+	return &CtrlServerStub{
+		manager:           manager,
+		querier:           query.NewJmesQuerier(manager),
+		connectionManager: &conn.ConnectionManagerStub{},
+	}
+}
+
+func (c *CtrlServerStub) GetConfiguration() *conf.WgMeshConfiguration {
+	return &conf.WgMeshConfiguration{
+		GrpcPort: "8080",
+		Endpoint: "abc.com",
+	}
+}
+
+func (c *CtrlServerStub) GetClient() *wgctrl.Client {
+	return &wgctrl.Client{}
+}
+
+func (c *CtrlServerStub) GetQuerier() query.Querier {
+	return c.querier
+}
+
+func (c *CtrlServerStub) GetMeshManager() mesh.MeshManager {
+	return c.manager
+}
+
+func (c *CtrlServerStub) Close() error {
+	return nil
+}
+
+func (c *CtrlServerStub) GetConnectionManager() conn.ConnectionManager {
+	return c.connectionManager
+}
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@ -56,6 +56,7 @@ type MeshIpc interface {
 	EnableInterface(meshId string, reply *string) error
 	GetDOT(meshId string, reply *string) error
 	Query(query QueryMesh, reply *string) error
+	PutDescription(description string, reply *string) error
 }

 const SockAddr = "/tmp/wgmesh_ipc.sock"
--- a/pkg/lib/conv.go
+++ b/pkg/lib/conv.go
@ -1,9 +1,5 @@
 package lib

-import (
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
-)
-
 // MapToSlice converts a map to a slice in go
 func MapValues[K comparable, V any](m map[K]V) []V {
 	return MapValuesWithExclude(m, map[K]struct{}{})
@ -23,8 +19,6 @@ func MapValuesWithExclude[K comparable, V any](m map[K]V, exclude map[K]struct{}
 			continue
 		}

-		logging.Log.WriteInfof("Key %s", k)
-
 		values[i] = v
 		i++
 	}
@ -36,7 +30,7 @@ func MapKeys[K comparable, V any](m map[K]V) []K {
 	values := make([]K, len(m))

 	i := 0
-	for k, _ := range m {
+	for k := range m {
 		values[i] = k
 		i++
 	}
@ -46,6 +40,7 @@ func MapKeys[K comparable, V any](m map[K]V) []K {

 type convert[V1 any, V2 any] func(V1) V2

+// Map turns a list of type V1 into type V2
 func Map[V1 any, V2 any](list []V1, f convert[V1, V2]) []V2 {
 	newList := make([]V2, len(list))

@ -55,3 +50,19 @@ func Map[V1 any, V2 any](list []V1, f convert[V1, V2]) []V2 {

 	return newList
 }
+
+type filterFunc[V any] func(V) bool
+
+// Filter filters out elements given a filter function.
+// If filter function is true keep it in otherwise leave it out
+func Filter[V any](list []V, f filterFunc[V]) []V {
+	newList := make([]V, 0)
+
+	for _, elem := range list {
+		if f(elem) {
+			newList = append(newList, elem)
+		}
+	}
+
+	return newList
+}
--- a/pkg/lib/conv_test.go
+++ b/pkg/lib/conv_test.go
@ -0,0 +1,144 @@
+package lib
+
+import (
+	"slices"
+	"testing"
+)
+
+func stringToInt(input string) int {
+	return len(input)
+}
+
+func intDiv(input int) int {
+	return input / 2
+}
+
+func TestMapValuesMapsValues(t *testing.T) {
+	values := []int{1, 4, 11, 92}
+	var theMap map[string]int = map[string]int{
+		"mynameisjeff": values[0],
+		"tim":          values[1],
+		"bob":          values[2],
+		"derek":        values[3],
+	}
+
+	mapValues := MapValues(theMap)
+
+	for _, elem := range mapValues {
+		if !slices.Contains(values, elem) {
+			t.Fatalf(`%d is not an expected value`, elem)
+		}
+	}
+
+	if len(mapValues) != len(theMap) {
+		t.Fatalf(`Expected length %d got %d`, len(theMap), len(mapValues))
+	}
+}
+
+func TestMapValuesWithExcludeExcludesValues(t *testing.T) {
+	values := []int{1, 9, 22}
+	var theMap map[string]int = map[string]int{
+		"mynameisbob": values[0],
+		"tim":         values[1],
+		"bob":         values[2],
+	}
+
+	exclude := map[string]struct{}{
+		"tim": {},
+	}
+
+	mapValues := MapValuesWithExclude(theMap, exclude)
+
+	if slices.Contains(mapValues, values[1]) {
+		t.Fatalf(`Failed to exclude expected value`)
+	}
+
+	if len(mapValues) != 2 {
+		t.Fatalf(`Incorrect expected length`)
+	}
+
+	for _, value := range theMap {
+		if !slices.Contains(values, value) {
+			t.Fatalf(`Element does not exist in the list of
+				expected values`)
+		}
+	}
+}
+
+func TestMapKeys(t *testing.T) {
+	keys := []string{"1", "2", "3"}
+
+	theMap := map[string]int{
+		keys[0]: 1,
+		keys[1]: 2,
+		keys[2]: 3,
+	}
+
+	mapKeys := MapKeys(theMap)
+
+	for _, elem := range mapKeys {
+		if !slices.Contains(keys, elem) {
+			t.Fatalf(`%s elem is not an expected key`, elem)
+		}
+	}
+
+	if len(mapKeys) != len(theMap) {
+		t.Fatalf(`Missing expected values`)
+	}
+}
+
+func TestMapValues(t *testing.T) {
+	array := []string{"mynameisjeff", "tim", "bob", "derek"}
+
+	intArray := Map(array, stringToInt)
+
+	for index, elem := range intArray {
+		if len(array[index]) != elem {
+			t.Fatalf(`Have %d want %d`, elem, len(array[index]))
+		}
+	}
+}
+
+func TestFilterFilterAll(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+
+	filterFunc := func(n int) bool {
+		return false
+	}
+
+	newValues := Filter(values, filterFunc)
+
+	if len(newValues) != 0 {
+		t.Fatalf(`Expected value was 0`)
+	}
+}
+
+func TestFilterFilterNone(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+
+	filterFunc := func(n int) bool {
+		return true
+	}
+
+	newValues := Filter(values, filterFunc)
+
+	if !slices.Equal(values, newValues) {
+		t.Fatalf(`Expected lists to be the same`)
+	}
+}
+
+func TestFilterFilterSome(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+
+	filterFunc := func(n int) bool {
+		return n < 3
+	}
+
+	expected := []int{1, 2}
+
+	actual := Filter(values, filterFunc)
+
+	if !slices.Equal(expected, actual) {
+		t.Fatalf(`Expected expected and actual to be the same`)
+	}
+}
--- a/pkg/lib/random.go
+++ b/pkg/lib/random.go
@ -1,6 +1,8 @@
 package lib

-import "math/rand"
+import (
+	"math/rand"
+)

 // RandomSubsetOfLength: Given an array of nodes generate of random
 // subset of 'num' length.
@ -17,6 +19,7 @@ func RandomSubsetOfLength[V any](vs []V, num int) []V {

 		if _, ok := selectedIndices[randomIndex]; !ok {
 			randomSubset = append(randomSubset, vs[randomIndex])
+			selectedIndices[randomIndex] = struct{}{}
 			i++
 		}
 	}
--- a/pkg/lib/random_test.go
+++ b/pkg/lib/random_test.go
@ -0,0 +1,46 @@
+package lib
+
+import (
+	"slices"
+	"testing"
+)
+
+// Test that a random subset of length 0 produces a zero length
+// list
+func TestRandomSubsetOfLength0(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5, 6, 7, 8}
+	randomValues := RandomSubsetOfLength(values, 0)
+
+	if len(randomValues) != 0 {
+		t.Fatalf(`Expected length to be 0`)
+	}
+}
+
+func TestRandomSubsetOfLength1(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+
+	randomValues := RandomSubsetOfLength(values, 1)
+
+	if len(randomValues) != 1 {
+		t.Fatalf(`Expected length to be 1`)
+	}
+
+	if !slices.Contains(values, randomValues[0]) {
+		t.Fatalf(`Expected length to be 1`)
+	}
+}
+
+func TestRandomSubsetEntireList(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	randomValues := RandomSubsetOfLength(values, len(values))
+
+	if len(randomValues) != len(values) {
+		t.Fatalf(`Expected length to be %d was %d`, len(values), len(randomValues))
+	}
+
+	slices.Sort(randomValues)
+
+	if !slices.Equal(values, randomValues) {
+		t.Fatalf(`Expected slices to be equal`)
+	}
+}
--- a/pkg/lib/rtnetlink.go
+++ b/pkg/lib/rtnetlink.go
@ -0,0 +1,300 @@
+package lib
+
+import (
+	"encoding/binary"
+	"fmt"
+	"net"
+
+	"github.com/jsimonetti/rtnetlink"
+	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"golang.org/x/sys/unix"
+)
+
+type RtNetlinkConfig struct {
+	conn *rtnetlink.Conn
+}
+
+func NewRtNetlinkConfig() (*RtNetlinkConfig, error) {
+	conn, err := rtnetlink.Dial(nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &RtNetlinkConfig{conn: conn}, nil
+}
+
+const WIREGUARD_MTU = 1420
+
+// Create a netlink interface if it does not exist. ifName is the name of the netlink interface
+func (c *RtNetlinkConfig) CreateLink(ifName string) error {
+	_, err := net.InterfaceByName(ifName)
+
+	if err == nil {
+		return fmt.Errorf("interface %s already exists", ifName)
+	}
+
+	err = c.conn.Link.New(&rtnetlink.LinkMessage{
+		Family: unix.AF_UNSPEC,
+		Flags:  unix.IFF_UP,
+		Attributes: &rtnetlink.LinkAttributes{
+			Name: ifName,
+			Info: &rtnetlink.LinkInfo{Kind: "wireguard"},
+			MTU:  uint32(WIREGUARD_MTU),
+		},
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to create wireguard interface: %w", err)
+	}
+
+	return nil
+}
+
+// Delete link delete the specified interface
+func (c *RtNetlinkConfig) DeleteLink(ifName string) error {
+	iface, err := net.InterfaceByName(ifName)
+
+	if err != nil {
+		return fmt.Errorf("failed to get interface %s %w", ifName, err)
+	}
+
+	err = c.conn.Link.Delete(uint32(iface.Index))
+
+	if err != nil {
+		return fmt.Errorf("failed to delete wg interface %w", err)
+	}
+
+	return nil
+}
+
+// AddAddress adds an address to the given interface.
+func (c *RtNetlinkConfig) AddAddress(ifName string, address string) error {
+	iface, err := net.InterfaceByName(ifName)
+
+	if err != nil {
+		return fmt.Errorf("failed to get interface %s error: %w", ifName, err)
+	}
+
+	addr, cidr, err := net.ParseCIDR(address)
+
+	if err != nil {
+		return fmt.Errorf("failed to parse CIDR %s error: %w", addr, err)
+	}
+
+	family := unix.AF_INET6
+
+	ipv4 := cidr.IP.To4()
+
+	if ipv4 != nil {
+		family = unix.AF_INET
+	}
+
+	// Calculate the prefix length
+	ones, _ := cidr.Mask.Size()
+
+	// Calculate the broadcast IP
+	// Only used when family is AF_INET
+	var brd net.IP
+	if ipv4 != nil {
+		brd = make(net.IP, len(ipv4))
+		binary.BigEndian.PutUint32(brd, binary.BigEndian.Uint32(ipv4)|^binary.BigEndian.Uint32(net.IP(cidr.Mask).To4()))
+	}
+
+	err = c.conn.Address.New(&rtnetlink.AddressMessage{
+		Family:       uint8(family),
+		PrefixLength: uint8(ones),
+		Scope:        unix.RT_SCOPE_UNIVERSE,
+		Index:        uint32(iface.Index),
+		Attributes: &rtnetlink.AddressAttributes{
+			Address:   addr,
+			Local:     addr,
+			Broadcast: brd,
+		},
+	})
+
+	if err != nil {
+		err = fmt.Errorf("failed to add address to link %w", err)
+	}
+
+	return err
+}
+
+// AddRoute: adds a route to the routing table.
+// ifName is the intrface to add the route to
+// gateway is the IP of the gateway device to hop to
+// dst is the network prefix of the advertised destination
+func (c *RtNetlinkConfig) AddRoute(ifName string, route Route) error {
+	iface, err := net.InterfaceByName(ifName)
+
+	if err != nil {
+		return fmt.Errorf("failed accessing interface %s error %w", ifName, err)
+	}
+
+	gw := route.Gateway
+	dst := route.Destination
+
+	var family uint8 = unix.AF_INET6
+
+	if dst.IP.To4() != nil {
+		family = unix.AF_INET
+	}
+
+	attr := rtnetlink.RouteAttributes{
+		Dst:      dst.IP,
+		OutIface: uint32(iface.Index),
+		Gateway:  gw,
+	}
+
+	ones, _ := dst.Mask.Size()
+
+	err = c.conn.Route.Replace(&rtnetlink.RouteMessage{
+		Family:     family,
+		Table:      unix.RT_TABLE_MAIN,
+		Protocol:   unix.RTPROT_BOOT,
+		Scope:      unix.RT_SCOPE_LINK,
+		Type:       unix.RTN_UNICAST,
+		DstLength:  uint8(ones),
+		Attributes: attr,
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to add route %w", err)
+	}
+
+	return nil
+}
+
+// DeleteRoute deletes routes with the gateway and destination
+func (c *RtNetlinkConfig) DeleteRoute(ifName string, route Route) error {
+	iface, err := net.InterfaceByName(ifName)
+
+	if err != nil {
+		return fmt.Errorf("failed accessing interface %s error %w", ifName, err)
+	}
+
+	gw := route.Gateway
+	dst := route.Destination
+
+	var family uint8 = unix.AF_INET6
+
+	if dst.IP.To4() != nil {
+		family = unix.AF_INET
+	}
+
+	attr := rtnetlink.RouteAttributes{
+		Dst:      dst.IP,
+		OutIface: uint32(iface.Index),
+		Gateway:  gw,
+	}
+
+	ones, _ := dst.Mask.Size()
+
+	err = c.conn.Route.Delete(&rtnetlink.RouteMessage{
+		Family:     family,
+		Table:      unix.RT_TABLE_MAIN,
+		Protocol:   unix.RTPROT_BOOT,
+		Scope:      unix.RT_SCOPE_LINK,
+		Type:       unix.RTN_UNICAST,
+		DstLength:  uint8(ones),
+		Attributes: attr,
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to delete route %w", err)
+	}
+
+	return nil
+}
+
+type Route struct {
+	Gateway     net.IP
+	Destination net.IPNet
+}
+
+func (r1 Route) equal(r2 Route) bool {
+	return r1.Gateway.String() == r2.Gateway.String() &&
+		r1.Destination.String() == r2.Destination.String()
+}
+
+// DeleteRoutes deletes all routes not in exclude
+func (c *RtNetlinkConfig) DeleteRoutes(ifName string, family uint8, exclude ...Route) error {
+	routes := make([]rtnetlink.RouteMessage, 0)
+
+	if len(exclude) != 0 {
+		lRoutes, err := c.listRoutes(ifName, family, exclude[0].Gateway)
+
+		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 {
+			maskSize = 32
+		}
+
+		cidr := net.CIDRMask(int(rtRoute.DstLength), maskSize)
+		route := Route{
+			Gateway:     rtRoute.Attributes.Gateway,
+			Destination: net.IPNet{IP: rtRoute.Attributes.Dst, Mask: cidr},
+		}
+
+		ifRoutes = append(ifRoutes, route)
+	}
+
+	shouldExclude := func(r Route) bool {
+		for _, route := range exclude {
+			if route.equal(r) {
+				return false
+			}
+		}
+		return true
+	}
+
+	toDelete := Filter(ifRoutes, shouldExclude)
+
+	for _, route := range toDelete {
+		logging.Log.WriteInfof("Deleting route %s", route.Destination.String())
+		err := c.DeleteRoute(ifName, route)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// listRoutes lists all routes on the interface
+func (c *RtNetlinkConfig) listRoutes(ifName string, family uint8, gateway net.IP) ([]rtnetlink.RouteMessage, error) {
+	iface, err := net.InterfaceByName(ifName)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed accessing interface %s error %w", ifName, err)
+	}
+
+	routes, err := c.conn.Route.List()
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to get route %w", err)
+	}
+
+	filterFunc := func(r rtnetlink.RouteMessage) bool {
+		return r.Attributes.Gateway.Equal(gateway) && r.Attributes.OutIface == uint32(iface.Index)
+	}
+
+	routes = Filter(routes, filterFunc)
+	return routes, nil
+}
+
+func (c *RtNetlinkConfig) Close() error {
+	return c.conn.Close()
+}
--- a/pkg/lib/timer.go
+++ b/pkg/lib/timer.go
@ -0,0 +1,42 @@
+package lib
+
+import "time"
+
+type TimerFunc = func() error
+
+type Timer struct {
+	f          TimerFunc
+	quit       chan struct{}
+	updateRate int
+}
+
+func (t *Timer) Run() error {
+	ticker := time.NewTicker(time.Duration(t.updateRate) * time.Second)
+
+	t.quit = make(chan struct{})
+
+	for {
+		select {
+		case <-ticker.C:
+			err := t.f()
+
+			if err != nil {
+				return err
+			}
+		case <-t.quit:
+			break
+		}
+	}
+}
+
+func (t *Timer) Stop() error {
+	close(t.quit)
+	return nil
+}
+
+func NewTimer(f TimerFunc, updateRate int) *Timer {
+	return &Timer{
+		f:          f,
+		updateRate: updateRate,
+	}
+}
--- a/pkg/mesh/config.go
+++ b/pkg/mesh/config.go
@ -1,6 +1,7 @@
 package mesh

 import (
+	"fmt"
 	"net"

 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
@ -9,14 +10,16 @@ import (
 // MeshConfigApplyer abstracts applying the mesh configuration
 type MeshConfigApplyer interface {
 	ApplyConfig() error
+	RemovePeers(meshId string) error
+	SetMeshManager(manager MeshManager)
 }

 // WgMeshConfigApplyer applies WireGuard configuration
 type WgMeshConfigApplyer struct {
-	meshManager *MeshManager
+	meshManager MeshManager
 }

-func ConvertMeshNode(node MeshNode) (*wgtypes.PeerConfig, error) {
+func convertMeshNode(node MeshNode) (*wgtypes.PeerConfig, error) {
 	endpoint, err := net.ResolveUDPAddr("udp", node.GetWgEndpoint())

 	if err != nil {
@ -59,7 +62,7 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 	var count int = 0

 	for _, n := range nodes {
-		peer, err := ConvertMeshNode(n)
+		peer, err := convertMeshNode(n)

 		if err != nil {
 			return err
@ -70,8 +73,7 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 	}

 	cfg := wgtypes.Config{
-		Peers:        peerConfigs,
-		ReplacePeers: true,
+		Peers: peerConfigs,
 	}

 	dev, err := mesh.GetDevice()
@ -80,11 +82,11 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 		return err
 	}

-	return m.meshManager.Client.ConfigureDevice(dev.Name, cfg)
+	return m.meshManager.GetClient().ConfigureDevice(dev.Name, cfg)
 }

 func (m *WgMeshConfigApplyer) ApplyConfig() error {
-	for _, mesh := range m.meshManager.Meshes {
+	for _, mesh := range m.meshManager.GetMeshes() {
 		err := m.updateWgConf(mesh)

 		if err != nil {
@ -95,6 +97,31 @@ func (m *WgMeshConfigApplyer) ApplyConfig() error {
 	return nil
 }

-func NewWgMeshConfigApplyer(manager *MeshManager) MeshConfigApplyer {
-	return &WgMeshConfigApplyer{meshManager: manager}
+func (m *WgMeshConfigApplyer) RemovePeers(meshId string) error {
+	mesh := m.meshManager.GetMesh(meshId)
+
+	if mesh == nil {
+		return fmt.Errorf("mesh %s does not exist", meshId)
+	}
+
+	dev, err := mesh.GetDevice()
+
+	if err != nil {
+		return err
+	}
+
+	m.meshManager.GetClient().ConfigureDevice(dev.Name, wgtypes.Config{
+		ReplacePeers: true,
+		Peers:        make([]wgtypes.PeerConfig, 1),
+	})
+
+	return nil
+}
+
+func (m *WgMeshConfigApplyer) SetMeshManager(manager MeshManager) {
+	m.meshManager = manager
+}
+
+func NewWgMeshConfigApplyer() MeshConfigApplyer {
+	return &WgMeshConfigApplyer{}
 }
--- a/pkg/mesh/graph.go
+++ b/pkg/mesh/graph.go
@ -15,7 +15,7 @@ type MeshGraphConverter interface {
 }

 type MeshDOTConverter struct {
-	manager *MeshManager
+	manager MeshManager
 }

 func (c *MeshDOTConverter) Generate(meshId string) (string, error) {
@ -34,7 +34,7 @@ func (c *MeshDOTConverter) Generate(meshId string) (string, error) {
 	}

 	for _, node := range snapshot.GetNodes() {
-		c.graphNode(g, node)
+		c.graphNode(g, node, meshId)
 	}

 	nodes := lib.MapValues(snapshot.GetNodes())
@ -55,11 +55,13 @@ func (c *MeshDOTConverter) Generate(meshId string) (string, error) {
 }

 // graphNode: graphs a node within the mesh
-func (c *MeshDOTConverter) graphNode(g *graph.Graph, node MeshNode) {
+func (c *MeshDOTConverter) graphNode(g *graph.Graph, node MeshNode, meshId string) {
 	nodeId := fmt.Sprintf("\"%s\"", node.GetIdentifier())
 	g.PutNode(nodeId, graph.CIRCLE)

-	if node.GetHostEndpoint() == c.manager.HostParameters.HostEndpoint {
+	self, _ := c.manager.GetSelf(meshId)
+
+	if node.GetHostEndpoint() == self.GetHostEndpoint() {
 		return
 	}

@ -70,6 +72,6 @@ func (c *MeshDOTConverter) graphNode(g *graph.Graph, node MeshNode) {
 	}
 }

-func NewMeshDotConverter(m *MeshManager) MeshGraphConverter {
+func NewMeshDotConverter(m MeshManager) MeshGraphConverter {
 	return &MeshDOTConverter{manager: m}
 }
--- a/pkg/mesh/manager.go
+++ b/pkg/mesh/manager.go
@ -13,7 +13,26 @@ import (
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

-type MeshManager struct {
+type MeshManager interface {
+	CreateMesh(devName string, port int) (string, error)
+	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
+	GetSelf(meshId string) (MeshNode, error)
+	ApplyConfig() error
+	SetDescription(description string) error
+	UpdateTimeStamp() error
+	GetClient() *wgctrl.Client
+	GetMeshes() map[string]MeshProvider
+	Prune() error
+	Close() error
+}
+
+type MeshManagerImpl struct {
 	Meshes       map[string]MeshProvider
 	RouteManager RouteManager
 	Client       *wgctrl.Client
@ -29,8 +48,21 @@ type MeshManager struct {
 	interfaceManipulator wg.WgInterfaceManipulator
 }

+// Prune implements MeshManager.
+func (m *MeshManagerImpl) Prune() error {
+	for _, mesh := range m.Meshes {
+		err := mesh.Prune(m.conf.PruneTime)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // CreateMesh: Creates a new mesh, stores it and returns the mesh id
-func (m *MeshManager) CreateMesh(devName string, port int) (string, error) {
+func (m *MeshManagerImpl) CreateMesh(devName string, port int) (string, error) {
 	meshId, err := m.idGenerator.GetId()

 	if err != nil {
@ -46,14 +78,20 @@ func (m *MeshManager) CreateMesh(devName string, port int) (string, error) {
 	})

 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("error creating mesh: %w", err)
 	}

-	m.Meshes[meshId] = nodeManager
-	return meshId, m.interfaceManipulator.CreateInterface(&wg.CreateInterfaceParams{
+	err = m.interfaceManipulator.CreateInterface(&wg.CreateInterfaceParams{
 		IfName: devName,
 		Port:   port,
 	})
+
+	if err != nil {
+		return "", fmt.Errorf("error creating mesh: %w", err)
+	}
+
+	m.Meshes[meshId] = nodeManager
+	return meshId, nil
 }

 type AddMeshParams struct {
@ -64,7 +102,7 @@ type AddMeshParams struct {
 }

 // AddMesh: Add the mesh to the list of meshes
-func (m *MeshManager) AddMesh(params *AddMeshParams) error {
+func (m *MeshManagerImpl) AddMesh(params *AddMeshParams) error {
 	meshProvider, err := m.meshProviderFactory.CreateMesh(&MeshProviderFactoryParams{
 		DevName: params.DevName,
 		Port:    params.WgPort,
@ -92,47 +130,35 @@ func (m *MeshManager) AddMesh(params *AddMeshParams) error {
 }

 // HasChanges returns true if the mesh has changes
-func (m *MeshManager) HasChanges(meshId string) bool {
+func (m *MeshManagerImpl) HasChanges(meshId string) bool {
 	return m.Meshes[meshId].HasChanges()
 }

 // GetMesh returns the mesh with the given meshid
-func (m *MeshManager) GetMesh(meshId string) MeshProvider {
-	theMesh, _ := m.Meshes[meshId]
+func (m *MeshManagerImpl) GetMesh(meshId string) MeshProvider {
+	theMesh := m.Meshes[meshId]
 	return theMesh
 }

 // EnableInterface: Enables the given WireGuard interface.
-func (s *MeshManager) EnableInterface(meshId string) error {
+func (s *MeshManagerImpl) EnableInterface(meshId string) error {
 	err := s.configApplyer.ApplyConfig()

 	if err != nil {
 		return err
 	}

-	meshNode, err := s.GetSelf(meshId)
+	err = s.RouteManager.InstallRoutes()

 	if err != nil {
 		return err
 	}

-	mesh := s.GetMesh(meshId)
-
-	if err != nil {
-		return err
-	}
-
-	dev, err := mesh.GetDevice()
-
-	if err != nil {
-		return err
-	}
-
-	return s.interfaceManipulator.EnableInterface(dev.Name, meshNode.GetWgHost().String())
+	return nil
 }

 // GetPublicKey: Gets the public key of the WireGuard mesh
-func (s *MeshManager) GetPublicKey(meshId string) (*wgtypes.Key, error) {
+func (s *MeshManagerImpl) GetPublicKey(meshId string) (*wgtypes.Key, error) {
 	mesh, ok := s.Meshes[meshId]

 	if !ok {
@ -159,7 +185,13 @@ type AddSelfParams struct {
 }

 // AddSelf adds this host to the mesh
-func (s *MeshManager) AddSelf(params *AddSelfParams) error {
+func (s *MeshManagerImpl) AddSelf(params *AddSelfParams) error {
+	mesh := s.GetMesh(params.MeshId)
+
+	if mesh == nil {
+		return fmt.Errorf("addself: mesh %s does not exist", params.MeshId)
+	}
+
 	pubKey, err := s.GetPublicKey(params.MeshId)

 	if err != nil {
@ -179,28 +211,52 @@ func (s *MeshManager) AddSelf(params *AddSelfParams) error {
 		Endpoint:  params.Endpoint,
 	})

+	device, err := mesh.GetDevice()
+
+	if err != nil {
+		return fmt.Errorf("failed to get device %w", err)
+	}
+
+	err = s.interfaceManipulator.AddAddress(device.Name, fmt.Sprintf("%s/64", nodeIP))
+
+	if err != nil {
+		return fmt.Errorf("addSelf: failed to add address to dev %w", err)
+	}
+
 	s.Meshes[params.MeshId].AddNode(node)
 	return s.RouteManager.UpdateRoutes()
 }

 // LeaveMesh leaves the mesh network
-func (s *MeshManager) LeaveMesh(meshId string) error {
-	_, exists := s.Meshes[meshId]
+func (s *MeshManagerImpl) LeaveMesh(meshId string) error {
+	mesh, exists := s.Meshes[meshId]

 	if !exists {
-		return errors.New(fmt.Sprintf("mesh %s does not exist", meshId))
+		return fmt.Errorf("mesh %s does not exist", meshId)
 	}

-	// For now just delete the mesh with the ID.
+	err := s.RouteManager.RemoveRoutes(meshId)
+
+	if err != nil {
+		return err
+	}
+
+	device, err := mesh.GetDevice()
+
+	if err != nil {
+		return err
+	}
+
+	err = s.interfaceManipulator.RemoveInterface(device.Name)
 	delete(s.Meshes, meshId)
-	return nil
+	return err
 }

-func (s *MeshManager) GetSelf(meshId string) (MeshNode, error) {
+func (s *MeshManagerImpl) GetSelf(meshId string) (MeshNode, error) {
 	meshInstance, ok := s.Meshes[meshId]

 	if !ok {
-		return nil, errors.New(fmt.Sprintf("mesh %s does not exist", meshId))
+		return nil, fmt.Errorf("mesh %s does not exist", meshId)
 	}

 	snapshot, err := meshInstance.GetMesh()
@ -218,8 +274,30 @@ func (s *MeshManager) GetSelf(meshId string) (MeshNode, error) {
 	return node, nil
 }

+func (s *MeshManagerImpl) ApplyConfig() error {
+	err := s.configApplyer.ApplyConfig()
+
+	if err != nil {
+		return err
+	}
+
+	return s.RouteManager.InstallRoutes()
+}
+
+func (s *MeshManagerImpl) SetDescription(description string) error {
+	for _, mesh := range s.Meshes {
+		err := mesh.SetDescription(s.HostParameters.HostEndpoint, description)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // UpdateTimeStamp updates the timestamp of this node in all meshes
-func (s *MeshManager) UpdateTimeStamp() error {
+func (s *MeshManagerImpl) UpdateTimeStamp() error {
 	for _, mesh := range s.Meshes {
 		snapshot, err := mesh.GetMesh()

@ -241,6 +319,32 @@ func (s *MeshManager) UpdateTimeStamp() error {
 	return nil
 }

+func (s *MeshManagerImpl) GetClient() *wgctrl.Client {
+	return s.Client
+}
+
+func (s *MeshManagerImpl) GetMeshes() map[string]MeshProvider {
+	return s.Meshes
+}
+
+func (s *MeshManagerImpl) Close() error {
+	for _, mesh := range s.Meshes {
+		dev, err := mesh.GetDevice()
+
+		if err != nil {
+			return err
+		}
+
+		err = s.interfaceManipulator.RemoveInterface(dev.Name)
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // NewMeshManagerParams params required to create an instance of a mesh manager
 type NewMeshManagerParams struct {
 	Conf                 conf.WgMeshConfiguration
@ -250,10 +354,12 @@ type NewMeshManagerParams struct {
 	IdGenerator          lib.IdGenerator
 	IPAllocator          ip.IPAllocator
 	InterfaceManipulator wg.WgInterfaceManipulator
+	ConfigApplyer        MeshConfigApplyer
+	RouteManager         RouteManager
 }

 // Creates a new instance of a mesh manager with the given parameters
-func NewMeshManager(params *NewMeshManagerParams) *MeshManager {
+func NewMeshManager(params *NewMeshManagerParams) *MeshManagerImpl {
 	hostParams := HostParameters{}

 	switch params.Conf.Endpoint {
@ -265,7 +371,7 @@ func NewMeshManager(params *NewMeshManagerParams) *MeshManager {

 	logging.Log.WriteInfof("Endpoint %s", hostParams.HostEndpoint)

-	m := &MeshManager{
+	m := &MeshManagerImpl{
 		Meshes:              make(map[string]MeshProvider),
 		HostParameters:      &hostParams,
 		meshProviderFactory: params.MeshProvider,
@ -273,8 +379,14 @@ func NewMeshManager(params *NewMeshManagerParams) *MeshManager {
 		Client:              params.Client,
 		conf:                &params.Conf,
 	}
-	m.configApplyer = NewWgMeshConfigApplyer(m)
-	m.RouteManager = NewRouteManager(m)
+
+	m.configApplyer = params.ConfigApplyer
+	m.RouteManager = params.RouteManager
+
+	if m.RouteManager == nil {
+		m.RouteManager = NewRouteManager(m)
+	}
+
 	m.idGenerator = params.IdGenerator
 	m.ipAllocator = params.IPAllocator
 	m.interfaceManipulator = params.InterfaceManipulator
--- a/pkg/mesh/manager_test.go
+++ b/pkg/mesh/manager_test.go
@ -0,0 +1,247 @@
+package mesh
+
+import (
+	"testing"
+
+	"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/wg"
+)
+
+func getMeshConfiguration() *conf.WgMeshConfiguration {
+	return &conf.WgMeshConfiguration{
+		GrpcPort:           "8080",
+		Endpoint:           "abc.com",
+		ClusterSize:        64,
+		SyncRate:           4,
+		BranchRate:         3,
+		InterClusterChance: 0.15,
+		InfectionCount:     2,
+		KeepAliveTime:      60,
+	}
+}
+
+func getMeshManager() *MeshManagerImpl {
+	manager := NewMeshManager(&NewMeshManagerParams{
+		Conf:                 *getMeshConfiguration(),
+		Client:               nil,
+		MeshProvider:         &StubMeshProviderFactory{},
+		NodeFactory:          &StubNodeFactory{Config: getMeshConfiguration()},
+		IdGenerator:          &lib.UUIDGenerator{},
+		IPAllocator:          &ip.ULABuilder{},
+		InterfaceManipulator: &wg.WgInterfaceManipulatorStub{},
+		ConfigApplyer:        &MeshConfigApplyerStub{},
+		RouteManager:         &RouteManagerStub{},
+	})
+
+	return manager
+}
+
+func TestCreateMeshCreatesANewMeshProvider(t *testing.T) {
+	manager := getMeshManager()
+
+	meshId, err := manager.CreateMesh("wg0", 5000)
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(meshId) == 0 {
+		t.Fatal(`meshId should not be empty`)
+	}
+
+	_, exists := manager.Meshes[meshId]
+
+	if !exists {
+		t.Fatal(`mesh was not created when it should be`)
+	}
+}
+
+func TestAddMeshAddsAMesh(t *testing.T) {
+	manager := getMeshManager()
+	meshId := "meshid123"
+
+	manager.AddMesh(&AddMeshParams{
+		MeshId:    meshId,
+		DevName:   "wg0",
+		WgPort:    6000,
+		MeshBytes: make([]byte, 0),
+	})
+
+	mesh := manager.GetMesh(meshId)
+
+	if mesh == nil || mesh.GetMeshId() != meshId {
+		t.Fatalf(`mesh has not been added to the list of meshes`)
+	}
+}
+
+func TestAddMeshMeshAlreadyExistsReplacesIt(t *testing.T) {
+	manager := getMeshManager()
+	meshId := "meshid123"
+
+	for i := 0; i < 2; i++ {
+		err := manager.AddMesh(&AddMeshParams{
+			MeshId:    meshId,
+			DevName:   "wg0",
+			WgPort:    6000,
+			MeshBytes: make([]byte, 0),
+		})
+
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	mesh := manager.GetMesh(meshId)
+
+	if mesh == nil || mesh.GetMeshId() != meshId {
+		t.Fatalf(`mesh has not been added to the list of meshes`)
+	}
+}
+
+func TestAddSelfAddsSelfToTheMesh(t *testing.T) {
+	manager := getMeshManager()
+	meshId := "meshid123"
+
+	err := manager.AddMesh(&AddMeshParams{
+		MeshId:    meshId,
+		DevName:   "wg0",
+		WgPort:    6000,
+		MeshBytes: make([]byte, 0),
+	})
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId,
+		WgPort:   5000,
+		Endpoint: "abc.com",
+	})
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	mesh, err := manager.GetMesh(meshId).GetMesh()
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, ok := mesh.GetNodes()["abc.com"]
+
+	if !ok {
+		t.Fatalf(`node has not been added`)
+	}
+}
+
+func TestAddSelfToMeshAlreadyInMesh(t *testing.T) {
+	TestAddSelfAddsSelfToTheMesh(t)
+	TestAddSelfAddsSelfToTheMesh(t)
+}
+
+func TestAddSelfToMeshMeshDoesNotExist(t *testing.T) {
+	manager := getMeshManager()
+	meshId := "meshid123"
+
+	err := manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId,
+		WgPort:   5000,
+		Endpoint: "abc.com",
+	})
+
+	if err == nil {
+		t.Fatalf(`Expected error to be thrown`)
+	}
+}
+
+func TestLeaveMeshMeshDoesNotExist(t *testing.T) {
+	manager := getMeshManager()
+	meshId := "meshid123"
+
+	err := manager.LeaveMesh(meshId)
+
+	if err == nil {
+		t.Fatalf(`Expected error to be thrown`)
+	}
+}
+
+func TestLeaveMeshDeletesMesh(t *testing.T) {
+	manager := getMeshManager()
+	meshId := "meshid123"
+
+	err := manager.AddMesh(&AddMeshParams{
+		MeshId:    meshId,
+		DevName:   "wg0",
+		WgPort:    6000,
+		MeshBytes: make([]byte, 0),
+	})
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = manager.LeaveMesh(meshId)
+
+	if err != nil {
+		t.Fatalf("%s", err.Error())
+	}
+
+	_, exists := manager.Meshes[meshId]
+
+	if exists {
+		t.Fatalf(`expected mesh to have been deleted`)
+	}
+}
+
+func TestSetDescription(t *testing.T) {
+	manager := getMeshManager()
+	description := "wooooo"
+
+	meshId1, _ := manager.CreateMesh("wg0", 5000)
+	meshId2, _ := manager.CreateMesh("wg0", 5001)
+
+	manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId1,
+		WgPort:   5000,
+		Endpoint: "abc.com:8080",
+	})
+	manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId2,
+		WgPort:   5000,
+		Endpoint: "abc.com:8080",
+	})
+
+	err := manager.SetDescription(description)
+
+	if err != nil {
+		t.Fatalf(`failed to set the descriptions`)
+	}
+}
+
+func TestUpdateTimeStampUpdatesAllMeshes(t *testing.T) {
+	manager := getMeshManager()
+
+	meshId1, _ := manager.CreateMesh("wg0", 5000)
+	meshId2, _ := manager.CreateMesh("wg0", 5001)
+
+	manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId1,
+		WgPort:   5000,
+		Endpoint: "abc.com:8080",
+	})
+	manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId2,
+		WgPort:   5000,
+		Endpoint: "abc.com:8080",
+	})
+
+	err := manager.UpdateTimeStamp()
+
+	if err != nil {
+		t.Fatalf(`failed to update the timestamp`)
+	}
+}
--- a/pkg/mesh/pruner.go
+++ b/pkg/mesh/pruner.go
@ -0,0 +1,16 @@
+package mesh
+
+import (
+	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
+)
+
+func pruneFunction(m MeshManager) lib.TimerFunc {
+	return func() error {
+		return m.Prune()
+	}
+}
+
+func NewPruner(m MeshManager, conf conf.WgMeshConfiguration) *lib.Timer {
+	return lib.NewTimer(pruneFunction(m), conf.PruneTime/2)
+}
--- a/pkg/mesh/route.go
+++ b/pkg/mesh/route.go
@ -1,22 +1,29 @@
 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 {
-	meshes := r.meshManager.Meshes
+	meshes := r.meshManager.GetMeshes()
 	ulaBuilder := new(ip.ULABuilder)

 	for _, mesh1 := range meshes {
@ -32,7 +39,13 @@ func (r *RouteManagerImpl) UpdateRoutes() error {
 				return err
 			}

-			err = mesh1.AddRoutes(r.meshManager.HostParameters.HostEndpoint, ipNet.String())
+			self, err := r.meshManager.GetSelf(mesh1.GetMeshId())
+
+			if err != nil {
+				return err
+			}
+
+			err = mesh1.AddRoutes(self.GetHostEndpoint(), ipNet.String())

 			if err != nil {
 				return err
@ -43,6 +56,129 @@ func (r *RouteManagerImpl) UpdateRoutes() error {
 	return nil
 }

-func NewRouteManager(m *MeshManager) RouteManager {
+// removeRoutes: removes all meshes we are no longer a part of
+func (r *RouteManagerImpl) RemoveRoutes(meshId string) error {
+	ulaBuilder := new(ip.ULABuilder)
+	meshes := r.meshManager.GetMeshes()
+
+	ipNet, err := ulaBuilder.GetIPNet(meshId)
+
+	if err != nil {
+		return err
+	}
+
+	for _, mesh1 := range meshes {
+		self, err := r.meshManager.GetSelf(meshId)
+
+		if err != nil {
+			return err
+		}
+
+		mesh1.RemoveRoutes(self.GetHostEndpoint(), 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()}
 }
--- a/pkg/mesh/route_stub.go
+++ b/pkg/mesh/route_stub.go
@ -0,0 +1,16 @@
+package mesh
+
+type RouteManagerStub struct {
+}
+
+func (r *RouteManagerStub) UpdateRoutes() error {
+	return nil
+}
+
+func (r *RouteManagerStub) InstallRoutes() error {
+	return nil
+}
+
+func (r *RouteManagerStub) RemoveRoutes(meshId string) error {
+	return nil
+}
--- a/pkg/mesh/stub_types.go
+++ b/pkg/mesh/stub_types.go
@ -0,0 +1,250 @@
+package mesh
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"golang.zx2c4.com/wireguard/wgctrl"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
+)
+
+type MeshNodeStub struct {
+	hostEndpoint string
+	publicKey    wgtypes.Key
+	wgEndpoint   string
+	wgHost       *net.IPNet
+	timeStamp    int64
+	routes       []string
+	identifier   string
+	description  string
+}
+
+func (m *MeshNodeStub) GetHostEndpoint() string {
+	return m.hostEndpoint
+}
+
+func (m *MeshNodeStub) GetPublicKey() (wgtypes.Key, error) {
+	return m.publicKey, nil
+}
+
+func (m *MeshNodeStub) GetWgEndpoint() string {
+	return m.wgEndpoint
+}
+
+func (m *MeshNodeStub) GetWgHost() *net.IPNet {
+	return m.wgHost
+}
+
+func (m *MeshNodeStub) GetTimeStamp() int64 {
+	return m.timeStamp
+}
+
+func (m *MeshNodeStub) GetRoutes() []string {
+	return m.routes
+}
+
+func (m *MeshNodeStub) GetIdentifier() string {
+	return m.identifier
+}
+
+func (m *MeshNodeStub) GetDescription() string {
+	return m.description
+}
+
+type MeshSnapshotStub struct {
+	nodes map[string]MeshNode
+}
+
+func (s *MeshSnapshotStub) GetNodes() map[string]MeshNode {
+	return s.nodes
+}
+
+type MeshProviderStub struct {
+	meshId   string
+	snapshot *MeshSnapshotStub
+}
+
+// RemoveRoutes implements MeshProvider.
+func (*MeshProviderStub) RemoveRoutes(nodeId string, route ...string) error {
+	panic("unimplemented")
+}
+
+// Prune implements MeshProvider.
+func (*MeshProviderStub) Prune(pruneAmount int) error {
+	return nil
+}
+
+// UpdateTimeStamp implements MeshProvider.
+func (*MeshProviderStub) UpdateTimeStamp(nodeId string) error {
+	return nil
+}
+
+func (s *MeshProviderStub) AddNode(node MeshNode) {
+	s.snapshot.nodes[node.GetHostEndpoint()] = node
+}
+
+func (s *MeshProviderStub) GetMesh() (MeshSnapshot, error) {
+	return s.snapshot, nil
+}
+
+func (s *MeshProviderStub) GetMeshId() string {
+	return s.meshId
+}
+
+func (s *MeshProviderStub) Save() []byte {
+	return make([]byte, 0)
+}
+
+func (s *MeshProviderStub) Load(bytes []byte) error {
+	return nil
+}
+
+func (s *MeshProviderStub) GetDevice() (*wgtypes.Device, error) {
+	pubKey, _ := wgtypes.GenerateKey()
+	return &wgtypes.Device{
+		PublicKey: pubKey,
+	}, nil
+}
+
+func (s *MeshProviderStub) SaveChanges() {}
+
+func (s *MeshProviderStub) HasChanges() bool {
+	return false
+}
+
+func (s *MeshProviderStub) AddRoutes(nodeId string, route ...string) error {
+	return nil
+}
+
+func (s *MeshProviderStub) GetSyncer() MeshSyncer {
+	return nil
+}
+
+func (s *MeshProviderStub) SetDescription(nodeId string, description string) error {
+	return nil
+}
+
+type StubMeshProviderFactory struct{}
+
+func (s *StubMeshProviderFactory) CreateMesh(params *MeshProviderFactoryParams) (MeshProvider, error) {
+	return &MeshProviderStub{
+		meshId:   params.MeshId,
+		snapshot: &MeshSnapshotStub{nodes: make(map[string]MeshNode)},
+	}, nil
+}
+
+type StubNodeFactory struct {
+	Config *conf.WgMeshConfiguration
+}
+
+func (s *StubNodeFactory) Build(params *MeshNodeFactoryParams) MeshNode {
+	_, wgHost, _ := net.ParseCIDR(fmt.Sprintf("%s/128", params.NodeIP.String()))
+
+	return &MeshNodeStub{
+		hostEndpoint: params.Endpoint,
+		publicKey:    *params.PublicKey,
+		wgEndpoint:   fmt.Sprintf("%s:%s", params.Endpoint, s.Config.GrpcPort),
+		wgHost:       wgHost,
+		timeStamp:    time.Now().Unix(),
+		routes:       make([]string, 0),
+		identifier:   "abc",
+		description:  "A Mesh Node Stub",
+	}
+}
+
+type MeshConfigApplyerStub struct{}
+
+func (a *MeshConfigApplyerStub) ApplyConfig() error {
+	return nil
+}
+
+func (a *MeshConfigApplyerStub) RemovePeers(meshId string) error {
+	return nil
+}
+
+func (a *MeshConfigApplyerStub) SetMeshManager(manager MeshManager) {
+}
+
+type MeshManagerStub struct {
+	meshes map[string]MeshProvider
+}
+
+// Close implements MeshManager.
+func (*MeshManagerStub) Close() error {
+	panic("unimplemented")
+}
+
+// Prune implements MeshManager.
+func (*MeshManagerStub) Prune() error {
+	return nil
+}
+
+func NewMeshManagerStub() MeshManager {
+	return &MeshManagerStub{meshes: make(map[string]MeshProvider)}
+}
+
+func (m *MeshManagerStub) CreateMesh(devName string, port int) (string, error) {
+	return "tim123", nil
+}
+
+func (m *MeshManagerStub) AddMesh(params *AddMeshParams) error {
+	m.meshes[params.MeshId] = &MeshProviderStub{
+		params.MeshId,
+		&MeshSnapshotStub{nodes: make(map[string]MeshNode)},
+	}
+
+	return nil
+}
+
+func (m *MeshManagerStub) HasChanges(meshId string) bool {
+	return false
+}
+
+func (m *MeshManagerStub) GetMesh(meshId string) MeshProvider {
+	return &MeshProviderStub{
+		meshId:   meshId,
+		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
+}
+
+func (m *MeshManagerStub) AddSelf(params *AddSelfParams) error {
+	return nil
+}
+
+func (m *MeshManagerStub) GetSelf(meshId string) (MeshNode, error) {
+	return nil, nil
+}
+
+func (m *MeshManagerStub) ApplyConfig() error {
+	return nil
+}
+
+func (m *MeshManagerStub) SetDescription(description string) error {
+	return nil
+}
+
+func (m *MeshManagerStub) UpdateTimeStamp() error {
+	return nil
+}
+
+func (m *MeshManagerStub) GetClient() *wgctrl.Client {
+	return nil
+}
+
+func (m *MeshManagerStub) GetMeshes() map[string]MeshProvider {
+	return m.meshes
+}
+
+func (m *MeshManagerStub) LeaveMesh(meshId string) error {
+	return nil
+}
--- a/pkg/mesh/types.go
+++ b/pkg/mesh/types.go
@ -26,6 +26,8 @@ type MeshNode interface {
 	GetRoutes() []string
 	// GetIdentifier: returns the identifier of the node
 	GetIdentifier() string
+	// GetDescription: returns the description for this node
+	GetDescription() string
 }

 type MeshSnapshot interface {
@ -56,19 +58,26 @@ type MeshProvider interface {
 	GetDevice() (*wgtypes.Device, error)
 	// HasChanges returns true if we have changes since last time we synced
 	HasChanges() bool
-	// Record that we have changges and save the corresponding changes
+	// Record that we have changes and save the corresponding changes
 	SaveChanges()
 	// 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
+	// DeleteRoutes: deletes the routes from the node
+	RemoveRoutes(nodeId string, route ...string) error
+	// GetSyncer: returns the automerge syncer for sync
 	GetSyncer() MeshSyncer
+	// SetDescription: sets the description of this automerge data type
+	SetDescription(nodeId string, description string) error
+	// Prune: prunes all nodes that have not updated their timestamp in
+	// pruneAmount seconds
+	Prune(pruneAmount int) error
 }

 // HostParameters contains the IDs of a node
 type HostParameters struct {
 	HostEndpoint string
-	// TODO: Contain the WireGungracefullyuard identifier in this
 }

 // MeshProviderFactoryParams parameters required to build a mesh provider
--- a/pkg/middleware/auth.go
+++ b/pkg/middleware/auth.go
@ -1,29 +0,0 @@
-package middleware
-
-import (
-	"context"
-	"errors"
-
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/rpc"
-)
-
-// AuthRpcProvider implements the AuthRpcProvider service
-type AuthRpcProvider struct {
-	rpc.UnimplementedAuthenticationServer
-}
-
-// JoinMesh handles a JoinMeshRequest. Succeeds by stating the node managed to join the mesh
-// or returns an error if it failed
-func (a *AuthRpcProvider) JoinMesh(ctx context.Context, in *rpc.JoinAuthMeshRequest) (*rpc.JoinAuthMeshReply, error) {
-	meshId := in.MeshId
-
-	if meshId == "" {
-		return nil, errors.New("Must specify the meshId")
-	}
-
-	logging.Log.WriteInfof("MeshID: " + in.MeshId)
-
-	var token string = ""
-	return &rpc.JoinAuthMeshReply{Success: true, Token: &token}, nil
-}
--- a/pkg/query/query.go
+++ b/pkg/query/query.go
@ -0,0 +1,84 @@
+package query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/jmespath/go-jmespath"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/wgmesh/pkg/mesh"
+)
+
+// Querier queries a data store for the given data
+// and returns data in the corresponding encoding
+type Querier interface {
+	Query(meshId string, queryParams string) ([]byte, error)
+}
+
+type JmesQuerier struct {
+	manager mesh.MeshManager
+}
+
+type QueryError struct {
+	msg string
+}
+
+type QueryNode struct {
+	HostEndpoint string   `json:"hostEndpoint"`
+	PublicKey    string   `json:"publicKey"`
+	WgEndpoint   string   `json:"wgEndpoint"`
+	WgHost       string   `json:"wgHost"`
+	Timestamp    int64    `json:"timestmap"`
+	Description  string   `json:"description"`
+	Routes       []string `json:"routes"`
+}
+
+func (m *QueryError) Error() string {
+	return m.msg
+}
+
+// Query: queries the data
+func (j *JmesQuerier) Query(meshId, queryParams string) ([]byte, error) {
+	mesh, ok := j.manager.GetMeshes()[meshId]
+
+	if !ok {
+		return nil, &QueryError{msg: fmt.Sprintf("%s does not exist", meshId)}
+	}
+
+	snapshot, err := mesh.GetMesh()
+
+	if err != nil {
+		return nil, err
+	}
+
+	nodes := lib.Map(lib.MapValues(snapshot.GetNodes()), meshNodeToQueryNode)
+
+	result, err := jmespath.Search(queryParams, nodes)
+
+	if err != nil {
+		return nil, err
+	}
+
+	bytes, err := json.Marshal(result)
+	return bytes, err
+}
+
+func meshNodeToQueryNode(node mesh.MeshNode) *QueryNode {
+	queryNode := new(QueryNode)
+	queryNode.HostEndpoint = node.GetHostEndpoint()
+	pubKey, _ := node.GetPublicKey()
+
+	queryNode.PublicKey = pubKey.String()
+
+	queryNode.WgEndpoint = node.GetWgEndpoint()
+	queryNode.WgHost = node.GetWgHost().String()
+
+	queryNode.Timestamp = node.GetTimeStamp()
+	queryNode.Routes = node.GetRoutes()
+	queryNode.Description = node.GetDescription()
+	return queryNode
+}
+
+func NewJmesQuerier(manager mesh.MeshManager) Querier {
+	return &JmesQuerier{manager: manager}
+}
--- a/pkg/robin/requester.go
+++ b/pkg/robin/requester.go
@ -8,39 +8,41 @@ import (
 	"time"

 	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/ip"
 	"github.com/tim-beatham/wgmesh/pkg/ipc"
 	"github.com/tim-beatham/wgmesh/pkg/mesh"
 	"github.com/tim-beatham/wgmesh/pkg/rpc"
 )

 type IpcHandler struct {
-	Server      *ctrlserver.MeshCtrlServer
-	ipAllocator ip.IPAllocator
+	Server ctrlserver.CtrlServer
 }

 func (n *IpcHandler) CreateMesh(args *ipc.NewMeshArgs, reply *string) error {
-	meshId, err := n.Server.MeshManager.CreateMesh(args.IfName, args.WgPort)
+	meshId, err := n.Server.GetMeshManager().CreateMesh(args.IfName, args.WgPort)

 	if err != nil {
 		return err
 	}

-	err = n.Server.MeshManager.AddSelf(&mesh.AddSelfParams{
+	err = n.Server.GetMeshManager().AddSelf(&mesh.AddSelfParams{
 		MeshId:   meshId,
 		WgPort:   args.WgPort,
 		Endpoint: args.Endpoint,
 	})

+	if err != nil {
+		return err
+	}
+
 	*reply = meshId
 	return err
 }

 func (n *IpcHandler) ListMeshes(_ string, reply *ipc.ListMeshReply) error {
-	meshNames := make([]string, len(n.Server.MeshManager.Meshes))
+	meshNames := make([]string, len(n.Server.GetMeshManager().GetMeshes()))

 	i := 0
-	for meshId, _ := range n.Server.MeshManager.Meshes {
+	for meshId, _ := range n.Server.GetMeshManager().GetMeshes() {
 		meshNames[i] = meshId
 		i++
 	}
@ -50,7 +52,7 @@ func (n *IpcHandler) ListMeshes(_ string, reply *ipc.ListMeshReply) error {
 }

 func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {
-	peerConnection, err := n.Server.ConnectionManager.GetConnection(args.IpAdress)
+	peerConnection, err := n.Server.GetConnectionManager().GetConnection(args.IpAdress)

 	if err != nil {
 		return err
@ -77,7 +79,7 @@ func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {
 		return err
 	}

-	err = n.Server.MeshManager.AddMesh(&mesh.AddMeshParams{
+	err = n.Server.GetMeshManager().AddMesh(&mesh.AddMeshParams{
 		MeshId:    args.MeshId,
 		DevName:   args.IfName,
 		WgPort:    args.Port,
@ -88,7 +90,7 @@ func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {
 		return err
 	}

-	err = n.Server.MeshManager.AddSelf(&mesh.AddSelfParams{
+	err = n.Server.GetMeshManager().AddSelf(&mesh.AddSelfParams{
 		MeshId:   args.MeshId,
 		WgPort:   args.Port,
 		Endpoint: args.Endpoint,
@ -104,7 +106,7 @@ func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {

 // LeaveMesh leaves a mesh network
 func (n *IpcHandler) LeaveMesh(meshId string, reply *string) error {
-	err := n.Server.MeshManager.LeaveMesh(meshId)
+	err := n.Server.GetMeshManager().LeaveMesh(meshId)

 	if err == nil {
 		*reply = fmt.Sprintf("Left Mesh %s", meshId)
@ -114,7 +116,7 @@ func (n *IpcHandler) LeaveMesh(meshId string, reply *string) error {
 }

 func (n *IpcHandler) GetMesh(meshId string, reply *ipc.GetMeshReply) error {
-	mesh := n.Server.MeshManager.GetMesh(meshId)
+	mesh := n.Server.GetMeshManager().GetMesh(meshId)
 	meshSnapshot, err := mesh.GetMesh()

 	if err != nil {
@ -124,6 +126,7 @@ func (n *IpcHandler) GetMesh(meshId string, reply *ipc.GetMeshReply) error {
 	if mesh == nil {
 		return errors.New("mesh does not exist")
 	}
+
 	nodes := make([]ctrlserver.MeshNode, len(meshSnapshot.GetNodes()))

 	i := 0
@ -152,7 +155,7 @@ func (n *IpcHandler) GetMesh(meshId string, reply *ipc.GetMeshReply) error {
 }

 func (n *IpcHandler) EnableInterface(meshId string, reply *string) error {
-	err := n.Server.MeshManager.EnableInterface(meshId)
+	err := n.Server.GetMeshManager().EnableInterface(meshId)

 	if err != nil {
 		*reply = err.Error()
@ -164,7 +167,7 @@ func (n *IpcHandler) EnableInterface(meshId string, reply *string) error {
 }

 func (n *IpcHandler) GetDOT(meshId string, reply *string) error {
-	g := mesh.NewMeshDotConverter(n.Server.MeshManager)
+	g := mesh.NewMeshDotConverter(n.Server.GetMeshManager())

 	result, err := g.Generate(meshId)

@ -177,7 +180,7 @@ func (n *IpcHandler) GetDOT(meshId string, reply *string) error {
 }

 func (n *IpcHandler) Query(params ipc.QueryMesh, reply *string) error {
-	queryResponse, err := n.Server.Querier.Query(params.MeshId, params.Query)
+	queryResponse, err := n.Server.GetQuerier().Query(params.MeshId, params.Query)

 	if err != nil {
 		return err
@ -187,8 +190,19 @@ func (n *IpcHandler) Query(params ipc.QueryMesh, reply *string) error {
 	return nil
 }

+func (n *IpcHandler) PutDescription(description string, reply *string) error {
+	err := n.Server.GetMeshManager().SetDescription(description)
+
+	if err != nil {
+		return err
+	}
+
+	*reply = fmt.Sprintf("Set description to %s", description)
+	return nil
+}
+
 type RobinIpcParams struct {
-	CtrlServer *ctrlserver.MeshCtrlServer
+	CtrlServer ctrlserver.CtrlServer
 }

 func NewRobinIpc(ipcParams RobinIpcParams) IpcHandler {
--- a/pkg/robin/requester_test.go
+++ b/pkg/robin/requester_test.go
@ -0,0 +1,73 @@
+package robin
+
+import (
+	"testing"
+
+	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/wgmesh/pkg/ipc"
+	"github.com/tim-beatham/wgmesh/pkg/mesh"
+)
+
+func getRequester() *IpcHandler {
+	return &IpcHandler{Server: ctrlserver.NewCtrlServerStub()}
+}
+
+func TestCreateMeshRepliesMeshId(t *testing.T) {
+	var reply string
+	requester := getRequester()
+
+	err := requester.CreateMesh(&ipc.NewMeshArgs{
+		IfName:   "wg0",
+		WgPort:   5000,
+		Endpoint: "abc.com",
+	}, &reply)
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(reply) == 0 {
+		t.Fatalf(`reply should have been returned`)
+	}
+}
+
+func TestListMeshesNoMeshesListsEmpty(t *testing.T) {
+	var reply ipc.ListMeshReply
+	requester := getRequester()
+
+	err := requester.ListMeshes("", &reply)
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(reply.Meshes) != 0 {
+		t.Fatalf(`meshes should be empty`)
+	}
+}
+
+func TestListMeshesMeshesNotEmpty(t *testing.T) {
+	var reply ipc.ListMeshReply
+	requester := getRequester()
+
+	requester.Server.GetMeshManager().AddMesh(&mesh.AddMeshParams{
+		MeshId:    "tim123",
+		DevName:   "wg0",
+		WgPort:    5000,
+		MeshBytes: make([]byte, 0),
+	})
+
+	err := requester.ListMeshes("", &reply)
+
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(reply.Meshes) != 1 {
+		t.Fatalf(`only only mesh exists`)
+	}
+
+	if reply.Meshes[0] != "tim123" {
+		t.Fatalf(`meshId was %s expected %s`, reply.Meshes[0], "tim123")
+	}
+}
--- a/pkg/robin/responder.go
+++ b/pkg/robin/responder.go
@ -13,29 +13,6 @@ type WgRpc struct {
 	Server *ctrlserver.MeshCtrlServer
 }

-func nodeToRpcNode(node ctrlserver.MeshNode) *rpc.MeshNode {
-	return &rpc.MeshNode{
-		PublicKey:  node.PublicKey,
-		WgEndpoint: node.WgEndpoint,
-		WgHost:     node.WgHost,
-		Endpoint:   node.HostEndpoint,
-	}
-}
-
-func nodesToRpcNodes(nodes map[string]ctrlserver.MeshNode) []*rpc.MeshNode {
-	n := len(nodes)
-	meshNodes := make([]*rpc.MeshNode, n)
-
-	var i int = 0
-
-	for _, v := range nodes {
-		meshNodes[i] = nodeToRpcNode(v)
-		i++
-	}
-
-	return meshNodes
-}
-
 func (m *WgRpc) GetMesh(ctx context.Context, request *rpc.GetMeshRequest) (*rpc.GetMeshReply, error) {
 	mesh := m.Server.MeshManager.GetMesh(request.MeshId)

--- a/pkg/robin/responder_test.go
+++ b/pkg/robin/responder_test.go
@ -0,0 +1 @@
+package robin
--- a/pkg/sync/syncer.go
+++ b/pkg/sync/syncer.go
@ -2,10 +2,12 @@ package sync

 import (
 	"errors"
+	"math/rand"
 	"sync"
 	"time"

-	crdt "github.com/tim-beatham/wgmesh/pkg/automerge"
+	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/wgmesh/pkg/conn"
 	"github.com/tim-beatham/wgmesh/pkg/lib"
 	logging "github.com/tim-beatham/wgmesh/pkg/log"
 	"github.com/tim-beatham/wgmesh/pkg/mesh"
@ -18,27 +20,35 @@ type Syncer interface {
 }

 type SyncerImpl struct {
-	manager            *mesh.MeshManager
-	requester          SyncRequester
-	authenticatedNodes []crdt.MeshNodeCrdt
+	manager        mesh.MeshManager
+	requester      SyncRequester
+	infectionCount int
+	syncCount      int
+	cluster        conn.ConnCluster
+	conf           *conf.WgMeshConfiguration
 }

-const subSetLength = 3
-
 // Sync: Sync random nodes
 func (s *SyncerImpl) Sync(meshId string) error {
-	if !s.manager.HasChanges(meshId) {
+	logging.Log.WriteInfof("UPDATING WG CONF")
+	err := s.manager.ApplyConfig()
+
+	if err != nil {
+		logging.Log.WriteInfof("Failed to update config %w", err)
+	}
+
+	if !s.manager.HasChanges(meshId) && s.infectionCount == 0 {
 		logging.Log.WriteInfof("No changes for %s", meshId)
 		return nil
 	}

-	mesh := s.manager.GetMesh(meshId)
+	theMesh := s.manager.GetMesh(meshId)

-	if mesh == nil {
+	if theMesh == nil {
 		return errors.New("the provided mesh does not exist")
 	}

-	snapshot, err := mesh.GetMesh()
+	snapshot, err := theMesh.GetMesh()

 	if err != nil {
 		return err
@ -50,38 +60,63 @@ func (s *SyncerImpl) Sync(meshId string) error {
 		return nil
 	}

-	excludedNodes := map[string]struct{}{
-		s.manager.HostParameters.HostEndpoint: {},
+	self, err := s.manager.GetSelf(meshId)
+
+	if err != nil {
+		return err
 	}

+	excludedNodes := map[string]struct{}{
+		self.GetHostEndpoint(): {},
+	}
 	meshNodes := lib.MapValuesWithExclude(nodes, excludedNodes)
-	randomSubset := lib.RandomSubsetOfLength(meshNodes, subSetLength)
+
+	getNames := func(node mesh.MeshNode) string {
+		return node.GetHostEndpoint()
+	}
+
+	nodeNames := lib.Map(meshNodes, getNames)
+
+	neighbours := s.cluster.GetNeighbours(nodeNames, self.GetHostEndpoint())
+	randomSubset := lib.RandomSubsetOfLength(neighbours, s.conf.BranchRate)
+
+	for _, node := range randomSubset {
+		logging.Log.WriteInfof("Random node: %s", node)
+	}

 	before := time.Now()

+	if len(meshNodes) > s.conf.ClusterSize && rand.Float64() < s.conf.InterClusterChance {
+		logging.Log.WriteInfof("Sending to random cluster")
+		interCluster := s.cluster.GetInterCluster(nodeNames, self.GetHostEndpoint())
+		randomSubset = append(randomSubset, interCluster)
+	}
+
 	var waitGroup sync.WaitGroup

-	for _, n := range randomSubset {
+	for index := range randomSubset {
 		waitGroup.Add(1)

-		syncMeshFunc := func() error {
+		go func(i int) error {
 			defer waitGroup.Done()
-			err := s.requester.SyncMesh(meshId, n.GetHostEndpoint())
+			err := s.requester.SyncMesh(meshId, randomSubset[i])
 			return err
-		}
-
-		go syncMeshFunc()
+		}(index)
 	}

 	waitGroup.Wait()

+	s.syncCount++
 	logging.Log.WriteInfof("SYNC TIME: %v", time.Now().Sub(before))
+	logging.Log.WriteInfof("SYNC COUNT: %d", s.syncCount)
+
+	s.infectionCount = ((s.conf.InfectionCount + s.infectionCount - 1) % s.conf.InfectionCount)
 	return nil
 }

 // SyncMeshes: Sync all meshes
 func (s *SyncerImpl) SyncMeshes() error {
-	for meshId, _ := range s.manager.Meshes {
+	for meshId, _ := range s.manager.GetMeshes() {
 		err := s.Sync(meshId)

 		if err != nil {
@ -92,6 +127,13 @@ func (s *SyncerImpl) SyncMeshes() error {
 	return nil
 }

-func NewSyncer(m *mesh.MeshManager, r SyncRequester) Syncer {
-	return &SyncerImpl{manager: m, requester: r}
+func NewSyncer(m mesh.MeshManager, conf *conf.WgMeshConfiguration, r SyncRequester) Syncer {
+	cluster, _ := conn.NewConnCluster(conf.ClusterSize)
+	return &SyncerImpl{
+		manager:        m,
+		conf:           conf,
+		requester:      r,
+		infectionCount: 0,
+		syncCount:      0,
+		cluster:        cluster}
 }
--- a/pkg/sync/syncererror.go
+++ b/pkg/sync/syncererror.go
@ -14,7 +14,7 @@ type SyncErrorHandler interface {

 // SyncErrorHandlerImpl Is an implementation of the SyncErrorHandler
 type SyncErrorHandlerImpl struct {
-	meshManager *mesh.MeshManager
+	meshManager mesh.MeshManager
 }

 func (s *SyncErrorHandlerImpl) incrementFailedCount(meshId string, endpoint string) bool {
@ -24,6 +24,13 @@ func (s *SyncErrorHandlerImpl) incrementFailedCount(meshId string, endpoint stri
 		return false
 	}

+	// self, err := s.meshManager.GetSelf(meshId)
+
+	// if err != nil {
+	// return false
+	// }
+
+	// mesh.DecrementHealth(endpoint, self.GetHostEndpoint())
 	return true
 }

@ -40,6 +47,6 @@ func (s *SyncErrorHandlerImpl) Handle(meshId string, endpoint string, err error)
 	return false
 }

-func NewSyncErrorHandler(m *mesh.MeshManager) SyncErrorHandler {
+func NewSyncErrorHandler(m mesh.MeshManager) SyncErrorHandler {
 	return &SyncErrorHandlerImpl{meshManager: m}
 }
--- a/pkg/sync/syncrequester.go
+++ b/pkg/sync/syncrequester.go
@ -89,10 +89,12 @@ func (s *SyncRequesterImpl) SyncMesh(meshId, endpoint string) error {

 	c := rpc.NewSyncServiceClient(client)

-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	syncTimeOut := s.server.Conf.SyncRate * float64(time.Second)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(syncTimeOut))
 	defer cancel()

-	err = syncMesh(mesh, ctx, c)
+	err = s.syncMesh(mesh, ctx, c)

 	if err != nil {
 		return s.handleErr(meshId, endpoint, err)
@ -102,7 +104,7 @@ func (s *SyncRequesterImpl) SyncMesh(meshId, endpoint string) error {
 	return nil
 }

-func syncMesh(mesh mesh.MeshProvider, ctx context.Context, client rpc.SyncServiceClient) error {
+func (s *SyncRequesterImpl) syncMesh(mesh mesh.MeshProvider, ctx context.Context, client rpc.SyncServiceClient) error {
 	stream, err := client.SyncMesh(ctx)

 	syncer := mesh.GetSyncer()
--- a/pkg/sync/syncscheduler.go
+++ b/pkg/sync/syncscheduler.go
@ -1,10 +1,8 @@
 package sync

 import (
-	"time"
-
 	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
 )

 // SyncScheduler: Loops through all nodes in the mesh and runs a schedule to
@ -16,41 +14,19 @@ type SyncScheduler interface {

 // SyncSchedulerImpl scheduler for sync scheduling
 type SyncSchedulerImpl struct {
-	syncRate int
-	quit     chan struct{}
-	server   *ctrlserver.MeshCtrlServer
-	syncer   Syncer
+	quit   chan struct{}
+	server *ctrlserver.MeshCtrlServer
+	syncer Syncer
 }

 // Run implements SyncScheduler.
-func (s *SyncSchedulerImpl) Run() error {
-	ticker := time.NewTicker(time.Duration(s.syncRate) * time.Second)
-
-	quit := make(chan struct{})
-	s.quit = quit
-
-	for {
-		select {
-		case <-ticker.C:
-			err := s.syncer.SyncMeshes()
-
-			if err != nil {
-				logging.Log.WriteErrorf(err.Error())
-			}
-			break
-		case <-quit:
-			break
-		}
+func syncFunction(syncer Syncer) lib.TimerFunc {
+	return func() error {
+		return syncer.SyncMeshes()
 	}
 }

-// Stop implements SyncScheduler.
-func (s *SyncSchedulerImpl) Stop() error {
-	close(s.quit)
-	return nil
-}
-
-func NewSyncScheduler(s *ctrlserver.MeshCtrlServer, syncRequester SyncRequester, syncRate int) SyncScheduler {
-	syncer := NewSyncer(s.MeshManager, syncRequester)
-	return &SyncSchedulerImpl{server: s, syncRate: syncRate, syncer: syncer}
+func NewSyncScheduler(s *ctrlserver.MeshCtrlServer, syncRequester SyncRequester) *lib.Timer {
+	syncer := NewSyncer(s.MeshManager, s.Conf, syncRequester)
+	return lib.NewTimer(syncFunction(syncer), int(s.Conf.SyncRate))
 }
--- a/pkg/timestamp/timestamp.go
+++ b/pkg/timestamp/timestamp.go
@ -1,48 +1,14 @@
 package timestamp

 import (
-	"time"
-
 	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
 )

-type TimestampScheduler interface {
-	Run() error
-	Stop() error
-}
-
-type TimeStampSchedulerImpl struct {
-	meshManager *mesh.MeshManager
-	updateRate  int
-	quit        chan struct{}
-}
-
-func (s *TimeStampSchedulerImpl) Run() error {
-	ticker := time.NewTicker(time.Duration(s.updateRate) * time.Second)
-
-	s.quit = make(chan struct{})
-
-	for {
-		select {
-		case <-ticker.C:
-			err := s.meshManager.UpdateTimeStamp()
-
-			if err != nil {
-				logging.Log.WriteErrorf("Update Timestamp Error: %s", err.Error())
-			}
-		case <-s.quit:
-			break
-		}
+func NewTimestampScheduler(ctrlServer *ctrlserver.MeshCtrlServer) lib.Timer {
+	timerFunc := func() error {
+		return ctrlServer.MeshManager.UpdateTimeStamp()
 	}
-}

-func NewTimestampScheduler(ctrlServer *ctrlserver.MeshCtrlServer, updateRate int) TimestampScheduler {
-	return &TimeStampSchedulerImpl{meshManager: ctrlServer.MeshManager, updateRate: updateRate}
-}
-
-func (s *TimeStampSchedulerImpl) Stop() error {
-	close(s.quit)
-	return nil
+	return *lib.NewTimer(timerFunc, ctrlServer.Conf.KeepAliveTime)
 }
--- a/pkg/wg/stubs.go
+++ b/pkg/wg/stubs.go
@ -0,0 +1,15 @@
+package wg
+
+type WgInterfaceManipulatorStub struct{}
+
+func (i *WgInterfaceManipulatorStub) CreateInterface(params *CreateInterfaceParams) error {
+	return nil
+}
+
+func (i *WgInterfaceManipulatorStub) AddAddress(ifName string, addr string) error {
+	return nil
+}
+
+func (i *WgInterfaceManipulatorStub) RemoveInterface(ifName string) error {
+	return nil
+}
--- a/pkg/wg/types.go
+++ b/pkg/wg/types.go
@ -16,7 +16,8 @@ type CreateInterfaceParams struct {
 type WgInterfaceManipulator interface {
 	// CreateInterface creates a WireGuard interface
 	CreateInterface(params *CreateInterfaceParams) error
-	// Enable interface enables the given interface with
-	// the IP. It overrides the IP at the interface
-	EnableInterface(ifName string, ip string) error
+	// AddAddress adds an address to the given interface name
+	AddAddress(ifName string, addr string) error
+	// RemoveInterface removes the specified interface
+	RemoveInterface(ifName string) error
 }
--- a/pkg/wg/wg.go
+++ b/pkg/wg/wg.go
@ -2,47 +2,36 @@ package wg

 import (
 	"fmt"
-	"net"
-	"os/exec"

+	"github.com/tim-beatham/wgmesh/pkg/lib"
 	logging "github.com/tim-beatham/wgmesh/pkg/log"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

-// createInterface uses ip link to create an interface. If the interface exists
-// it returns an error
-func createInterface(ifName string) error {
-	_, err := net.InterfaceByName(ifName)
-
-	if err == nil {
-		return &WgError{msg: fmt.Sprintf("Interface %s already exists", ifName)}
-	}
-
-	// Check if the interface exists
-	cmd := exec.Command("/usr/bin/ip", "link", "add", "dev", ifName, "type", "wireguard")
-
-	if err := cmd.Run(); err != nil {
-		return err
-	}
-	return nil
-}
-
 type WgInterfaceManipulatorImpl struct {
 	client *wgctrl.Client
 }

+// CreateInterface creates a WireGuard interface
 func (m *WgInterfaceManipulatorImpl) CreateInterface(params *CreateInterfaceParams) error {
-	err := createInterface(params.IfName)
+	rtnl, err := lib.NewRtNetlinkConfig()

 	if err != nil {
-		return err
+		return fmt.Errorf("failed to access link: %w", err)
+	}
+	defer rtnl.Close()
+
+	err = rtnl.CreateLink(params.IfName)
+
+	if err != nil {
+		return fmt.Errorf("failed to create link: %w", err)
 	}

 	privateKey, err := wgtypes.GeneratePrivateKey()

 	if err != nil {
-		return err
+		return fmt.Errorf("failed to create private key: %w", err)
 	}

 	var cfg wgtypes.Config = wgtypes.Config{
@ -50,49 +39,44 @@ func (m *WgInterfaceManipulatorImpl) CreateInterface(params *CreateInterfacePara
 		ListenPort: &params.Port,
 	}

-	m.client.ConfigureDevice(params.IfName, cfg)
+	err = m.client.ConfigureDevice(params.IfName, cfg)
+
+	if err != nil {
+		return fmt.Errorf("failed to configure dev: %w", err)
+	}
+
+	logging.Log.WriteInfof("ip link set up dev %s type wireguard", params.IfName)
 	return nil
 }

-// flushInterface flushes the specified interface
-func flushInterface(ifName string) error {
-	_, err := net.InterfaceByName(ifName)
+// Add an address to the given interface
+func (m *WgInterfaceManipulatorImpl) AddAddress(ifName string, addr string) error {
+	rtnl, err := lib.NewRtNetlinkConfig()

 	if err != nil {
-		return &WgError{msg: fmt.Sprintf("Interface %s does not exist cannot flush", ifName)}
+		return fmt.Errorf("failed to create config: %w", err)
+	}
+	defer rtnl.Close()
+
+	err = rtnl.AddAddress(ifName, addr)
+
+	if err != nil {
+		err = fmt.Errorf("failed to add address: %w", err)
 	}

-	cmd := exec.Command("/usr/bin/ip", "addr", "flush", "dev", ifName)
-
-	if err := cmd.Run(); err != nil {
-		logging.Log.WriteErrorf(fmt.Sprintf("%s error flushing interface %s", err.Error(), ifName))
-		return &WgError{msg: fmt.Sprintf("Failed to flush interface %s", ifName)}
-	}
-
-	return nil
+	return err
 }

-// EnableInterface flushes the interface and sets the ip address of the
-// interface
-func (m *WgInterfaceManipulatorImpl) EnableInterface(ifName string, ip string) error {
-	err := flushInterface(ifName)
+// RemoveInterface implements WgInterfaceManipulator.
+func (*WgInterfaceManipulatorImpl) RemoveInterface(ifName string) error {
+	rtnl, err := lib.NewRtNetlinkConfig()

 	if err != nil {
-		return err
+		return fmt.Errorf("failed to create config: %w", err)
 	}
+	defer rtnl.Close()

-	hostIp, _, err := net.ParseCIDR(ip)
-
-	if err != nil {
-		return err
-	}
-
-	cmd := exec.Command("/usr/bin/ip", "addr", "add", hostIp.String()+"/64", "dev", ifName)
-
-	if err := cmd.Run(); err != nil {
-		return err
-	}
-	return nil
+	return rtnl.DeleteLink(ifName)
 }

 func NewWgInterfaceManipulator(client *wgctrl.Client) WgInterfaceManipulator {
Author	SHA1	Message	Date
Tim Beatham	1a864b7c80	Removed interface manipulation via os.Exec into rtnetlink calls	2023-11-07 19:48:53 +00:00
Tim Beatham	4c19ebd81f	Merge pull request #12 from tim-beatham/11-health-system 11 health system	2023-11-06 13:40:04 +00:00
Tim Beatham	acbeb689b5	Prune nodes if they exceed their timeout time	2023-11-06 13:37:28 +00:00
Tim Beatham	bc6cd4fdd5	Modified syncer	2023-11-06 10:05:23 +00:00
Tim Beatham	c88012cf71	Added health system to count how many times a node fails to conenct.	2023-11-06 09:54:06 +00:00
Tim Beatham	4dc85f3861	Merge pull request #10 from tim-beatham/9-add-ci-support 9 add ci support	2023-11-05 18:07:52 +00:00
Tim Beatham	ef614f5961	Add cert dependencies	2023-11-05 18:06:24 +00:00
Tim Beatham	9454d62417	Adding stubs and writing tests	2023-11-05 18:03:58 +00:00
Tim Beatham	bb07d35dcb	Unit testing the automerge library and lib functions	2023-11-05 12:13:40 +00:00
Tim Beatham	76dda2cf6f	Update go.mod	2023-11-05 10:54:38 +00:00
Tim Beatham	1b286dd3c1	Update go.yml	2023-11-05 10:53:57 +00:00
Tim Beatham	2d45c2d298	Run go mod tidy in workflow	2023-11-05 10:51:24 +00:00
Tim Beatham	900c67a121	Update go.mod	2023-11-05 10:49:18 +00:00
Tim Beatham	b2fa08a642	Reverted go version	2023-11-05 10:48:35 +00:00
Tim Beatham	a4e9a5cd0f	Updated go version in workflow	2023-11-05 10:47:10 +00:00
Tim Beatham	275eb423fb	Create GitHub hosted test runner go.yml	2023-11-05 10:45:39 +00:00
Tim Beatham	d17dce3b1e	Added clustering and clean up	2023-11-03 15:26:09 +00:00
Tim Beatham	e2c6db3a4f	Merge pull request #8 from tim-beatham/7-create-rotating-window-of-connections Implemented clustering betweeen nodes	2023-11-03 15:25:30 +00:00
Tim Beatham	843caddf6b	Implemented clustering betweeen nodes	2023-11-03 15:24:18 +00:00
Tim Beatham	8d8a13d6ff	Build error forgot to add query.go	2023-11-01 13:17:58 +00:00
Tim Beatham	5183edc592	Merge pull request #6 from tim-beatham/5-ability-to-add-alias-and-description-to-services Ability for each node to set their description describing what service they provide.	2023-11-01 11:58:52 +00:00
Tim Beatham	d462d95d6d	Ability for each node to set their description describing what service they provide.	2023-11-01 11:58:10 +00:00
Tim Beatham	8e50848043	Merge pull request #4 from tim-beatham/3-periodically-update-the-wg-configuration Fixing an issue where packets are dropped each time	2023-11-01 10:42:56 +00:00
Tim Beatham	e63edea763	Fixing an issue where packets are dropped each time we change wg configuration	2023-11-01 10:39:46 +00:00
Tim Beatham	a1caf2e8ae	Merge pull request #2 from tim-beatham/1-log-key-events-in-the-mesh 1 log key events in the mesh	2023-10-31 10:37:59 +00:00