restructuring continued

controllers/auth_grpc.go

@@ -82,6 +82,7 @@ func grpcAuthorize(ctx context.Context) error {
 	if err != nil {
 		return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: "+network)
 	}
+	emptynode := models.Node{}
 	node, err := logic.GetNodeByIDorMacAddress(nodeID, mac, network)
 	if database.IsEmptyRecord(err) {
 		// == DELETE replace logic after 2 major version updates ==
@@ -93,7 +94,7 @@ func grpcAuthorize(ctx context.Context) error {
 		}
 		return status.Errorf(codes.Unauthenticated, "Empty record")
 	}
-	if err != nil || node.ID == "" {
+	if err != nil || node.MacAddress == emptynode.MacAddress {
 		return status.Errorf(codes.Unauthenticated, "Node does not exist.")
 	}
 
@@ -106,8 +107,9 @@ func grpcAuthorize(ctx context.Context) error {
 // Login - node authenticates using its password and retrieves a JWT for authorization.
 func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
 
-	var reqNode, err = getNewOrLegacyNode(req.Data)
+	//out := new(LoginResponse)
-	if err != nil {
+	var reqNode models.Node
+	if err := json.Unmarshal([]byte(req.Data), &reqNode); err != nil {
 		return nil, err
 	}
 
@@ -117,6 +119,8 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
 	macaddress := reqNode.MacAddress
 
 	var result models.NodeAuth
+	var err error
+	// err := errors.New("generic server error")
 
 	if nodeID == "" {
 		//TODO: Set Error  response
@@ -126,7 +130,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
 		err = errors.New("missing password")
 		return nil, err
 	} else {
-		//Search DB for node with ID. Ignore pending nodes (they should not be able to authenticate with API until approved).
+		//Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API until approved).
 		collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
 		if err != nil {
 			return nil, err

controllers/node.go

@@ -29,9 +29,10 @@ func nodeHandlers(r *mux.Router) {
 	r.HandleFunc("/api/nodes/{network}/{nodeid}/createingress", securityCheck(false, http.HandlerFunc(createIngressGateway))).Methods("POST")
 	r.HandleFunc("/api/nodes/{network}/{nodeid}/deleteingress", securityCheck(false, http.HandlerFunc(deleteIngressGateway))).Methods("DELETE")
 	r.HandleFunc("/api/nodes/{network}/{nodeid}/approve", authorize(true, "user", http.HandlerFunc(uncordonNode))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}", createNode).Methods("POST")
+	// r.HandleFunc("/api/nodes/{network}", createNode).Methods("POST")
 	r.HandleFunc("/api/nodes/adm/{network}/lastmodified", authorize(true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
 	r.HandleFunc("/api/nodes/adm/{network}/authenticate", authenticate).Methods("POST")
+
 }
 
 func authenticate(response http.ResponseWriter, request *http.Request) {
@@ -185,7 +186,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 				r.Header.Set("ismasterkey", "yes")
 			}
 			if !isadmin && params["network"] != "" {
-				if logic.StringSliceContains(networks, params["network"]) {
+				if functions.SliceContains(networks, params["network"]) {
 					isnetadmin = true
 				}
 			}
@@ -403,11 +404,6 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
-	if err = runServerPeerUpdate(node.Network, true); err != nil {
-		logger.Log(1, "internal error when creating node:", node.ID)
-	}
-
 	logger.Log(1, r.Header.Get("user"), "created new node", node.Name, "on network", node.Network)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -418,15 +414,11 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 func uncordonNode(w http.ResponseWriter, r *http.Request) {
 	var params = mux.Vars(r)
 	w.Header().Set("Content-Type", "application/json")
-	var nodeid = params["nodeid"]
+	node, err := logic.UncordonNode(params["nodeid"])
-	node, err := logic.UncordonNode(nodeid)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(node.Network, false); err != nil {
-		logger.Log(1, "internal error when approving node:", nodeid)
-	}
 	logger.Log(1, r.Header.Get("user"), "uncordoned node", node.Name)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode("SUCCESS")
@@ -448,9 +440,6 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(gateway.NetID, true); err != nil {
-		logger.Log(1, "internal error when setting peers after creating egress on node:", gateway.NodeID)
-	}
 	logger.Log(1, r.Header.Get("user"), "created egress gateway on node", gateway.NodeID, "on network", gateway.NetID)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -466,9 +455,6 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(netid, true); err != nil {
-		logger.Log(1, "internal error when setting peers after removing egress on node:", nodeid)
-	}
 	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -486,7 +472,6 @@ func createIngressGateway(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
 	logger.Log(1, r.Header.Get("user"), "created ingress gateway on node", nodeid, "on network", netid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -501,7 +486,6 @@ func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
 	logger.Log(1, r.Header.Get("user"), "deleted ingress gateway", nodeid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -546,14 +530,11 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 		newNode.PostUp = node.PostUp
 	}
 
-	var shouldPeersUpdate = logic.ShouldPeersUpdate(&node, &newNode)
-
 	err = logic.UpdateNode(&node, &newNode)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-
 	if relayupdate {
 		logic.UpdateRelay(node.Network, node.RelayAddrs, newNode.RelayAddrs)
 		if err = logic.NetworkNodesUpdatePullChanges(node.Network); err != nil {
@@ -561,16 +542,14 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	if servercfg.IsDNSMode() { // TODO check when this should be updated..
+	if servercfg.IsDNSMode() {
 		err = logic.SetDNS()
 	}
-
-	err = runServerPeerUpdate(node.Network, shouldPeersUpdate)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	logger.Log(1, r.Header.Get("user"), "updated node", node.ID)
+	logger.Log(1, r.Header.Get("user"), "updated node", node.MacAddress, "on network", node.Network)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(newNode)
 }
@@ -587,13 +566,7 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
-	err = logic.DeleteNodeByID(&node, false)
+	err = logic.DeleteNodeByMacAddress(&node, false)
-	if err != nil {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
-
-	err = runServerPeerUpdate(node.Network, true)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return

controllers/node_grpc.go

@@ -10,7 +10,6 @@ import (
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/mq"
 	"github.com/gravitl/netmaker/servercfg"
 )
 
@@ -21,7 +20,18 @@ type NodeServiceServer struct {
 
 // NodeServiceServer.ReadNode - reads node and responds with gRPC
 func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-	var node, err = getNewOrLegacyNode(req.Data)
+	// convert string id (from proto) to mongoDB ObjectId
+	var err error
+	var node models.Node
+	var macAndNetwork = make([]string, 2)
+	if strings.Contains(req.Data, "###") {
+		macAndNetwork = strings.Split(req.Data, "###")
+		if len(macAndNetwork) != 2 {
+			return nil, errors.New("could not read node, invalid node id given")
+		}
+	}
+
+	node, err = logic.GetNodeByIDorMacAddress(req.Data, macAndNetwork[0], macAndNetwork[1])
 	if err != nil {
 		return nil, err
 	}
@@ -86,23 +96,13 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object)
 	if err != nil {
 		return nil, err
 	}
-	// notify other nodes on network of new peer
-	if err := mq.NewPeer(node); err != nil {
-		logger.Log(0, "failed to inform peers of new node "+err.Error())
-	}
-
-	err = runServerPeerUpdate(node.Network, true)
-	if err != nil {
-		logger.Log(1, "internal error when setting peers after node,", node.ID, "was created (gRPC)")
-	}
-	logger.Log(0, "new node,", node.Name, ", added on network,"+node.Network)
 
 	return response, nil
 }
 
 // NodeServiceServer.UpdateNode updates a node and responds over gRPC
 func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
+	// Get the node data from the request
 	var newnode models.Node
 	if err := json.Unmarshal([]byte(req.GetData()), &newnode); err != nil {
 		return nil, err
@@ -117,7 +117,6 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
 		newnode.PostDown = node.PostDown
 		newnode.PostUp = node.PostUp
 	}
-	var shouldPeersUpdate = logic.ShouldPeersUpdate(&node, &newnode)
 
 	err = logic.UpdateNode(&node, &newnode)
 	if err != nil {
@@ -131,10 +130,6 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
 	if errN != nil {
 		return nil, err
 	}
-	err = runServerPeerUpdate(newnode.Network, shouldPeersUpdate)
-	if err != nil {
-		logger.Log(1, "could not update peers on gRPC after node,", newnode.ID, "updated (gRPC), \nerror:", err.Error())
-	}
 	return &nodepb.Object{
 		Data: string(nodeData),
 		Type: nodepb.NODE_TYPE,
@@ -143,26 +138,17 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
 
 // NodeServiceServer.DeleteNode - deletes a node and responds over gRPC
 func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
+	nodeID := req.GetData()
-	var node, err = getNewOrLegacyNode(req.Data)
+	var nodeInfo = strings.Split(nodeID, "###")
+	if len(nodeInfo) != 2 {
+		return nil, errors.New("node not found")
+	}
+	var node, err = logic.GetNode(nodeInfo[0], nodeInfo[1])
+	err = logic.DeleteNodeByMacAddress(&node, true)
 	if err != nil {
 		return nil, err
 	}
 
-	err = logic.DeleteNodeByID(&node, true)
-	if err != nil {
-		return nil, err
-	}
-	// notify other nodes on network of deleted peer
-	if err := mq.NewPeer(node); err != nil {
-		logger.Log(0, "failed to inform peers of deleted node "+err.Error())
-	}
-
-	err = runServerPeerUpdate(node.Network, true)
-	if err != nil {
-		logger.Log(1, "internal error when setting peers after deleting node:", node.ID, "over gRPC")
-	}
-
 	return &nodepb.Object{
 		Data: "success",
 		Type: nodepb.STRING_TYPE,
@@ -171,39 +157,49 @@ func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object)
 
 // NodeServiceServer.GetPeers - fetches peers over gRPC
 func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
+	macAndNetwork := strings.Split(req.Data, "###")
+	if len(macAndNetwork) == 2 {
+		// TODO: Make constant and new variable for isServer
+		node, err := logic.GetNode(macAndNetwork[0], macAndNetwork[1])
+		if err != nil {
+			return nil, err
+		}
+		if node.IsServer == "yes" && logic.IsLeader(&node) {
+			logic.SetNetworkServerPeers(&node)
+		}
+		excludeIsRelayed := node.IsRelay != "yes"
+		var relayedNode string
+		if node.IsRelayed == "yes" {
+			relayedNode = node.Address
+		}
+		peers, err := logic.GetPeersList(macAndNetwork[1], excludeIsRelayed, relayedNode)
+		if err != nil {
+			return nil, err
+		}
 
-	var node, err = getNewOrLegacyNode(req.Data)
+		peersData, err := json.Marshal(&peers)
-	if err != nil {
+		logger.Log(3, node.Address, "checked in successfully")
-		return nil, err
+		return &nodepb.Object{
+			Data: string(peersData),
+			Type: nodepb.NODE_TYPE,
+		}, err
 	}
-
-	excludeIsRelayed := node.IsRelay != "yes"
-	var relayedNode string
-	if node.IsRelayed == "yes" {
-		relayedNode = node.Address
-	}
-	peers, err := logic.GetPeersList(node.Network, excludeIsRelayed, relayedNode)
-	if err != nil {
-		return nil, err
-	}
-
-	peersData, err := json.Marshal(&peers)
-	logger.Log(3, node.Address, "checked in successfully")
 	return &nodepb.Object{
-		Data: string(peersData),
+		Data: "",
 		Type: nodepb.NODE_TYPE,
-	}, err
+	}, errors.New("could not fetch peers, invalid node id")
 }
 
 // NodeServiceServer.GetExtPeers - returns ext peers for a gateway node
 func (s *NodeServiceServer) GetExtPeers(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-
+	// Initiate a NodeItem type to write decoded data to
-	var node, err = getNewOrLegacyNode(req.Data)
+	//data := &models.PeersResponse{}
-	if err != nil {
+	// collection.Find returns a cursor for our (empty) query
-		return nil, err
+	macAndNetwork := strings.Split(req.Data, "###")
+	if len(macAndNetwork) != 2 {
+		return nil, errors.New("did not receive valid node id when fetching ext peers")
 	}
-
+	peers, err := logic.GetExtPeersList(macAndNetwork[0], macAndNetwork[1])
-	peers, err := logic.GetExtPeersList(&node)
 	if err != nil {
 		return nil, err
 	}
@@ -230,27 +226,3 @@ func (s *NodeServiceServer) GetExtPeers(ctx context.Context, req *nodepb.Object)
 		Type: nodepb.EXT_PEER,
 	}, nil
 }
-
-// == private methods ==
-
-func getNewOrLegacyNode(data string) (models.Node, error) {
-	var reqNode, node models.Node
-	var err error
-
-	if err = json.Unmarshal([]byte(data), &reqNode); err != nil {
-		oldID := strings.Split(data, "###") // handle legacy client IDs
-		if len(oldID) == 2 {
-			if node, err = logic.GetNodeByIDorMacAddress(reqNode.ID, oldID[0], oldID[1]); err != nil {
-				return models.Node{}, err
-			}
-		} else {
-			return models.Node{}, err
-		}
-	} else {
-		node, err = logic.GetNodeByIDorMacAddress(reqNode.ID, reqNode.MacAddress, reqNode.Network)
-		if err != nil {
-			return models.Node{}, err
-		}
-	}
-	return node, nil
-}

controllers/node_test.go

@@ -19,12 +19,12 @@ func TestCreateEgressGateway(t *testing.T) {
 	t.Run("NoNodes", func(t *testing.T) {
 		node, err := logic.CreateEgressGateway(gateway)
 		assert.Equal(t, models.Node{}, node)
-		assert.EqualError(t, err, "could not find any records")
+		assert.EqualError(t, err, "unable to get record key")
 	})
 	t.Run("Success", func(t *testing.T) {
 		testnode := createTestNode()
 		gateway.NetID = "skynet"
-		gateway.NodeID = testnode.ID
+		gateway.NodeID = testnode.MacAddress
 
 		node, err := logic.CreateEgressGateway(gateway)
 		assert.Nil(t, err)
@@ -43,7 +43,7 @@ func TestDeleteEgressGateway(t *testing.T) {
 	gateway.Interface = "eth0"
 	gateway.Ranges = []string{"10.100.100.0/24"}
 	gateway.NetID = "skynet"
-	gateway.NodeID = testnode.ID
+	gateway.NodeID = testnode.MacAddress
 	t.Run("Success", func(t *testing.T) {
 		node, err := logic.CreateEgressGateway(gateway)
 		assert.Nil(t, err)
@@ -68,8 +68,13 @@ func TestDeleteEgressGateway(t *testing.T) {
 		node, err := logic.DeleteEgressGateway(gateway.NetID, "01:02:03")
 		assert.EqualError(t, err, "no result found")
 		assert.Equal(t, models.Node{}, node)
-		deleteAllNodes()
 	})
+	t.Run("BadNet", func(t *testing.T) {
+		node, err := logic.DeleteEgressGateway("badnet", gateway.NodeID)
+		assert.EqualError(t, err, "no result found")
+		assert.Equal(t, models.Node{}, node)
+	})
+
 }
 
 func TestGetNetworkNodes(t *testing.T) {
@@ -135,7 +140,10 @@ func TestValidateEgressGateway(t *testing.T) {
 }
 
 func deleteAllNodes() {
-	database.DeleteAllRecords(database.NODES_TABLE_NAME)
+	nodes, _ := logic.GetAllNodes()
+	for _, node := range nodes {
+		logic.DeleteNodeByMacAddress(&node, true)
+	}
 }
 
 func createTestNode() *models.Node {

controllers/relay.go

@@ -26,9 +26,6 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(relay.NetID, true); err != nil {
-		logger.Log(1, "internal error when creating relay on node:", relay.NodeID)
-	}
 	logger.Log(1, r.Header.Get("user"), "created relay on node", relay.NodeID, "on network", relay.NetID)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -44,9 +41,6 @@ func deleteRelay(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(netid, true); err != nil {
-		logger.Log(1, "internal error when deleting relay on node:", nodeid)
-	}
 	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)

logic/nodes.go

@@ -64,8 +64,8 @@ func GetSortedNetworkServerNodes(network string) ([]models.Node, error) {
 }
 
 // UncordonNode - approves a node to join a network
-func UncordonNode(network, macaddress string) (models.Node, error) {
+func UncordonNode(nodeid string) (models.Node, error) {
-	node, err := GetNodeByMacAddress(network, macaddress)
+	node, err := GetNodeByID(nodeid)
 	if err != nil {
 		return models.Node{}, err
 	}
@@ -296,6 +296,7 @@ func SetNodeDefaults(node *models.Node) {
 }
 
 // GetRecordKey - get record key
+// depricated
 func GetRecordKey(id string, network string) (string, error) {
 	if id == "" || network == "" {
 		return "", errors.New("unable to get record key")
@@ -379,6 +380,28 @@ func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
 	return relay, errors.New("could not find relay for node " + relayedNodeAddr)
 }
 
+// GetNodeByIDorMacAddress - gets the node, if a mac address exists, but not id, then it should delete it and recreate in DB with new ID
+func GetNodeByIDorMacAddress(uuid string, macaddress string, network string) (models.Node, error) {
+	var node models.Node
+	var err error
+	node, err = GetNodeByID(uuid)
+	if err != nil && macaddress != "" && network != "" {
+		node, err = GetNodeByMacAddress(network, macaddress)
+		if err != nil {
+			return models.Node{}, err
+		}
+		err = DeleteNodeByMacAddress(&node, true) // remove node
+		if err != nil {
+			return models.Node{}, err
+		}
+		err = CreateNode(&node)
+		if err != nil {
+			return models.Node{}, err
+		}
+	}
+	return node, err
+}
+
 // GetNodeByID - get node by uuid, should have been set by create
 func GetNodeByID(uuid string) (models.Node, error) {
 	var record, err = database.FetchRecord(database.NODES_TABLE_NAME, uuid)
@@ -391,3 +414,22 @@ func GetNodeByID(uuid string) (models.Node, error) {
 	}
 	return node, nil
 }
+
+// GetDeletedNodeByID - get a deleted node
+func GetDeletedNodeByID(uuid string) (models.Node, error) {
+
+	var node models.Node
+
+	record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, uuid)
+	if err != nil {
+		return models.Node{}, err
+	}
+
+	if err = json.Unmarshal([]byte(record), &node); err != nil {
+		return models.Node{}, err
+	}
+
+	SetNodeDefaults(&node)
+
+	return node, nil
+}

logic/relay.go

@@ -13,13 +13,12 @@ import (
 // CreateRelay - creates a relay
 func CreateRelay(relay models.RelayRequest) (models.Node, error) {
 	node, err := GetNodeByID(relay.NodeID)
-	if err != nil {
-		return models.Node{}, err
-	}
 	if node.OS == "macos" { // add in darwin later
 		return models.Node{}, errors.New(node.OS + " is unsupported for relay")
 	}
-
+	if err != nil {
+		return models.Node{}, err
+	}
 	err = ValidateRelay(relay)
 	if err != nil {
 		return models.Node{}, err
@@ -27,13 +26,17 @@ func CreateRelay(relay models.RelayRequest) (models.Node, error) {
 	node.IsRelay = "yes"
 	node.RelayAddrs = relay.RelayAddrs
 
+	key, err := GetRecordKey(relay.NodeID, relay.NetID)
+	if err != nil {
+		return node, err
+	}
 	node.SetLastModified()
 	node.PullChanges = "yes"
 	nodeData, err := json.Marshal(&node)
 	if err != nil {
 		return node, err
 	}
-	if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
+	if err = database.Insert(key, string(nodeData), database.NODES_TABLE_NAME); err != nil {
 		return models.Node{}, err
 	}
 	err = SetRelayedNodes("yes", node.Network, node.RelayAddrs)

logic/server.go

@@ -214,7 +214,7 @@ func ServerLeave(mac string, network string) error {
 	if err != nil {
 		return err
 	}
-	return DeleteNode(&serverNode, true)
+	return DeleteNodeByMacAddress(&serverNode, true)
 }
 
 /**

logic/util.go

@@ -42,8 +42,8 @@ func SetNetworkServerPeers(node *models.Node) {
 	}
 }
 
-// DeleteNode - deletes a node from database or moves into delete nodes table
+// DeleteNodeByMacAddress - deletes a node from database or moves into delete nodes table
-func DeleteNode(node *models.Node, exterminate bool) error {
+func DeleteNodeByMacAddress(node *models.Node, exterminate bool) error {
 	var err error
 	var key = node.ID
 	if !exterminate {
@@ -104,8 +104,10 @@ func CreateNode(node *models.Node) error {
 	if err != nil {
 		return err
 	}
+	node.ID = uuid.NewString()
+
 	//Create a JWT for the node
-	tokenString, _ := CreateJWT(node.MacAddress, node.Network)
+	tokenString, _ := CreateJWT(node.ID, node.MacAddress, node.Network)
 	if tokenString == "" {
 		//returnErrorResponse(w, r, errorResponse)
 		return err
@@ -115,8 +117,6 @@ func CreateNode(node *models.Node) error {
 		return err
 	}
 
-	node.ID = uuid.NewString()
-
 	nodebytes, err := json.Marshal(&node)
 	if err != nil {
 		return err
@@ -180,6 +180,34 @@ func GetNode(macaddress string, network string) (models.Node, error) {
 	return node, err
 }
 
+// DeleteNodeByID - deletes a node from database or moves into delete nodes table
+func DeleteNodeByID(node *models.Node, exterminate bool) error {
+	var err error
+	var key = node.ID
+	if !exterminate {
+		node.Action = models.NODE_DELETE
+		nodedata, err := json.Marshal(&node)
+		if err != nil {
+			return err
+		}
+		err = database.Insert(key, string(nodedata), database.DELETED_NODES_TABLE_NAME)
+		if err != nil {
+			return err
+		}
+	} else {
+		if err := database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, key); err != nil {
+			logger.Log(2, err.Error())
+		}
+	}
+	if err = database.DeleteRecord(database.NODES_TABLE_NAME, key); err != nil {
+		return err
+	}
+	if servercfg.IsDNSMode() {
+		SetDNS()
+	}
+	return removeLocalServer(node)
+}
+
 // GetNodePeers - fetches peers for a given node
 func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error) {
 	var peers []models.Node