bugfix-node-not-leaving

- Add lock when perform synchronisation on concurrent access

cmd/api/main.go

@@ -3,7 +3,7 @@ package main
 import (
 	"log"
 
-	"github.com/tim-beatham/wgmesh/pkg/api"
+	"github.com/tim-beatham/smegmesh/pkg/api"
 )
 
 func main() {

cmd/dns/main.go

@@ -3,7 +3,7 @@ package main
 import (
 	"log"
 
-	smegdns "github.com/tim-beatham/wgmesh/pkg/dns"
+	smegdns "github.com/tim-beatham/smegmesh/pkg/dns"
 )
 
 func main() {

cmd/smegctl/main.go

@@ -6,10 +6,10 @@ import (
 	"os"
 
 	"github.com/akamensky/argparse"
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	graph "github.com/tim-beatham/wgmesh/pkg/dot"
-	"github.com/tim-beatham/wgmesh/pkg/ipc"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	graph "github.com/tim-beatham/smegmesh/pkg/dot"
+	"github.com/tim-beatham/smegmesh/pkg/ipc"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 )
 
 const SockAddr = "/tmp/wgmesh_ipc.sock"
@@ -22,25 +22,22 @@ type CreateMeshParams struct {
 	AdvertiseDefault bool
 }
 
-func createMesh(params *CreateMeshParams) string {
+func createMesh(client *ipc.SmegmeshIpc, args *ipc.NewMeshArgs) {
 	var reply string
-	newMeshParams := ipc.NewMeshArgs{
-		WgArgs: params.WgArgs,
-	}
-
-	err := params.Client.Call("IpcHandler.CreateMesh", &newMeshParams, &reply)
+	err := client.CreateMesh(args, &reply)
 
 	if err != nil {
-		return err.Error()
+		fmt.Println(err.Error())
+		return
 	}
 
-	return reply
+	fmt.Println(reply)
 }
 
-func listMeshes(client *ipcRpc.Client) {
+func listMeshes(client *ipc.SmegmeshIpc) {
 	reply := new(ipc.ListMeshReply)
 
-	err := client.Call("IpcHandler.ListMeshes", "", &reply)
+	err := client.ListMeshes(reply)
 
 	if err != nil {
 		logging.Log.WriteErrorf(err.Error())
@@ -52,38 +49,22 @@ func listMeshes(client *ipcRpc.Client) {
 	}
 }
 
-type JoinMeshParams struct {
-	Client           *ipcRpc.Client
-	MeshId           string
-	IpAddress        string
-	Endpoint         string
-	WgArgs           ipc.WireGuardArgs
-	AdvertiseRoutes  bool
-	AdvertiseDefault bool
-}
-
-func joinMesh(params *JoinMeshParams) string {
+func joinMesh(client *ipc.SmegmeshIpc, args ipc.JoinMeshArgs) {
 	var reply string
 
-	args := ipc.JoinMeshArgs{
-		MeshId:   params.MeshId,
-		IpAdress: params.IpAddress,
-		WgArgs:   params.WgArgs,
-	}
-
-	err := params.Client.Call("IpcHandler.JoinMesh", &args, &reply)
+	err := client.JoinMesh(args, &reply)
 
 	if err != nil {
-		return err.Error()
+		fmt.Println(err.Error())
 	}
 
-	return reply
+	fmt.Println(reply)
 }
 
-func leaveMesh(client *ipcRpc.Client, meshId string) {
+func leaveMesh(client *ipc.SmegmeshIpc, meshId string) {
 	var reply string
 
-	err := client.Call("IpcHandler.LeaveMesh", &meshId, &reply)
+	err := client.LeaveMesh(meshId, &reply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -93,10 +74,10 @@ func leaveMesh(client *ipcRpc.Client, meshId string) {
 	fmt.Println(reply)
 }
 
-func getGraph(client *ipcRpc.Client) {
+func getGraph(client *ipc.SmegmeshIpc) {
 	listMeshesReply := new(ipc.ListMeshReply)
 
-	err := client.Call("IpcHandler.ListMeshes", "", &listMeshesReply)
+	err := client.ListMeshes(listMeshesReply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -108,7 +89,7 @@ func getGraph(client *ipcRpc.Client) {
 	for _, meshId := range listMeshesReply.Meshes {
 		var meshReply ipc.GetMeshReply
 
-		err := client.Call("IpcHandler.GetMesh", &meshId, &meshReply)
+		err := client.GetMesh(meshId, &meshReply)
 
 		if err != nil {
 			fmt.Println(err.Error())
@@ -129,10 +110,15 @@ func getGraph(client *ipcRpc.Client) {
 	fmt.Println(dot)
 }
 
-func queryMesh(client *ipcRpc.Client, meshId, query string) {
+func queryMesh(client *ipc.SmegmeshIpc, meshId, query string) {
 	var reply string
 
-	err := client.Call("IpcHandler.Query", &ipc.QueryMesh{MeshId: meshId, Query: query}, &reply)
+	args := ipc.QueryMesh{
+		MeshId: meshId,
+		Query:  query,
+	}
+
+	err := client.Query(args, &reply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -142,11 +128,13 @@ 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) {
+func putDescription(client *ipc.SmegmeshIpc, meshId, description string) {
 	var reply string
 
-	err := client.Call("IpcHandler.PutDescription", &description, &reply)
+	err := client.PutDescription(ipc.PutDescriptionArgs{
+		MeshId:      meshId,
+		Description: description,
+	}, &reply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -157,10 +145,13 @@ func putDescription(client *ipcRpc.Client, description string) {
 }
 
 // putAlias: puts an alias for the node
-func putAlias(client *ipcRpc.Client, alias string) {
+func putAlias(client *ipc.SmegmeshIpc, meshid, alias string) {
 	var reply string
 
-	err := client.Call("IpcHandler.PutAlias", &alias, &reply)
+	err := client.PutAlias(ipc.PutAliasArgs{
+		MeshId: meshid,
+		Alias:  alias,
+	}, &reply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -170,15 +161,14 @@ func putAlias(client *ipcRpc.Client, alias string) {
 	fmt.Println(reply)
 }
 
-func setService(client *ipcRpc.Client, service, value string) {
+func setService(client *ipc.SmegmeshIpc, meshId, service, value string) {
 	var reply string
 
-	serviceArgs := &ipc.PutServiceArgs{
+	err := client.PutService(ipc.PutServiceArgs{
+		MeshId:  meshId,
 		Service: service,
 		Value:   value,
-	}
-
-	err := client.Call("IpcHandler.PutService", serviceArgs, &reply)
+	}, &reply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -188,10 +178,13 @@ func setService(client *ipcRpc.Client, service, value string) {
 	fmt.Println(reply)
 }
 
-func deleteService(client *ipcRpc.Client, service string) {
+func deleteService(client *ipc.SmegmeshIpc, meshId, service string) {
 	var reply string
 
-	err := client.Call("IpcHandler.PutService", &service, &reply)
+	err := client.DeleteService(ipc.DeleteServiceArgs{
+		MeshId:  meshId,
+		Service: service,
+	}, &reply)
 
 	if err != nil {
 		fmt.Println(err.Error())
@@ -202,8 +195,8 @@ func deleteService(client *ipcRpc.Client, service string) {
 }
 
 func main() {
-	parser := argparse.NewParser("wg-mesh",
-		"wg-mesh Manipulate WireGuard mesh networks")
+	parser := argparse.NewParser("smgctl",
+		"smegctl Manipulate WireGuard mesh networks")
 
 	newMeshCmd := parser.NewCommand("new-mesh", "Create a new mesh")
 	listMeshCmd := parser.NewCommand("list-meshes", "List meshes the node is connected to")
@@ -226,7 +219,6 @@ func main() {
 	})
 
 	var newMeshRole *string = newMeshCmd.Selector("r", "role", []string{"peer", "client"}, &argparse.Options{
-		Default: "peer",
 		Help: "Role in the mesh network. A value of peer means that the node is publicly routeable and thus considered" +
 			" in the gossip protocol. Client means that the node is not publicly routeable and is not a candidate in the gossip" +
 			" protocol",
@@ -259,7 +251,6 @@ func main() {
 	})
 
 	var joinMeshRole *string = joinMeshCmd.Selector("r", "role", []string{"peer", "client"}, &argparse.Options{
-		Default: "peer",
 		Help: "Role in the mesh network. A value of peer means that the node is publicly routeable and thus considered" +
 			" in the gossip protocol. Client means that the node is not publicly routeable and is not a candidate in the gossip" +
 			" protocol",
@@ -302,6 +293,16 @@ func main() {
 		Help:     "Description of the node in the mesh",
 	})
 
+	var descriptionMeshId *string = putDescriptionCmd.String("m", "meshid", &argparse.Options{
+		Required: true,
+		Help:     "MeshID of the mesh network to join",
+	})
+
+	var aliasMeshId *string = putAliasCmd.String("m", "meshid", &argparse.Options{
+		Required: true,
+		Help:     "MeshID of the mesh network to join",
+	})
+
 	var alias *string = putAliasCmd.String("a", "alias", &argparse.Options{
 		Required: true,
 		Help:     "Alias of the node to set can be used in DNS to lookup an IP address",
@@ -316,11 +317,21 @@ func main() {
 		Help:     "Value of the service to advertise in the mesh network",
 	})
 
+	var serviceMeshId *string = setServiceCmd.String("m", "meshid", &argparse.Options{
+		Required: true,
+		Help:     "MeshID of the mesh network to join",
+	})
+
 	var deleteServiceKey *string = deleteServiceCmd.String("s", "service", &argparse.Options{
 		Required: true,
 		Help:     "Key of the service to remove",
 	})
 
+	var deleteServiceMeshid *string = deleteServiceCmd.String("m", "meshid", &argparse.Options{
+		Required: true,
+		Help:     "MeshID of the mesh network to join",
+	})
+
 	err := parser.Parse(os.Args)
 
 	if err != nil {
@@ -328,16 +339,13 @@ func main() {
 		return
 	}
 
-	client, err := ipcRpc.DialHTTP("unix", SockAddr)
+	client, err := ipc.NewClientIpc()
 	if err != nil {
-		fmt.Println(err.Error())
-		return
+		panic(err)
 	}
 
 	if newMeshCmd.Happened() {
-		fmt.Println(createMesh(&CreateMeshParams{
-			Client:   client,
-			Endpoint: *newMeshEndpoint,
+		args := &ipc.NewMeshArgs{
 			WgArgs: ipc.WireGuardArgs{
 				Endpoint:              *newMeshEndpoint,
 				Role:                  *newMeshRole,
@@ -346,7 +354,9 @@ func main() {
 				AdvertiseDefaultRoute: *newMeshAdvertiseDefaults,
 				AdvertiseRoutes:       *newMeshAdvertiseRoutes,
 			},
-		}))
+		}
+
+		createMesh(client, args)
 	}
 
 	if listMeshCmd.Happened() {
@@ -354,11 +364,9 @@ func main() {
 	}
 
 	if joinMeshCmd.Happened() {
-		fmt.Println(joinMesh(&JoinMeshParams{
-			Client:    client,
+		args := ipc.JoinMeshArgs{
 			IpAddress: *joinMeshIpAddress,
 			MeshId:    *joinMeshId,
-			Endpoint:  *joinMeshEndpoint,
 			WgArgs: ipc.WireGuardArgs{
 				Endpoint:              *joinMeshEndpoint,
 				Role:                  *joinMeshRole,
@@ -367,7 +375,8 @@ func main() {
 				AdvertiseDefaultRoute: *joinMeshAdvertiseDefaults,
 				AdvertiseRoutes:       *joinMeshAdvertiseRoutes,
 			},
-		}))
+		}
+		joinMesh(client, args)
 	}
 
 	if getGraphCmd.Happened() {
@@ -383,18 +392,18 @@ func main() {
 	}
 
 	if putDescriptionCmd.Happened() {
-		putDescription(client, *description)
+		putDescription(client, *descriptionMeshId, *description)
 	}
 
 	if putAliasCmd.Happened() {
-		putAlias(client, *alias)
+		putAlias(client, *aliasMeshId, *alias)
 	}
 
 	if setServiceCmd.Happened() {
-		setService(client, *serviceKey, *serviceValue)
+		setService(client, *serviceMeshId, *serviceKey, *serviceValue)
 	}
 
 	if deleteServiceCmd.Happened() {
-		deleteService(client, *deleteServiceKey)
+		deleteService(client, *deleteServiceMeshid, *deleteServiceKey)
 	}
 }

cmd/smegd/main.go

@@ -6,14 +6,14 @@ import (
 	"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/mesh"
-	"github.com/tim-beatham/wgmesh/pkg/robin"
-	"github.com/tim-beatham/wgmesh/pkg/sync"
-	timer "github.com/tim-beatham/wgmesh/pkg/timers"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	ctrlserver "github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/ipc"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/robin"
+	"github.com/tim-beatham/smegmesh/pkg/sync"
+	timer "github.com/tim-beatham/smegmesh/pkg/timers"
 	"golang.zx2c4.com/wireguard/wgctrl"
 )
 
@@ -59,6 +59,11 @@ func main() {
 	}
 
 	ctrlServer, err := ctrlserver.NewCtrlServer(&ctrlServerParams)
+
+	if err != nil {
+		panic(err)
+	}
+
 	syncProvider.Server = ctrlServer
 	syncRequester = sync.NewSyncRequester(ctrlServer)
 	syncer = sync.NewSyncer(ctrlServer.MeshManager, conf, syncRequester)

cmd/wgmeshd/configuration.yaml

@@ -10,5 +10,5 @@ syncRate: 1
 interClusterChance: 0.15
 branchRate: 3
 infectionCount: 3
-keepAliveTime: 10
+heartBeatTime: 10
 pruneTime: 20

examples/meshtomesh/shared/configuration.yaml

@@ -10,5 +10,5 @@ syncRate: 1
 interClusterChance: 0.15
 branchRate: 3
 infectionCount: 3
-keepAliveTime: 10
+heartBeatTime: 10
 pruneTime: 20

examples/simple/shared/configuration.yaml

@@ -10,5 +10,5 @@ syncRate: 1
 interClusterChance: 0.15
 branchRate: 3
 infectionCount: 3
-keepAliveTime: 10
+heartBeatTime: 10
 pruneTime: 20

go.mod

@@ -1,4 +1,4 @@
-module github.com/tim-beatham/wgmesh
+module github.com/tim-beatham/smegmesh
 
 go 1.21.3
 
@@ -11,11 +11,11 @@ require (
 	github.com/google/uuid v1.3.0
 	github.com/jmespath/go-jmespath v0.4.0
 	github.com/jsimonetti/rtnetlink v1.3.5
+	github.com/lithammer/shortuuid v3.0.0+incompatible
 	github.com/miekg/dns v1.1.57
 	github.com/sirupsen/logrus v1.9.3
 	golang.org/x/sys v0.14.0
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20230429144221-925a1e7659e6
-	gonum.org/v1/gonum v0.14.0
 	google.golang.org/grpc v1.58.1
 	google.golang.org/protobuf v1.31.0
 	gopkg.in/yaml.v3 v3.0.1

go.sum

@@ -27,8 +27,6 @@ github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/o
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
-github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/go-playground/validator/v10 v10.16.0 h1:x+plE831WK4vaKHO/jpgUGsvLKIqRRkz6M78GuJAfGE=
 github.com/go-playground/validator/v10 v10.16.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
@@ -57,6 +55,8 @@ github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZX
 github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/lithammer/shortuuid v3.0.0+incompatible h1:NcD0xWW/MZYXEHa6ITy6kaXN5nwm/V115vj2YXfhS0w=
+github.com/lithammer/shortuuid v3.0.0+incompatible/go.mod h1:FR74pbAuElzOUuenUHTK2Tciko1/vKuIKS9dSkDrA4w=
 github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mdlayher/genetlink v1.3.2 h1:KdrNKe+CTu+IbZnm/GVUMXSqBBLqcGpRDa0xkQy56gw=
@@ -123,8 +123,6 @@ golang.zx2c4.com/wireguard v0.0.0-20230704135630-469159ecf7d1 h1:EY138uSo1JYlDq+
 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=
-gonum.org/v1/gonum v0.14.0 h1:2NiG67LD1tEH0D7kM+ps2V+fXmsAnpUeec7n8tcr4S0=
-gonum.org/v1/gonum v0.14.0/go.mod h1:AoWeoz0becf9QMWtE8iWXNXc27fK4fNeHNf/oMejGfU=
 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=

pkg/api/apiserver.go

@@ -4,17 +4,13 @@ import (
 	"fmt"
 	"net/http"
 
-	ipcRpc "net/rpc"
-
 	"github.com/gin-gonic/gin"
-	"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/what8words"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/ipc"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/what8words"
 )
 
-const SockAddr = "/tmp/wgmesh_ipc.sock"
-
 type ApiServer interface {
 	GetMeshes(c *gin.Context)
 	Run(addr string) error
@@ -22,7 +18,7 @@ type ApiServer interface {
 
 type SmegServer struct {
 	router *gin.Engine
-	client *ipcRpc.Client
+	client *ipc.SmegmeshIpc
 	words  *what8words.What8Words
 }
 
@@ -106,7 +102,7 @@ func (s *SmegServer) CreateMesh(c *gin.Context) {
 
 	var reply string
 
-	err := s.client.Call("IpcHandler.CreateMesh", &ipcRequest, &reply)
+	err := s.client.CreateMesh(&ipcRequest, &reply)
 
 	if err != nil {
 		c.JSON(http.StatusBadRequest, &gin.H{
@@ -132,8 +128,8 @@ func (s *SmegServer) JoinMesh(c *gin.Context) {
 	}
 
 	ipcRequest := ipc.JoinMeshArgs{
-		MeshId:   joinMesh.MeshId,
-		IpAdress: joinMesh.Bootstrap,
+		MeshId:    joinMesh.MeshId,
+		IpAddress: joinMesh.Bootstrap,
 		WgArgs: ipc.WireGuardArgs{
 			WgPort: joinMesh.WgPort,
 		},
@@ -141,7 +137,7 @@ func (s *SmegServer) JoinMesh(c *gin.Context) {
 
 	var reply string
 
-	err := s.client.Call("IpcHandler.JoinMesh", &ipcRequest, &reply)
+	err := s.client.JoinMesh(ipcRequest, &reply)
 
 	if err != nil {
 		c.JSON(http.StatusBadRequest, &gin.H{
@@ -164,7 +160,7 @@ func (s *SmegServer) GetMesh(c *gin.Context) {
 
 	getMeshReply := new(ipc.GetMeshReply)
 
-	err := s.client.Call("IpcHandler.GetMesh", &meshid, &getMeshReply)
+	err := s.client.GetMesh(meshid, getMeshReply)
 
 	if err != nil {
 		c.JSON(http.StatusNotFound,
@@ -182,7 +178,7 @@ func (s *SmegServer) GetMesh(c *gin.Context) {
 func (s *SmegServer) GetMeshes(c *gin.Context) {
 	listMeshesReply := new(ipc.ListMeshReply)
 
-	err := s.client.Call("IpcHandler.ListMeshes", "", &listMeshesReply)
+	err := s.client.ListMeshes(listMeshesReply)
 
 	if err != nil {
 		logging.Log.WriteErrorf(err.Error())
@@ -195,7 +191,7 @@ func (s *SmegServer) GetMeshes(c *gin.Context) {
 	for _, mesh := range listMeshesReply.Meshes {
 		getMeshReply := new(ipc.GetMeshReply)
 
-		err := s.client.Call("IpcHandler.GetMesh", &mesh, &getMeshReply)
+		err := s.client.GetMesh(mesh, getMeshReply)
 
 		if err != nil {
 			logging.Log.WriteErrorf(err.Error())
@@ -215,7 +211,7 @@ func (s *SmegServer) Run(addr string) error {
 }
 
 func NewSmegServer(conf ApiServerConf) (ApiServer, error) {
-	client, err := ipcRpc.DialHTTP("unix", SockAddr)
+	client, err := ipc.NewClientIpc()
 
 	if err != nil {
 		return nil, err
@@ -239,9 +235,19 @@ func NewSmegServer(conf ApiServerConf) (ApiServer, error) {
 		words:  words,
 	}
 
-	router.GET("/meshes", smegServer.GetMeshes)
-	router.GET("/mesh/:meshid", smegServer.GetMesh)
-	router.POST("/mesh/create", smegServer.CreateMesh)
-	router.POST("/mesh/join", smegServer.JoinMesh)
+	v1 := router.Group("/api/v1")
+	{
+		meshes := v1.Group("/meshes")
+		{
+			meshes.GET("/", smegServer.GetMeshes)
+		}
+		mesh := v1.Group("/mesh")
+		{
+			mesh.GET("/:meshid", smegServer.GetMesh)
+			mesh.POST("/create", smegServer.CreateMesh)
+			mesh.POST("/join", smegServer.JoinMesh)
+		}
+	}
+
 	return smegServer, nil
 }

pkg/automerge/automerge.go

@@ -9,10 +9,10 @@ import (
 	"time"
 
 	"github.com/automerge/automerge-go"
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"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/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

pkg/automerge/automerge_sync.go

@@ -2,7 +2,7 @@ package automerge
 
 import (
 	"github.com/automerge/automerge-go"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 )
 
 type AutomergeSync struct {

pkg/automerge/automerge_test.go

@@ -6,9 +6,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 

pkg/automerge/factory.go

@@ -3,9 +3,9 @@ package automerge
 import (
 	"fmt"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 )
 
 type CrdtProviderFactory struct{}

pkg/conf/conf.go

@@ -47,7 +47,6 @@ type WgConfiguration struct {
 	// If the user is globaly accessible they specify themselves as a client.
 	Role *NodeType `yaml:"role" validate:"required,eq=client|eq=peer"`
 	// KeepAliveWg configures the implementation so that we send keep alive packets to peers.
-	// KeepAlive can only be set if role is type client
 	KeepAliveWg *int `yaml:"keepAliveWg" validate:"omitempty,gte=0"`
 	// PreUp are WireGuard commands to run before adding the WG interface
 	PreUp []string `yaml:"preUp"`
@@ -77,11 +76,13 @@ type DaemonConfiguration struct {
 	Profile bool `yaml:"profile"`
 	// StubWg whether or not to stub the WireGuard types
 	StubWg bool `yaml:"stubWg"`
-	// SyncRate specifies how long the minimum time should be between synchronisation
-	SyncRate int `yaml:"syncRate" validate:"required,gte=1"`
-	// KeepAliveTime: number of seconds before the leader of the mesh sends an update to
+	// SyncTime specifies how long the minimum time should be between synchronisation
+	SyncTime int `yaml:"syncTime" validate:"required,gte=1"`
+	// PullTime specifies the interval between checking for configuration changes
+	PullTime int `yaml:"pullTime" validate:"gte=0"`
+	// HeartBeat: number of seconds before the leader of the mesh sends an update to
 	// send to every member in the mesh
-	KeepAliveTime int `yaml:"keepAliveTime" validate:"required,gte=1"`
+	HeartBeat int `yaml:"heartBeatTime" validate:"required,gte=1"`
 	// ClusterSize specifies how many neighbours you should synchronise with per round
 	ClusterSize int `yaml:"clusterSize" validate:"gte=1"`
 	// InterClusterChance specifies the probabilityof inter-cluster communication in a sync round

pkg/conf/conf_test.go

@@ -21,11 +21,12 @@ func getExampleConfiguration() *DaemonConfiguration {
 		Timeout:              5,
 		Profile:              false,
 		StubWg:               false,
-		SyncRate:             2,
-		KeepAliveTime:        2,
+		SyncTime:             2,
+		HeartBeat:            2,
 		ClusterSize:          64,
 		InterClusterChance:   0.15,
 		BranchRate:           3,
+		PullTime:             0,
 		InfectionCount:       2,
 		BaseConfiguration: WgConfiguration{
 			IPDiscovery:           &discovery,
@@ -162,9 +163,9 @@ func TestBranchRateZero(t *testing.T) {
 	}
 }
 
-func TestSyncRateZero(t *testing.T) {
+func TestsyncTimeZero(t *testing.T) {
 	conf := getExampleConfiguration()
-	conf.SyncRate = 0
+	conf.SyncTime = 0
 
 	err := ValidateDaemonConfiguration(conf)
 
@@ -175,7 +176,7 @@ func TestSyncRateZero(t *testing.T) {
 
 func TestKeepAliveTimeZero(t *testing.T) {
 	conf := getExampleConfiguration()
-	conf.KeepAliveTime = 0
+	conf.HeartBeat = 0
 	err := ValidateDaemonConfiguration(conf)
 
 	if err == nil {
@@ -215,6 +216,17 @@ func TestInfectionCountOne(t *testing.T) {
 	}
 }
 
+func TestPullTimeNegative(t *testing.T) {
+	conf := getExampleConfiguration()
+	conf.PullTime = -1
+
+	err := ValidateDaemonConfiguration(conf)
+
+	if err == nil {
+		t.Fatal(`error should be thrown`)
+	}
+}
+
 func TestValidConfiguration(t *testing.T) {
 	conf := getExampleConfiguration()
 	err := ValidateDaemonConfiguration(conf)

pkg/conn/cluster.go

@@ -23,9 +23,10 @@ func binarySearch(global []string, selfId string, groupSize int) (int, int) {
 
 	lower := 0
 	higher := len(global) - 1
-	mid := (lower + higher) / 2
 
 	for (higher+1)-lower > groupSize {
+		mid := (lower + higher) / 2
+
 		if global[mid] < selfId {
 			lower = mid + 1
 		} else if global[mid] > selfId {
@@ -33,8 +34,6 @@ func binarySearch(global []string, selfId string, groupSize int) (int, int) {
 		} else {
 			break
 		}
-
-		mid = (lower + higher) / 2
 	}
 
 	return lower, int(math.Min(float64(lower+groupSize), float64(len(global))))

pkg/conn/connection.go

@@ -6,7 +6,7 @@ import (
 	"crypto/tls"
 	"errors"
 
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 )

pkg/conn/connectionmanager.go

@@ -7,7 +7,7 @@ import (
 	"os"
 	"sync"
 
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 )
 
 // ConnectionManager defines an interface for maintaining peer connections

pkg/conn/connectionserver.go

@@ -8,9 +8,9 @@ import (
 	"net"
 	"os"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/rpc"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/rpc"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
 )

pkg/crdt/datastore.go

@@ -9,10 +9,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"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/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
@@ -264,7 +264,7 @@ func (m *TwoPhaseStoreMeshManager) UpdateTimeStamp(nodeId string) error {
 
 	peerToUpdate := peers[0]
 
-	if uint64(time.Now().Unix())-m.store.Clock.GetTimestamp(peerToUpdate) > 3*uint64(m.DaemonConf.KeepAliveTime) {
+	if uint64(time.Now().Unix())-m.store.Clock.GetTimestamp(peerToUpdate) > 3*uint64(m.DaemonConf.HeartBeat) {
 		m.store.Mark(peerToUpdate)
 
 		if len(peers) < 2 {

pkg/crdt/datastore_test.go

@@ -6,9 +6,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
@@ -32,8 +32,8 @@ func setUpTests() *TestParams {
 			GrpcPort:             0,
 			Timeout:              20,
 			Profile:              false,
-			SyncRate:             2,
-			KeepAliveTime:        10,
+			SyncTime:             2,
+			HeartBeat:            10,
 			ClusterSize:          32,
 			InterClusterChance:   0.15,
 			BranchRate:           3,

pkg/crdt/factory.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"hash/fnv"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 )
 
 type TwoPhaseMapFactory struct {
@@ -24,7 +24,7 @@ func (f *TwoPhaseMapFactory) CreateMesh(params *mesh.MeshProviderFactoryParams)
 			h := fnv.New64a()
 			h.Write([]byte(s))
 			return h.Sum64()
-		}, uint64(3*f.Config.KeepAliveTime)),
+		}, uint64(3*f.Config.HeartBeat)),
 	}, nil
 }
 

pkg/crdt/g_map_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 )
 
 func NewGmap() *GMap[string, bool] {

pkg/crdt/two_phase_map.go

@@ -3,7 +3,7 @@ package crdt
 import (
 	"cmp"
 
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 )
 
 type TwoPhaseMap[K cmp.Ordered, D any] struct {

pkg/crdt/two_phase_map_syncer.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"encoding/gob"
 
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 )
 
 type SyncState int

pkg/crdt/vector_clock.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 )
 
 type VectorBucket struct {

pkg/ctrlserver/ctrlserver.go

@@ -1,16 +1,16 @@
 package ctrlserver
 
 import (
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/conn"
-	"github.com/tim-beatham/wgmesh/pkg/crdt"
-	"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"
-	"github.com/tim-beatham/wgmesh/pkg/wg"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/conn"
+	"github.com/tim-beatham/smegmesh/pkg/crdt"
+	"github.com/tim-beatham/smegmesh/pkg/ip"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/query"
+	"github.com/tim-beatham/smegmesh/pkg/rpc"
+	"github.com/tim-beatham/smegmesh/pkg/wg"
 	"golang.zx2c4.com/wireguard/wgctrl"
 )
 

pkg/ctrlserver/ctrltypes.go

@@ -4,11 +4,11 @@ import (
 	"net"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/conn"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
-	"github.com/tim-beatham/wgmesh/pkg/query"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/conn"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/query"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

pkg/ctrlserver/stub.go

@@ -1,10 +1,10 @@
 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"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/conn"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/query"
 	"golang.zx2c4.com/wireguard/wgctrl"
 )
 

pkg/dns/dns.go

@@ -4,21 +4,18 @@ import (
 	"encoding/json"
 	"fmt"
 	"net"
-	"net/rpc"
 
 	"github.com/miekg/dns"
-	"github.com/tim-beatham/wgmesh/pkg/ipc"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/query"
+	"github.com/tim-beatham/smegmesh/pkg/ipc"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/query"
 )
 
-const SockAddr = "/tmp/wgmesh_ipc.sock"
-
 const MeshRegularExpression = `(?P<meshId>.+)\.(?P<alias>.+)\.smeg\.`
 
 type DNSHandler struct {
-	client *rpc.Client
+	client *ipc.SmegmeshIpc
 	server *dns.Server
 }
 
@@ -27,7 +24,7 @@ type DNSHandler struct {
 func (d *DNSHandler) queryMesh(meshId, alias string) net.IP {
 	var reply string
 
-	err := d.client.Call("IpcHandler.Query", &ipc.QueryMesh{
+	err := d.client.Query(ipc.QueryMesh{
 		MeshId: meshId,
 		Query:  fmt.Sprintf("[?alias == '%s'] | [0]", alias),
 	}, &reply)
@@ -97,7 +94,7 @@ func (h *DNSHandler) Close() error {
 }
 
 func NewDns(udpPort int) (*DNSHandler, error) {
-	client, err := rpc.DialHTTP("unix", SockAddr)
+	client, err := ipc.NewClientIpc()
 
 	if err != nil {
 		return nil, err

pkg/dot/dot.go

@@ -6,7 +6,7 @@ import (
 	"hash/fnv"
 	"strings"
 
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 )
 
 type GraphType string

pkg/dot/wg.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"slices"
 
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
 )
 
 // MeshGraphConverter converts a mesh to a graph

pkg/ip/cga.go

@@ -34,7 +34,7 @@ type CgaParameters struct {
 	flag           byte
 }
 
-func NewCga(key wgtypes.Key, subnetPrefix [2 * InterfaceIdLen]byte) (*CgaParameters, error) {
+func NewCga(key wgtypes.Key, collisionCount uint8, subnetPrefix [2 * InterfaceIdLen]byte) (*CgaParameters, error) {
 	var params CgaParameters
 
 	_, err := rand.Read(params.Modifier[:])
@@ -45,6 +45,7 @@ func NewCga(key wgtypes.Key, subnetPrefix [2 * InterfaceIdLen]byte) (*CgaParamet
 
 	params.PublicKey = key
 	params.SubnetPrefix = subnetPrefix
+	params.CollisionCount = collisionCount
 	return &params, nil
 }
 
@@ -78,7 +79,6 @@ func (c *CgaParameters) generateHash1() []byte {
 	byteVal[hash1Length-1] = c.CollisionCount
 
 	hash := sha1.Sum(byteVal[:])
-
 	return hash[:Hash1Prefix]
 }
 
@@ -90,9 +90,6 @@ func clearBit(num, pos int) byte {
 }
 
 func (c *CgaParameters) generateInterface() []byte {
-	// TODO: On duplicate address detection increment collision.
-	// Also incorporate SEC
-
 	hash1 := c.generateHash1()
 
 	var interfaceId []byte = make([]byte, InterfaceIdLen)

pkg/ip/types.go

@@ -7,5 +7,5 @@ import (
 )
 
 type IPAllocator interface {
-	GetIP(key wgtypes.Key, meshId string) (net.IP, error)
+	GetIP(key wgtypes.Key, meshId string, collisionCount uint8) (net.IP, error)
 }

pkg/ip/ula.go

@@ -39,10 +39,10 @@ func (u *ULABuilder) GetIPNet(meshId string) (*net.IPNet, error) {
 	return net, nil
 }
 
-func (u *ULABuilder) GetIP(key wgtypes.Key, meshId string) (net.IP, error) {
+func (u *ULABuilder) GetIP(key wgtypes.Key, meshId string, collisionCount uint8) (net.IP, error) {
 	ulaPrefix := getMeshPrefix(meshId)
 
-	c, err := NewCga(key, ulaPrefix)
+	c, err := NewCga(key, collisionCount, ulaPrefix)
 
 	if err != nil {
 		return nil, err

pkg/ipc/ipc.go

@@ -5,11 +5,27 @@ import (
 	"net"
 	"net/http"
 	"net/rpc"
+	ipcRpc "net/rpc"
 	"os"
 
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
 )
 
+const SockAddr = "/tmp/wgmesh_sock"
+
+type MeshIpc interface {
+	CreateMesh(args *NewMeshArgs, reply *string) error
+	ListMeshes(name string, reply *ListMeshReply) error
+	JoinMesh(args *JoinMeshArgs, reply *string) error
+	LeaveMesh(meshId string, reply *string) error
+	GetMesh(meshId string, reply *GetMeshReply) error
+	Query(query QueryMesh, reply *string) error
+	PutDescription(args PutDescriptionArgs, reply *string) error
+	PutAlias(args PutAliasArgs, reply *string) error
+	PutService(args PutServiceArgs, reply *string) error
+	DeleteService(args DeleteServiceArgs, reply *string) error
+}
+
 // WireGuardArgs are provided args specific to WireGuard
 type WireGuardArgs struct {
 	// WgPort is the WireGuard port to expose
@@ -39,7 +55,7 @@ type JoinMeshArgs struct {
 	// MeshId is the ID of the mesh to join
 	MeshId string
 	// IpAddress is a routable IP in another mesh
-	IpAdress string
+	IpAddress string
 	// WgArgs is the WireGuard parameters to use.
 	WgArgs WireGuardArgs
 }
@@ -47,6 +63,22 @@ type JoinMeshArgs struct {
 type PutServiceArgs struct {
 	Service string
 	Value   string
+	MeshId  string
+}
+
+type DeleteServiceArgs struct {
+	Service string
+	MeshId  string
+}
+
+type PutAliasArgs struct {
+	Alias  string
+	MeshId string
+}
+
+type PutDescriptionArgs struct {
+	Description string
+	MeshId      string
 }
 
 type GetMeshReply struct {
@@ -62,20 +94,78 @@ type QueryMesh struct {
 	Query  string
 }
 
-type MeshIpc interface {
+type ClientIpc interface {
 	CreateMesh(args *NewMeshArgs, reply *string) error
-	ListMeshes(name string, reply *ListMeshReply) error
+	ListMeshes(args *ListMeshReply, reply *string) error
 	JoinMesh(args JoinMeshArgs, reply *string) error
 	LeaveMesh(meshId string, reply *string) error
 	GetMesh(meshId string, reply *GetMeshReply) error
 	Query(query QueryMesh, reply *string) error
-	PutDescription(description string, reply *string) error
-	PutAlias(alias string, reply *string) error
+	PutDescription(args PutDescriptionArgs, reply *string) error
+	PutAlias(args PutAliasArgs, reply *string) error
 	PutService(args PutServiceArgs, reply *string) error
-	DeleteService(service string, reply *string) error
+	DeleteService(args DeleteServiceArgs, reply *string) error
 }
 
-const SockAddr = "/tmp/wgmesh_ipc.sock"
+type SmegmeshIpc struct {
+	client *ipcRpc.Client
+}
+
+func NewClientIpc() (*SmegmeshIpc, error) {
+	client, err := ipcRpc.DialHTTP("unix", SockAddr)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &SmegmeshIpc{
+		client: client,
+	}, nil
+}
+
+func (c *SmegmeshIpc) CreateMesh(args *NewMeshArgs, reply *string) error {
+	return c.client.Call("IpcHandler.CreateMesh", args, reply)
+}
+
+func (c *SmegmeshIpc) ListMeshes(reply *ListMeshReply) error {
+	return c.client.Call("IpcHandler.ListMeshes", "", reply)
+}
+
+func (c *SmegmeshIpc) JoinMesh(args JoinMeshArgs, reply *string) error {
+	return c.client.Call("IpcHandler.JoinMesh", &args, reply)
+}
+
+func (c *SmegmeshIpc) LeaveMesh(meshId string, reply *string) error {
+	return c.client.Call("IpcHandler.LeaveMesh", &meshId, reply)
+}
+
+func (c *SmegmeshIpc) GetMesh(meshId string, reply *GetMeshReply) error {
+	return c.client.Call("IpcHandler.GetMesh", &meshId, reply)
+}
+
+func (c *SmegmeshIpc) Query(query QueryMesh, reply *string) error {
+	return c.client.Call("IpcHandler.Query", &query, reply)
+}
+
+func (c *SmegmeshIpc) PutDescription(args PutDescriptionArgs, reply *string) error {
+	return c.client.Call("IpcHandler.PutDescription", &args, reply)
+}
+
+func (c *SmegmeshIpc) PutAlias(args PutAliasArgs, reply *string) error {
+	return c.client.Call("IpcHandler.PutAlias", &args, reply)
+}
+
+func (c *SmegmeshIpc) PutService(args PutServiceArgs, reply *string) error {
+	return c.client.Call("IpcHandler.PutService", &args, reply)
+}
+
+func (c *SmegmeshIpc) DeleteService(args DeleteServiceArgs, reply *string) error {
+	return c.client.Call("IpcHandler.DeleteService", &args, reply)
+}
+
+func (c *SmegmeshIpc) Close() error {
+	return c.Close()
+}
 
 func RunIpcHandler(server MeshIpc) error {
 	if err := os.RemoveAll(SockAddr); err != nil {

pkg/lib/rtnetlink.go

@@ -6,7 +6,7 @@ import (
 	"net"
 
 	"github.com/jsimonetti/rtnetlink"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 	"golang.org/x/sys/unix"
 )
 

pkg/mesh/config.go

@@ -7,10 +7,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/ip"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/route"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/ip"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/route"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 

pkg/mesh/manager.go

@@ -3,13 +3,15 @@ package mesh
 import (
 	"errors"
 	"fmt"
+	"net"
 	"sync"
 
-	"github.com/tim-beatham/wgmesh/pkg/cmd"
-	"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"
+	"github.com/tim-beatham/smegmesh/pkg/cmd"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/ip"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/wg"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
@@ -24,10 +26,10 @@ type MeshManager interface {
 	LeaveMesh(meshId string) error
 	GetSelf(meshId string) (MeshNode, error)
 	ApplyConfig() error
-	SetDescription(description string) error
-	SetAlias(alias string) error
-	SetService(service string, value string) error
-	RemoveService(service string) error
+	SetDescription(meshId, description string) error
+	SetAlias(meshId, alias string) error
+	SetService(meshId, service, value string) error
+	RemoveService(meshId, service string) error
 	UpdateTimeStamp() error
 	GetClient() *wgctrl.Client
 	GetMeshes() map[string]MeshProvider
@@ -61,29 +63,33 @@ func (m *MeshManagerImpl) GetRouteManager() RouteManager {
 }
 
 // RemoveService implements MeshManager.
-func (m *MeshManagerImpl) RemoveService(service string) error {
-	for _, mesh := range m.Meshes {
-		err := mesh.RemoveService(m.HostParameters.GetPublicKey(), service)
+func (m *MeshManagerImpl) RemoveService(meshId, service string) error {
+	mesh := m.GetMesh(meshId)
 
-		if err != nil {
-			return err
-		}
+	if mesh == nil {
+		return fmt.Errorf("mesh %s does not exist", meshId)
 	}
 
-	return nil
+	if !mesh.NodeExists(m.HostParameters.GetPublicKey()) {
+		return fmt.Errorf("node %s does not exist in the mesh", meshId)
+	}
+
+	return mesh.RemoveService(m.HostParameters.GetPublicKey(), service)
 }
 
 // SetService implements MeshManager.
-func (m *MeshManagerImpl) SetService(service string, value string) error {
-	for _, mesh := range m.Meshes {
-		err := mesh.AddService(m.HostParameters.GetPublicKey(), service, value)
+func (m *MeshManagerImpl) SetService(meshId, service, value string) error {
+	mesh := m.GetMesh(meshId)
 
-		if err != nil {
-			return err
-		}
+	if mesh == nil {
+		return fmt.Errorf("mesh %s does not exist", meshId)
 	}
 
-	return nil
+	if !mesh.NodeExists(m.HostParameters.GetPublicKey()) {
+		return fmt.Errorf("node %s does not exist in the mesh", meshId)
+	}
+
+	return mesh.AddService(m.HostParameters.GetPublicKey(), service, value)
 }
 
 func (m *MeshManagerImpl) GetNode(meshid, nodeId string) MeshNode {
@@ -134,6 +140,10 @@ func (m *MeshManagerImpl) CreateMesh(args *CreateMeshParams) (string, error) {
 		return "", err
 	}
 
+	if *meshConfiguration.Role == conf.CLIENT_ROLE {
+		return "", fmt.Errorf("cannot create mesh as a client")
+	}
+
 	meshId, err := m.idGenerator.GetId()
 
 	var ifName string = ""
@@ -277,10 +287,36 @@ func (s *MeshManagerImpl) AddSelf(params *AddSelfParams) error {
 
 	pubKey := s.HostParameters.PrivateKey.PublicKey()
 
-	nodeIP, err := s.ipAllocator.GetIP(pubKey, params.MeshId)
+	collisionCount := uint8(0)
 
-	if err != nil {
-		return err
+	var nodeIP net.IP
+
+	// Perform Duplicate Address Detection with the nodes
+	// that are already in the network
+	for {
+		generatedIP, err := s.ipAllocator.GetIP(pubKey, params.MeshId, collisionCount)
+
+		if err != nil {
+			return err
+		}
+
+		snapshot, err := mesh.GetMesh()
+
+		if err != nil {
+			return err
+		}
+
+		proposition := func(node MeshNode) bool {
+			ipNet := node.GetWgHost()
+			return ipNet.IP.Equal(nodeIP)
+		}
+
+		if lib.Contains(lib.MapValues(snapshot.GetNodes()), proposition) {
+			collisionCount++
+		} else {
+			nodeIP = generatedIP
+			break
+		}
 	}
 
 	node := s.nodeFactory.Build(&MeshNodeFactoryParams{
@@ -320,7 +356,7 @@ func (s *MeshManagerImpl) LeaveMesh(meshId string) error {
 	err := mesh.RemoveNode(s.HostParameters.GetPublicKey())
 
 	if err != nil {
-		return err
+		logging.Log.WriteErrorf(err.Error())
 	}
 
 	if s.OnDelete != nil {
@@ -348,7 +384,6 @@ func (s *MeshManagerImpl) LeaveMesh(meshId string) error {
 	}
 
 	s.cmdRunner.RunCommands(s.conf.BaseConfiguration.PostDown...)
-
 	return err
 }
 
@@ -373,43 +408,36 @@ func (s *MeshManagerImpl) ApplyConfig() error {
 		return nil
 	}
 
-	err := s.configApplyer.ApplyConfig()
-
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return s.configApplyer.ApplyConfig()
 }
 
-func (s *MeshManagerImpl) SetDescription(description string) error {
-	meshes := s.GetMeshes()
-	for _, mesh := range meshes {
-		if mesh.NodeExists(s.HostParameters.GetPublicKey()) {
-			err := mesh.SetDescription(s.HostParameters.GetPublicKey(), description)
+func (s *MeshManagerImpl) SetDescription(meshId, description string) error {
+	mesh := s.GetMesh(meshId)
 
-			if err != nil {
-				return err
-			}
-		}
+	if mesh == nil {
+		return fmt.Errorf("mesh %s does not exist", meshId)
 	}
 
-	return nil
+	if !mesh.NodeExists(s.HostParameters.GetPublicKey()) {
+		return fmt.Errorf("node %s does not exist in the mesh", meshId)
+	}
+
+	return mesh.SetDescription(s.HostParameters.GetPublicKey(), description)
 }
 
 // SetAlias implements MeshManager.
-func (s *MeshManagerImpl) SetAlias(alias string) error {
-	meshes := s.GetMeshes()
-	for _, mesh := range meshes {
-		if mesh.NodeExists(s.HostParameters.GetPublicKey()) {
-			err := mesh.SetAlias(s.HostParameters.GetPublicKey(), alias)
+func (s *MeshManagerImpl) SetAlias(meshId, alias string) error {
+	mesh := s.GetMesh(meshId)
 
-			if err != nil {
-				return err
-			}
-		}
+	if mesh == nil {
+		return fmt.Errorf("mesh %s does not exist", meshId)
 	}
-	return nil
+
+	if !mesh.NodeExists(s.HostParameters.GetPublicKey()) {
+		return fmt.Errorf("node %s does not exist in the mesh", meshId)
+	}
+
+	return mesh.SetAlias(s.HostParameters.GetPublicKey(), alias)
 }
 
 // UpdateTimeStamp updates the timestamp of this node in all meshes

pkg/mesh/manager_test.go

@@ -3,10 +3,10 @@ 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"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/ip"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/wg"
 )
 
 func getMeshConfiguration() *conf.DaemonConfiguration {
@@ -24,8 +24,8 @@ func getMeshConfiguration() *conf.DaemonConfiguration {
 		Timeout:              5,
 		Profile:              false,
 		StubWg:               true,
-		SyncRate:             2,
-		KeepAliveTime:        60,
+		SyncTime:             2,
+		HeartBeat:            60,
 		ClusterSize:          64,
 		InterClusterChance:   0.15,
 		BranchRate:           3,
@@ -213,7 +213,7 @@ func TestLeaveMeshDeletesMesh(t *testing.T) {
 	}
 }
 
-func TestSetAlias(t *testing.T) {
+func TestSetAliasUpdatesAliasOfNode(t *testing.T) {
 	manager := getMeshManager()
 	alias := "Firpo"
 
@@ -221,14 +221,13 @@ func TestSetAlias(t *testing.T) {
 		Port: 5000,
 		Conf: &conf.WgConfiguration{},
 	})
-
 	manager.AddSelf(&AddSelfParams{
 		MeshId:   meshId,
 		WgPort:   5000,
 		Endpoint: "abc.com:8080",
 	})
 
-	err := manager.SetAlias(alias)
+	err := manager.SetAlias(meshId, alias)
 
 	if err != nil {
 		t.Fatalf(`failed to set the alias`)
@@ -245,7 +244,7 @@ func TestSetAlias(t *testing.T) {
 	}
 }
 
-func TestSetDescription(t *testing.T) {
+func TestSetDescriptionSetsTheDescriptionOfTheNode(t *testing.T) {
 	manager := getMeshManager()
 	description := "wooooo"
 
@@ -254,23 +253,13 @@ func TestSetDescription(t *testing.T) {
 		Conf: &conf.WgConfiguration{},
 	})
 
-	meshId2, _ := manager.CreateMesh(&CreateMeshParams{
-		Port: 5001,
-		Conf: &conf.WgConfiguration{},
-	})
-
 	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)
+	err := manager.SetDescription(meshId1, description)
 
 	if err != nil {
 		t.Fatalf(`failed to set the descriptions`)
@@ -285,18 +274,7 @@ func TestSetDescription(t *testing.T) {
 	if description != self1.GetDescription() {
 		t.Fatalf(`description should be %s was %s`, description, self1.GetDescription())
 	}
-
-	self2, err := manager.GetSelf(meshId2)
-
-	if err != nil {
-		t.Fatalf(`failed to set the description`)
-	}
-
-	if description != self2.GetDescription() {
-		t.Fatalf(`description should be %s was %s`, description, self2.GetDescription())
-	}
 }
-
 func TestUpdateTimeStampUpdatesAllMeshes(t *testing.T) {
 	manager := getMeshManager()
 
@@ -327,3 +305,68 @@ func TestUpdateTimeStampUpdatesAllMeshes(t *testing.T) {
 		t.Fatalf(`failed to update the timestamp`)
 	}
 }
+
+func TestAddServiceAddsServiceToTheMesh(t *testing.T) {
+	manager := getMeshManager()
+
+	meshId1, _ := manager.CreateMesh(&CreateMeshParams{
+		Port: 5000,
+		Conf: &conf.WgConfiguration{},
+	})
+	manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId1,
+		WgPort:   5000,
+		Endpoint: "abc.com:8080",
+	})
+
+	serviceName := "hello"
+	manager.SetService(meshId1, serviceName, "dave")
+
+	self, err := manager.GetSelf(meshId1)
+
+	if err != nil {
+		t.Fatalf(`error thrown %s:`, err.Error())
+	}
+
+	if _, ok := self.GetServices()[serviceName]; !ok {
+		t.Fatalf(`service not added`)
+	}
+}
+
+func TestRemoveServiceRemovesTheServiceFromTheMesh(t *testing.T) {
+	manager := getMeshManager()
+
+	meshId1, _ := manager.CreateMesh(&CreateMeshParams{
+		Port: 5000,
+		Conf: &conf.WgConfiguration{},
+	})
+	manager.AddSelf(&AddSelfParams{
+		MeshId:   meshId1,
+		WgPort:   5000,
+		Endpoint: "abc.com:8080",
+	})
+
+	serviceName := "hello"
+	manager.SetService(meshId1, serviceName, "dave")
+
+	self, err := manager.GetSelf(meshId1)
+
+	if err != nil {
+		t.Fatalf(`error thrown %s:`, err.Error())
+	}
+
+	if _, ok := self.GetServices()[serviceName]; !ok {
+		t.Fatalf(`service not added`)
+	}
+
+	manager.RemoveService(meshId1, serviceName)
+	self, err = manager.GetSelf(meshId1)
+
+	if err != nil {
+		t.Fatalf(`error thrown %s:`, err.Error())
+	}
+
+	if _, ok := self.GetServices()[serviceName]; ok {
+		t.Fatalf(`service still exists`)
+	}
+}

pkg/mesh/route.go

@@ -3,8 +3,8 @@ package mesh
 import (
 	"net"
 
-	"github.com/tim-beatham/wgmesh/pkg/ip"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/ip"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 )
 
 type RouteManager interface {

pkg/mesh/stub_types.go

@@ -5,8 +5,8 @@ import (
 	"net"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
@@ -30,8 +30,8 @@ func (*MeshNodeStub) GetType() conf.NodeType {
 }
 
 // GetServices implements MeshNode.
-func (*MeshNodeStub) GetServices() map[string]string {
-	return make(map[string]string)
+func (m *MeshNodeStub) GetServices() map[string]string {
+	return m.services
 }
 
 // GetAlias implements MeshNode.
@@ -249,6 +249,7 @@ func (s *StubNodeFactory) Build(params *MeshNodeFactoryParams) MeshNode {
 		routes:       make([]Route, 0),
 		identifier:   "abc",
 		description:  "A Mesh Node Stub",
+		services:     make(map[string]string),
 	}
 }
 
@@ -271,32 +272,32 @@ type MeshManagerStub struct {
 
 // GetRouteManager implements MeshManager.
 func (*MeshManagerStub) GetRouteManager() RouteManager {
-	panic("unimplemented")
+	return nil
 }
 
 // GetNode implements MeshManager.
-func (*MeshManagerStub) GetNode(string, string) MeshNode {
-	panic("unimplemented")
+func (*MeshManagerStub) GetNode(meshId, nodeId string) MeshNode {
+	return nil
 }
 
 // RemoveService implements MeshManager.
-func (*MeshManagerStub) RemoveService(service string) error {
-	panic("unimplemented")
+func (*MeshManagerStub) RemoveService(meshId, service string) error {
+	return nil
 }
 
 // SetService implements MeshManager.
-func (*MeshManagerStub) SetService(service string, value string) error {
-	panic("unimplemented")
+func (*MeshManagerStub) SetService(meshId, service, value string) error {
+	return nil
 }
 
 // SetAlias implements MeshManager.
-func (*MeshManagerStub) SetAlias(alias string) error {
-	panic("unimplemented")
+func (*MeshManagerStub) SetAlias(meshId, alias string) error {
+	return nil
 }
 
 // Close implements MeshManager.
 func (*MeshManagerStub) Close() error {
-	panic("unimplemented")
+	return nil
 }
 
 // Prune implements MeshManager.
@@ -348,7 +349,7 @@ func (m *MeshManagerStub) ApplyConfig() error {
 	return nil
 }
 
-func (m *MeshManagerStub) SetDescription(description string) error {
+func (m *MeshManagerStub) SetDescription(meshId, description string) error {
 	return nil
 }
 

pkg/mesh/types.go

@@ -6,7 +6,7 @@ import (
 	"net"
 	"slices"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

pkg/query/query.go

@@ -6,9 +6,9 @@ import (
 	"strings"
 
 	"github.com/jmespath/go-jmespath"
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 )
 
 // Querier queries a data store for the given data

pkg/robin/requester.go

@@ -7,11 +7,11 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/ipc"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
-	"github.com/tim-beatham/wgmesh/pkg/rpc"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/ipc"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/rpc"
 )
 
 type IpcHandler struct {
@@ -43,10 +43,6 @@ func getOverrideConfiguration(args *ipc.WireGuardArgs) conf.WgConfiguration {
 func (n *IpcHandler) CreateMesh(args *ipc.NewMeshArgs, reply *string) error {
 	overrideConf := getOverrideConfiguration(&args.WgArgs)
 
-	if overrideConf.Role != nil && *overrideConf.Role == conf.CLIENT_ROLE {
-		return fmt.Errorf("cannot create a mesh with no public endpoint")
-	}
-
 	meshId, err := n.Server.GetMeshManager().CreateMesh(&mesh.CreateMeshParams{
 		Port: args.WgArgs.WgPort,
 		Conf: &overrideConf,
@@ -83,10 +79,14 @@ func (n *IpcHandler) ListMeshes(_ string, reply *ipc.ListMeshReply) error {
 	return nil
 }
 
-func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {
+func (n *IpcHandler) JoinMesh(args *ipc.JoinMeshArgs, reply *string) error {
 	overrideConf := getOverrideConfiguration(&args.WgArgs)
 
-	peerConnection, err := n.Server.GetConnectionManager().GetConnection(args.IpAdress)
+	if n.Server.GetMeshManager().GetMesh(args.MeshId) != nil {
+		return fmt.Errorf("user is already apart of the mesh")
+	}
+
+	peerConnection, err := n.Server.GetConnectionManager().GetConnection(args.IpAddress)
 
 	if err != nil {
 		return err
@@ -147,7 +147,6 @@ func (n *IpcHandler) LeaveMesh(meshId string, reply *string) error {
 	if err == nil {
 		*reply = fmt.Sprintf("Left Mesh %s", meshId)
 	}
-
 	return err
 }
 
@@ -193,30 +192,34 @@ 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)
+func (n *IpcHandler) PutDescription(args ipc.PutDescriptionArgs, reply *string) error {
+	err := n.Server.GetMeshManager().SetDescription(args.MeshId, args.Description)
 
 	if err != nil {
 		return err
 	}
 
-	*reply = fmt.Sprintf("Set description to %s", description)
+	*reply = fmt.Sprintf("set description to %s for %s", args.Description, args.MeshId)
 	return nil
 }
 
-func (n *IpcHandler) PutAlias(alias string, reply *string) error {
-	err := n.Server.GetMeshManager().SetAlias(alias)
+func (n *IpcHandler) PutAlias(args ipc.PutAliasArgs, reply *string) error {
+	if args.Alias == "" {
+		return fmt.Errorf("alias not provided")
+	}
+
+	err := n.Server.GetMeshManager().SetAlias(args.MeshId, args.Alias)
 
 	if err != nil {
 		return err
 	}
 
-	*reply = fmt.Sprintf("Set alias to %s", alias)
+	*reply = fmt.Sprintf("Set alias to %s", args.Alias)
 	return nil
 }
 
 func (n *IpcHandler) PutService(service ipc.PutServiceArgs, reply *string) error {
-	err := n.Server.GetMeshManager().SetService(service.Service, service.Value)
+	err := n.Server.GetMeshManager().SetService(service.MeshId, service.Service, service.Value)
 
 	if err != nil {
 		return err
@@ -226,8 +229,8 @@ func (n *IpcHandler) PutService(service ipc.PutServiceArgs, reply *string) error
 	return nil
 }
 
-func (n *IpcHandler) DeleteService(service string, reply *string) error {
-	err := n.Server.GetMeshManager().RemoveService(service)
+func (n *IpcHandler) DeleteService(service ipc.DeleteServiceArgs, reply *string) error {
+	err := n.Server.GetMeshManager().RemoveService(service.MeshId, service.Service)
 
 	if err != nil {
 		return err

pkg/robin/requester_test.go

@@ -3,10 +3,10 @@ package robin
 import (
 	"testing"
 
-	"github.com/tim-beatham/wgmesh/pkg/conf"
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/ipc"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/ipc"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 )
 
 func getRequester() *IpcHandler {

pkg/robin/responder.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"errors"
 
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/rpc"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/rpc"
 )
 
 type WgRpc struct {

pkg/robin/responder_test.go

@@ -1 +0,0 @@
-package robin

pkg/route/route.go

@@ -1,7 +1,7 @@
 package route
 
 import (
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 	"golang.org/x/sys/unix"
 )
 

pkg/sync/syncer.go

@@ -7,11 +7,11 @@ import (
 	"sync"
 	"time"
 
-	"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"
+	"github.com/tim-beatham/smegmesh/pkg/conf"
+	"github.com/tim-beatham/smegmesh/pkg/conn"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 )
 
 // Syncer: picks random nodes from the meshs
@@ -27,7 +27,8 @@ type SyncerImpl struct {
 	syncCount      int
 	cluster        conn.ConnCluster
 	conf           *conf.DaemonConfiguration
-	lastSync       map[string]uint64
+	lastSync       map[string]int64
+	lock           sync.RWMutex
 }
 
 // Sync: Sync with random nodes
@@ -38,11 +39,10 @@ func (s *SyncerImpl) Sync(correspondingMesh mesh.MeshProvider) error {
 
 	// Self can be nil if the node is removed
 	selfID := s.manager.GetPublicKey()
-	self, _ := correspondingMesh.GetNode(selfID.String())
+	self, err := correspondingMesh.GetNode(selfID.String())
 
-	// Mesh has been removed
-	if self == nil {
-		return fmt.Errorf("mesh %s does not exist", correspondingMesh.GetMeshId())
+	if err != nil {
+		logging.Log.WriteErrorf(err.Error())
 	}
 
 	correspondingMesh.Prune()
@@ -51,11 +51,12 @@ func (s *SyncerImpl) Sync(correspondingMesh mesh.MeshProvider) error {
 		logging.Log.WriteInfof("meshes %s has changes", correspondingMesh.GetMeshId())
 	}
 
-	if self.GetType() == conf.PEER_ROLE && !correspondingMesh.HasChanges() && s.infectionCount == 0 {
+	// If removed sync with other nodes to gossip the node is removed
+	if self != nil && self.GetType() == conf.PEER_ROLE && !correspondingMesh.HasChanges() && s.infectionCount == 0 {
 		logging.Log.WriteInfof("no changes for %s", correspondingMesh.GetMeshId())
 
-		// If not synchronised in certain pull from random neighbour
-		if uint64(time.Now().Unix())-s.lastSync[correspondingMesh.GetMeshId()] > 20 {
+		// If not synchronised in certain time pull from random neighbour
+		if s.conf.PullTime != 0 && time.Now().Unix()-s.lastSync[correspondingMesh.GetMeshId()] > int64(s.conf.PullTime) {
 			return s.Pull(self, correspondingMesh)
 		}
 
@@ -63,16 +64,19 @@ func (s *SyncerImpl) Sync(correspondingMesh mesh.MeshProvider) error {
 	}
 
 	before := time.Now()
-	s.manager.GetRouteManager().UpdateRoutes()
+	err = s.manager.GetRouteManager().UpdateRoutes()
+
+	if err != nil {
+		logging.Log.WriteErrorf(err.Error())
+	}
 
 	publicKey := s.manager.GetPublicKey()
 	nodeNames := correspondingMesh.GetPeers()
 
-	if self != nil {
-		nodeNames = lib.Filter(nodeNames, func(s string) bool {
-			return s != mesh.NodeID(self)
-		})
-	}
+	nodeNames = lib.Filter(nodeNames, func(s string) bool {
+		// Filter our only public key out so we dont sync with ourself
+		return s != publicKey.String()
+	})
 
 	var gossipNodes []string
 
@@ -84,7 +88,9 @@ func (s *SyncerImpl) Sync(correspondingMesh mesh.MeshProvider) error {
 			return nil
 		}
 
-		redundancyLength := min(len(neighbours), 3)
+		// Peer with 2 nodes so that there is redundnacy in
+		// the situation the node leaves pre-emptively
+		redundancyLength := min(len(neighbours), 2)
 		gossipNodes = neighbours[:redundancyLength]
 	} else {
 		neighbours := s.cluster.GetNeighbours(nodeNames, publicKey.String())
@@ -99,38 +105,39 @@ func (s *SyncerImpl) Sync(correspondingMesh mesh.MeshProvider) error {
 
 	// Do this synchronously to conserve bandwidth
 	for _, node := range gossipNodes {
-		correspondingPeer := s.manager.GetNode(correspondingMesh.GetMeshId(), node)
+		correspondingPeer, err := correspondingMesh.GetNode(node)
 
-		if correspondingPeer == nil {
+		if correspondingPeer == nil || err != nil {
 			logging.Log.WriteErrorf("node %s does not exist", node)
 			continue
 		}
 
-		err := s.requester.SyncMesh(correspondingMesh.GetMeshId(), correspondingPeer)
+		err = s.requester.SyncMesh(correspondingMesh.GetMeshId(), correspondingPeer)
 
 		if err == nil || err == io.EOF {
 			succeeded = true
 		}
 
 		if err != nil {
-			logging.Log.WriteInfof(err.Error())
+			logging.Log.WriteErrorf(err.Error())
 		}
 	}
 
 	s.syncCount++
-	logging.Log.WriteInfof("SYNC TIME: %v", time.Since(before))
-	logging.Log.WriteInfof("SYNC COUNT: %d", s.syncCount)
+	logging.Log.WriteInfof("sync time: %v", time.Since(before))
+	logging.Log.WriteInfof("number of syncs: %d", s.syncCount)
 
 	s.infectionCount = ((s.conf.InfectionCount + s.infectionCount - 1) % s.conf.InfectionCount)
 
 	if !succeeded {
-		// If could not gossip with anyone then repeat.
 		s.infectionCount++
 	}
 
 	correspondingMesh.SaveChanges()
 
-	s.lastSync[correspondingMesh.GetMeshId()] = uint64(time.Now().Unix())
+	s.lock.Lock()
+	s.lastSync[correspondingMesh.GetMeshId()] = time.Now().Unix()
+	s.lock.Unlock()
 	return nil
 }
 
@@ -148,7 +155,7 @@ func (s *SyncerImpl) Pull(self mesh.MeshNode, mesh mesh.MeshProvider) error {
 		return nil
 	}
 
-	logging.Log.WriteInfof("PULLING from node %s", neighbour[0])
+	logging.Log.WriteInfof("pulling from node %s", neighbour[0])
 
 	pullNode, err := mesh.GetNode(neighbour[0])
 
@@ -159,7 +166,7 @@ func (s *SyncerImpl) Pull(self mesh.MeshNode, mesh mesh.MeshProvider) error {
 	err = s.requester.SyncMesh(mesh.GetMeshId(), pullNode)
 
 	if err == nil || err == io.EOF {
-		s.lastSync[mesh.GetMeshId()] = uint64(time.Now().Unix())
+		s.lastSync[mesh.GetMeshId()] = time.Now().Unix()
 	} else {
 		return err
 	}
@@ -187,6 +194,7 @@ func (s *SyncerImpl) SyncMeshes() error {
 
 		go sync()
 	}
+	wg.Wait()
 
 	logging.Log.WriteInfof("updating the WireGuard configuration")
 	err := s.manager.ApplyConfig()
@@ -206,5 +214,5 @@ func NewSyncer(m mesh.MeshManager, conf *conf.DaemonConfiguration, r SyncRequest
 		infectionCount: 0,
 		syncCount:      0,
 		cluster:        cluster,
-		lastSync:       make(map[string]uint64)}
+		lastSync:       make(map[string]int64)}
 }

pkg/sync/syncererror.go

@@ -1,9 +1,9 @@
 package sync
 
 import (
-	"github.com/tim-beatham/wgmesh/pkg/conn"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/conn"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )

pkg/sync/syncrequester.go

@@ -6,10 +6,10 @@ import (
 	"io"
 	"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/rpc"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/rpc"
 )
 
 // SyncRequester: coordinates the syncing of meshes
@@ -91,7 +91,7 @@ func (s *SyncRequesterImpl) SyncMesh(meshId string, meshNode mesh.MeshNode) erro
 
 	c := rpc.NewSyncServiceClient(client)
 
-	syncTimeOut := float64(s.server.Conf.SyncRate) * float64(time.Second)
+	syncTimeOut := float64(s.server.Conf.SyncTime) * float64(time.Second)
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(syncTimeOut))
 	defer cancel()
@@ -99,11 +99,11 @@ func (s *SyncRequesterImpl) SyncMesh(meshId string, meshNode mesh.MeshNode) erro
 	err = s.syncMesh(mesh, ctx, c)
 
 	if err != nil {
-		return s.handleErr(meshId, pubKey.String(), err)
+		s.handleErr(meshId, pubKey.String(), err)
 	}
 
 	logging.Log.WriteInfof("Synced with node: %s meshId: %s\n", endpoint, meshId)
-	return nil
+	return err
 }
 
 func (s *SyncRequesterImpl) syncMesh(mesh mesh.MeshProvider, ctx context.Context, client rpc.SyncServiceClient) error {

pkg/sync/syncscheduler.go

@@ -1,8 +1,8 @@
 package sync
 
 import (
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
 )
 
 // Run implements SyncScheduler.
@@ -14,5 +14,5 @@ func syncFunction(syncer Syncer) lib.TimerFunc {
 }
 
 func NewSyncScheduler(s *ctrlserver.MeshCtrlServer, syncRequester SyncRequester, syncer Syncer) *lib.Timer {
-	return lib.NewTimer(syncFunction(syncer), s.Conf.SyncRate)
+	return lib.NewTimer(syncFunction(syncer), s.Conf.SyncTime)
 }

pkg/sync/syncservice.go

@@ -6,9 +6,9 @@ import (
 	"errors"
 	"io"
 
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/mesh"
-	"github.com/tim-beatham/wgmesh/pkg/rpc"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/mesh"
+	"github.com/tim-beatham/smegmesh/pkg/rpc"
 )
 
 type SyncServiceImpl struct {

pkg/timers/timers.go

@@ -1,9 +1,9 @@
 package timer
 
 import (
-	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/ctrlserver"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 )
 
 func NewTimestampScheduler(ctrlServer *ctrlserver.MeshCtrlServer) lib.Timer {
@@ -11,5 +11,5 @@ func NewTimestampScheduler(ctrlServer *ctrlserver.MeshCtrlServer) lib.Timer {
 		logging.Log.WriteInfof("Updated Timestamp")
 		return ctrlServer.MeshManager.UpdateTimeStamp()
 	}
-	return *lib.NewTimer(timerFunc, ctrlServer.Conf.KeepAliveTime)
+	return *lib.NewTimer(timerFunc, ctrlServer.Conf.HeartBeat)
 }

pkg/wg/wg.go

@@ -5,8 +5,8 @@ import (
 	"crypto/rand"
 	"fmt"
 
-	"github.com/tim-beatham/wgmesh/pkg/lib"
-	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"github.com/tim-beatham/smegmesh/pkg/lib"
+	logging "github.com/tim-beatham/smegmesh/pkg/log"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )