Merge pull request #615 from gravitl/feature_v0.10.0_uuid_switch

Feature v0.10.0 UUID switch

controllers/auth_grpc.go

@@ -72,7 +72,7 @@ func grpcAuthorize(ctx context.Context) error {
 
 	authToken := authHeader[0]
 
-	mac, network, err := logic.VerifyToken(authToken)
+	nodeID, mac, network, err := logic.VerifyToken(authToken)
 	if err != nil {
 		return err
 	}
@@ -83,9 +83,10 @@ func grpcAuthorize(ctx context.Context) error {
 		return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: "+network)
 	}
 	emptynode := models.Node{}
-	node, err := logic.GetNodeByMacAddress(network, mac)
+	node, err := logic.GetNodeByIDorMacAddress(nodeID, mac, network)
 	if database.IsEmptyRecord(err) {
-		if node, err = logic.GetDeletedNodeByMacAddress(network, mac); err == nil {
+		// == DELETE replace logic after 2 major version updates ==
+		if node, err = logic.GetDeletedNodeByID(node.ID); err == nil {
 			if functions.RemoveDeletedNode(node.ID) {
 				return status.Errorf(codes.Unauthenticated, models.NODE_DELETE)
 			}
@@ -106,29 +107,27 @@ 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) {
 
-	//out := new(LoginResponse)
-	var reqNode models.Node
-	if err := json.Unmarshal([]byte(req.Data), &reqNode); err != nil {
+	var reqNode, err = getNewOrLegacyNode(req.Data)
+	if err != nil {
 		return nil, err
 	}
 
-	macaddress := reqNode.MacAddress
+	nodeID := reqNode.ID
 	network := reqNode.Network
 	password := reqNode.Password
+	macaddress := reqNode.MacAddress
 
 	var result models.NodeAuth
-	var err error
-	// err := errors.New("generic server error")
 
-	if macaddress == "" {
+	if nodeID == "" {
 		//TODO: Set Error  response
-		err = errors.New("missing mac address")
+		err = errors.New("missing node ID")
 		return nil, err
 	} else if password == "" {
 		err = errors.New("missing password")
 		return nil, err
 	} else {
-		//Search DB for node with Mac Address. Ignore pending nodes (they should not be able to authenticate with API until approved).
+		//Search DB for node with ID. 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
@@ -137,7 +136,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
 			if err = json.Unmarshal([]byte(value), &result); err != nil {
 				continue // finish going through nodes
 			}
-			if result.MacAddress == macaddress && result.Network == network {
+			if result.ID == nodeID && result.Network == network {
 				break
 			}
 		}
@@ -150,7 +149,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
 			return nil, err
 		} else {
 			//Create a new JWT for the node
-			tokenString, err := logic.CreateJWT(macaddress, result.Network)
+			tokenString, err := logic.CreateJWT(result.ID, macaddress, result.Network)
 
 			if err != nil {
 				return nil, err

controllers/config/dnsconfig/netmaker.hosts

@@ -1 +0,0 @@
-10.0.0.1         node-4bukt.skynet

controllers/ext_client.go

@@ -25,11 +25,11 @@ func extClientHandlers(r *mux.Router) {
 	r.HandleFunc("/api/extclients/{network}/{clientid}/{type}", securityCheck(false, http.HandlerFunc(getExtClientConf))).Methods("GET")
 	r.HandleFunc("/api/extclients/{network}/{clientid}", securityCheck(false, http.HandlerFunc(updateExtClient))).Methods("PUT")
 	r.HandleFunc("/api/extclients/{network}/{clientid}", securityCheck(false, http.HandlerFunc(deleteExtClient))).Methods("DELETE")
-	r.HandleFunc("/api/extclients/{network}/{macaddress}", securityCheck(false, http.HandlerFunc(createExtClient))).Methods("POST")
+	r.HandleFunc("/api/extclients/{network}/{nodeid}", securityCheck(false, http.HandlerFunc(createExtClient))).Methods("POST")
 }
 
-func checkIngressExists(network string, macaddress string) bool {
-	node, err := logic.GetNodeByMacAddress(network, macaddress)
+func checkIngressExists(nodeID string) bool {
+	node, err := logic.GetNodeByID(nodeID)
 	if err != nil {
 		return false
 	}
@@ -122,7 +122,7 @@ func getExtClientConf(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	gwnode, err := logic.GetNodeByMacAddress(client.Network, client.IngressGatewayID)
+	gwnode, err := logic.GetNodeByID(client.IngressGatewayID)
 	if err != nil {
 		logger.Log(1, fmt.Sprintf("%s %s %s", r.Header.Get("user"), "Could not retrieve Ingress Gateway Node", client.IngressGatewayID))
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -211,8 +211,8 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 	var params = mux.Vars(r)
 
 	networkName := params["network"]
-	macaddress := params["macaddress"]
-	ingressExists := checkIngressExists(networkName, macaddress)
+	nodeid := params["nodeid"]
+	ingressExists := checkIngressExists(nodeid)
 	if !ingressExists {
 		returnErrorResponse(w, r, formatError(errors.New("ingress does not exist"), "internal"))
 		return
@@ -220,8 +220,8 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 
 	var extclient models.ExtClient
 	extclient.Network = networkName
-	extclient.IngressGatewayID = macaddress
-	node, err := logic.GetNodeByMacAddress(networkName, macaddress)
+	extclient.IngressGatewayID = nodeid
+	node, err := logic.GetNodeByIDorMacAddress(nodeid, nodeid, networkName)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return

controllers/node.go

@@ -19,16 +19,16 @@ func nodeHandlers(r *mux.Router) {
 
 	r.HandleFunc("/api/nodes", authorize(false, "user", http.HandlerFunc(getAllNodes))).Methods("GET")
 	r.HandleFunc("/api/nodes/{network}", authorize(true, "network", http.HandlerFunc(getNetworkNodes))).Methods("GET")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/createrelay", authorize(true, "user", http.HandlerFunc(createRelay))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/deleterelay", authorize(true, "user", http.HandlerFunc(deleteRelay))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/creategateway", authorize(true, "user", http.HandlerFunc(createEgressGateway))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/deletegateway", authorize(true, "user", http.HandlerFunc(deleteEgressGateway))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/createingress", securityCheck(false, http.HandlerFunc(createIngressGateway))).Methods("POST")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/deleteingress", securityCheck(false, http.HandlerFunc(deleteIngressGateway))).Methods("DELETE")
-	r.HandleFunc("/api/nodes/{network}/{macaddress}/approve", authorize(true, "user", http.HandlerFunc(uncordonNode))).Methods("POST")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/createrelay", authorize(true, "user", http.HandlerFunc(createRelay))).Methods("POST")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/deleterelay", authorize(true, "user", http.HandlerFunc(deleteRelay))).Methods("DELETE")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/creategateway", authorize(true, "user", http.HandlerFunc(createEgressGateway))).Methods("POST")
+	r.HandleFunc("/api/nodes/{network}/{nodeid}/deletegateway", authorize(true, "user", http.HandlerFunc(deleteEgressGateway))).Methods("DELETE")
+	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/adm/{network}/lastmodified", authorize(true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
 	r.HandleFunc("/api/nodes/adm/{network}/authenticate", authenticate).Methods("POST")
@@ -78,7 +78,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 				if err := json.Unmarshal([]byte(value), &result); err != nil {
 					continue
 				}
-				if result.MacAddress == authRequest.MacAddress && result.IsPending != "yes" && result.Network == networkname {
+				if (result.ID == authRequest.ID || result.MacAddress == authRequest.MacAddress) && result.IsPending != "yes" && result.Network == networkname {
 					break
 				}
 			}
@@ -97,7 +97,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
 				returnErrorResponse(response, request, errorResponse)
 				return
 			} else {
-				tokenString, _ := logic.CreateJWT(authRequest.MacAddress, result.Network)
+				tokenString, _ := logic.CreateJWT(authRequest.ID, authRequest.MacAddress, result.Network)
 
 				if tokenString == "" {
 					errorResponse.Code = http.StatusBadRequest
@@ -177,11 +177,11 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 			}
 
 			var isAuthorized = false
-			var macaddress = ""
+			var nodeID = ""
 			username, networks, isadmin, errN := logic.VerifyUserToken(authToken)
 			isnetadmin := isadmin
 			if errN == nil && isadmin {
-				macaddress = "mastermac"
+				nodeID = "mastermac"
 				isAuthorized = true
 				r.Header.Set("ismasterkey", "yes")
 			}
@@ -191,7 +191,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 				}
 			}
 			//The mastermac (login with masterkey from config) can do everything!! May be dangerous.
-			if macaddress == "mastermac" {
+			if nodeID == "mastermac" {
 				isAuthorized = true
 				r.Header.Set("ismasterkey", "yes")
 				//for everyone else, there's poor man's RBAC. The "cases" are defined in the routes in the handlers
@@ -201,12 +201,12 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 				case "all":
 					isAuthorized = true
 				case "nodes":
-					isAuthorized = (macaddress != "") || isnetadmin
+					isAuthorized = (nodeID != "") || isnetadmin
 				case "network":
 					if isnetadmin {
 						isAuthorized = true
 					} else {
-						node, err := logic.GetNodeByMacAddress(params["network"], macaddress)
+						node, err := logic.GetNodeByID(nodeID)
 						if err != nil {
 							errorResponse = models.ErrorResponse{
 								Code: http.StatusUnauthorized, Message: "W1R3: Missing Auth Token.",
@@ -220,7 +220,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
 					if isnetadmin {
 						isAuthorized = true
 					} else {
-						isAuthorized = (macaddress == params["macaddress"])
+						isAuthorized = (nodeID == params["netid"])
 					}
 				case "user":
 					isAuthorized = true
@@ -315,12 +315,12 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 
 	var params = mux.Vars(r)
 
-	node, err := logic.GetNode(params["macaddress"], params["network"])
+	node, err := logic.GetNodeByID(params["nodeid"])
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	logger.Log(2, r.Header.Get("user"), "fetched node", params["macaddress"])
+	logger.Log(2, r.Header.Get("user"), "fetched node", params["nodeid"])
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
@@ -414,7 +414,7 @@ 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")
-	node, err := logic.UncordonNode(params["network"], params["macaddress"])
+	node, err := logic.UncordonNode(params["nodeid"])
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
@@ -434,7 +434,7 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	gateway.NetID = params["network"]
-	gateway.NodeID = params["macaddress"]
+	gateway.NodeID = params["nodeid"]
 	node, err := logic.CreateEgressGateway(gateway)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -448,14 +448,14 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
 func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
-	nodeMac := params["macaddress"]
+	nodeid := params["nodeid"]
 	netid := params["network"]
-	node, err := logic.DeleteEgressGateway(netid, nodeMac)
+	node, err := logic.DeleteEgressGateway(netid, nodeid)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeMac, "on network", netid)
+	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
@@ -465,14 +465,14 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
 func createIngressGateway(w http.ResponseWriter, r *http.Request) {
 	var params = mux.Vars(r)
 	w.Header().Set("Content-Type", "application/json")
-	nodeMac := params["macaddress"]
+	nodeid := params["nodeid"]
 	netid := params["network"]
-	node, err := logic.CreateIngressGateway(netid, nodeMac)
+	node, err := logic.CreateIngressGateway(netid, nodeid)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	logger.Log(1, r.Header.Get("user"), "created ingress gateway on node", nodeMac, "on network", netid)
+	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)
 }
@@ -480,13 +480,13 @@ func createIngressGateway(w http.ResponseWriter, r *http.Request) {
 func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
-	nodeMac := params["macaddress"]
-	node, err := logic.DeleteIngressGateway(params["network"], nodeMac)
+	nodeid := params["nodeid"]
+	node, err := logic.DeleteIngressGateway(params["network"], nodeid)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	logger.Log(1, r.Header.Get("user"), "deleted ingress gateway", nodeMac)
+	logger.Log(1, r.Header.Get("user"), "deleted ingress gateway", nodeid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }
@@ -498,7 +498,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 
 	var node models.Node
 	//start here
-	node, err := logic.GetNodeByMacAddress(params["network"], params["macaddress"])
+	node, err := logic.GetNodeByID(params["nodeid"])
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
@@ -560,17 +560,18 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 
 	// get params
 	var params = mux.Vars(r)
-	var node, err = logic.GetNode(params["macaddress"], params["network"])
+	var nodeid = params["nodeid"]
+	var node, err = logic.GetNodeByID(nodeid)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
-	err = logic.DeleteNode(&node, false)
+	err = logic.DeleteNodeByID(&node, false)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
-	logger.Log(1, r.Header.Get("user"), "Deleted node", params["macaddress"], "from network", params["network"])
-	returnSuccessResponse(w, r, params["macaddress"]+" deleted.")
+	logger.Log(1, r.Header.Get("user"), "Deleted node", nodeid, "from network", params["network"])
+	returnSuccessResponse(w, r, nodeid+" deleted.")
 }

controllers/node_grpc.go

@@ -20,16 +20,11 @@ type NodeServiceServer struct {
 
 // NodeServiceServer.ReadNode - reads node and responds with gRPC
 func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
-	// convert string id (from proto) to mongoDB ObjectId
-	macAndNetwork := strings.Split(req.Data, "###")
-
-	if len(macAndNetwork) != 2 {
-		return nil, errors.New("could not read node, invalid node id given")
-	}
-	node, err := logic.GetNode(macAndNetwork[0], macAndNetwork[1])
+	var node, err = getNewOrLegacyNode(req.Data)
 	if err != nil {
 		return nil, err
 	}
+
 	node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
 	if err != nil {
 		return nil, err
@@ -96,15 +91,13 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object)
 
 // 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
 	}
-	macaddress := newnode.MacAddress
-	networkName := newnode.Network
 
-	node, err := logic.GetNodeByMacAddress(networkName, macaddress)
+	node, err := logic.GetNodeByIDorMacAddress(newnode.ID, newnode.MacAddress, newnode.Network)
 	if err != nil {
 		return nil, err
 	}
@@ -134,13 +127,13 @@ 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 nodeInfo = strings.Split(nodeID, "###")
-	if len(nodeInfo) != 2 {
-		return nil, errors.New("node not found")
+
+	var node, err = getNewOrLegacyNode(req.Data)
+	if err != nil {
+		return nil, err
 	}
-	var node, err = logic.GetNode(nodeInfo[0], nodeInfo[1])
-	err = logic.DeleteNode(&node, true)
+
+	err = logic.DeleteNodeByID(&node, true)
 	if err != nil {
 		return nil, err
 	}
@@ -153,49 +146,42 @@ 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
-		}
 
-		peersData, err := json.Marshal(&peers)
-		logger.Log(3, node.Address, "checked in successfully")
-		return &nodepb.Object{
-			Data: string(peersData),
-			Type: nodepb.NODE_TYPE,
-		}, err
+	var node, err = getNewOrLegacyNode(req.Data)
+	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(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: "",
+		Data: string(peersData),
 		Type: nodepb.NODE_TYPE,
-	}, errors.New("could not fetch peers, invalid node id")
+	}, err
 }
 
 // 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
-	//data := &models.PeersResponse{}
-	// collection.Find returns a cursor for our (empty) query
-	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])
+
+	var node, err = getNewOrLegacyNode(req.Data)
+	if err != nil {
+		return nil, err
+	}
+
+	peers, err := logic.GetExtPeersList(&node)
 	if err != nil {
 		return nil, err
 	}
@@ -222,3 +208,27 @@ 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, "unable to get record key")
+		assert.EqualError(t, err, "could not find any records")
 	})
 	t.Run("Success", func(t *testing.T) {
 		testnode := createTestNode()
 		gateway.NetID = "skynet"
-		gateway.NodeID = testnode.MacAddress
+		gateway.NodeID = testnode.ID
 
 		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.MacAddress
+	gateway.NodeID = testnode.ID
 	t.Run("Success", func(t *testing.T) {
 		node, err := logic.CreateEgressGateway(gateway)
 		assert.Nil(t, err)
@@ -68,13 +68,8 @@ 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) {
@@ -105,18 +100,13 @@ func TestUncordonNode(t *testing.T) {
 	deleteAllNetworks()
 	createNet()
 	node := createTestNode()
-	t.Run("BadNet", func(t *testing.T) {
-		resp, err := logic.UncordonNode("badnet", node.MacAddress)
-		assert.Equal(t, models.Node{}, resp)
-		assert.EqualError(t, err, "no result found")
-	})
-	t.Run("BadMac", func(t *testing.T) {
-		resp, err := logic.UncordonNode("skynet", "01:02:03")
+	t.Run("BadID", func(t *testing.T) {
+		resp, err := logic.UncordonNode("blahblah")
 		assert.Equal(t, models.Node{}, resp)
 		assert.EqualError(t, err, "no result found")
 	})
 	t.Run("Success", func(t *testing.T) {
-		resp, err := logic.UncordonNode("skynet", node.MacAddress)
+		resp, err := logic.UncordonNode(node.ID)
 		assert.Nil(t, err)
 		assert.Equal(t, "no", resp.IsPending)
 	})
@@ -145,10 +135,7 @@ func TestValidateEgressGateway(t *testing.T) {
 }
 
 func deleteAllNodes() {
-	nodes, _ := logic.GetAllNodes()
-	for _, node := range nodes {
-		logic.DeleteNode(&node, true)
-	}
+	database.DeleteAllRecords(database.NODES_TABLE_NAME)
 }
 
 func createTestNode() *models.Node {

controllers/relay.go

@@ -20,7 +20,7 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	relay.NetID = params["network"]
-	relay.NodeID = params["macaddress"]
+	relay.NodeID = params["nodeid"]
 	node, err := logic.CreateRelay(relay)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -34,14 +34,14 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
 func deleteRelay(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
-	nodeMac := params["macaddress"]
+	nodeid := params["nodeid"]
 	netid := params["network"]
-	node, err := logic.DeleteRelay(netid, nodeMac)
+	node, err := logic.DeleteRelay(netid, nodeid)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeMac, "on network", netid)
+	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
 }

go.mod

@@ -36,6 +36,7 @@ require (
 	github.com/go-playground/locales v0.14.0 // indirect
 	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/google/go-cmp v0.5.5 // indirect
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/josharian/native v0.0.0-20200817173448-b6b71def0850 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/mdlayher/genetlink v1.0.0 // indirect

go.sum

@@ -70,6 +70,8 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+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/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4=
 github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q=
 github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=

logic/extpeers.go

@@ -11,7 +11,7 @@ import (
 )
 
 // GetExtPeersList - gets the ext peers lists
-func GetExtPeersList(macaddress string, networkName string) ([]models.ExtPeersResponse, error) {
+func GetExtPeersList(node *models.Node) ([]models.ExtPeersResponse, error) {
 
 	var peers []models.ExtPeersResponse
 	records, err := database.FetchRecords(database.EXT_CLIENT_TABLE_NAME)
@@ -33,7 +33,7 @@ func GetExtPeersList(macaddress string, networkName string) ([]models.ExtPeersRe
 			logger.Log(2, "failed to unmarshal ext client")
 			continue
 		}
-		if extClient.Network == networkName && extClient.IngressGatewayID == macaddress {
+		if extClient.Network == node.Network && extClient.IngressGatewayID == node.ID {
 			peers = append(peers, peer)
 		}
 	}

logic/gateway.go

@@ -13,7 +13,7 @@ import (
 
 // CreateEgressGateway - creates an egress gateway
 func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, error) {
-	node, err := GetNodeByMacAddress(gateway.NetID, gateway.NodeID)
+	node, err := GetNodeByID(gateway.NodeID)
 	if node.OS == "windows" || node.OS == "macos" { // add in darwin later
 		return models.Node{}, errors.New(node.OS + " is unsupported for egress gateways")
 	}
@@ -44,10 +44,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
 			postDownCmd = node.PostDown + "; " + postDownCmd
 		}
 	}
-	key, err := GetRecordKey(gateway.NodeID, gateway.NetID)
-	if err != nil {
-		return node, err
-	}
+
 	node.PostUp = postUpCmd
 	node.PostDown = postDownCmd
 	node.SetLastModified()
@@ -56,7 +53,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
 	if err != nil {
 		return node, err
 	}
-	if err = database.Insert(key, string(nodeData), database.NODES_TABLE_NAME); err != nil {
+	if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
 		return models.Node{}, err
 	}
 	if err = NetworkNodesUpdatePullChanges(node.Network); err != nil {
@@ -65,6 +62,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
 	return node, nil
 }
 
+// ValidateEgressGateway - validates the egress gateway model
 func ValidateEgressGateway(gateway models.EgressGatewayRequest) error {
 	var err error
 
@@ -80,9 +78,9 @@ func ValidateEgressGateway(gateway models.EgressGatewayRequest) error {
 }
 
 // DeleteEgressGateway - deletes egress from node
-func DeleteEgressGateway(network, macaddress string) (models.Node, error) {
+func DeleteEgressGateway(network, nodeid string) (models.Node, error) {
 
-	node, err := GetNodeByMacAddress(network, macaddress)
+	node, err := GetNodeByID(nodeid)
 	if err != nil {
 		return models.Node{}, err
 	}
@@ -97,15 +95,12 @@ func DeleteEgressGateway(network, macaddress string) (models.Node, error) {
 	}
 	node.SetLastModified()
 	node.PullChanges = "yes"
-	key, err := GetRecordKey(node.MacAddress, node.Network)
-	if err != nil {
-		return models.Node{}, err
-	}
+
 	data, err := json.Marshal(&node)
 	if err != nil {
 		return models.Node{}, err
 	}
-	if err = database.Insert(key, string(data), database.NODES_TABLE_NAME); err != nil {
+	if err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME); err != nil {
 		return models.Node{}, err
 	}
 	if err = NetworkNodesUpdatePullChanges(network); err != nil {
@@ -115,10 +110,10 @@ func DeleteEgressGateway(network, macaddress string) (models.Node, error) {
 }
 
 // CreateIngressGateway - creates an ingress gateway
-func CreateIngressGateway(netid string, macaddress string) (models.Node, error) {
+func CreateIngressGateway(netid string, nodeid string) (models.Node, error) {
 
-	node, err := GetNodeByMacAddress(netid, macaddress)
-	if node.OS == "windows" || node.OS == "macos" { // add in darwin later
+	node, err := GetNodeByID(nodeid)
+	if node.OS == "windows" || node.OS == "darwin" { // add in darwin later
 		return models.Node{}, errors.New(node.OS + " is unsupported for ingress gateways")
 	}
 
@@ -149,15 +144,12 @@ func CreateIngressGateway(netid string, macaddress string) (models.Node, error)
 	node.PostDown = postDownCmd
 	node.PullChanges = "yes"
 	node.UDPHolePunch = "no"
-	key, err := GetRecordKey(node.MacAddress, node.Network)
-	if err != nil {
-		return models.Node{}, err
-	}
+
 	data, err := json.Marshal(&node)
 	if err != nil {
 		return models.Node{}, err
 	}
-	err = database.Insert(key, string(data), database.NODES_TABLE_NAME)
+	err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 	if err != nil {
 		return models.Node{}, err
 	}
@@ -166,9 +158,9 @@ func CreateIngressGateway(netid string, macaddress string) (models.Node, error)
 }
 
 // DeleteIngressGateway - deletes an ingress gateway
-func DeleteIngressGateway(networkName string, macaddress string) (models.Node, error) {
+func DeleteIngressGateway(networkName string, nodeid string) (models.Node, error) {
 
-	node, err := GetNodeByMacAddress(networkName, macaddress)
+	node, err := GetNodeByID(nodeid)
 	if err != nil {
 		return models.Node{}, err
 	}
@@ -177,7 +169,7 @@ func DeleteIngressGateway(networkName string, macaddress string) (models.Node, e
 		return models.Node{}, err
 	}
 	// delete ext clients belonging to ingress gateway
-	if err = DeleteGatewayExtClients(macaddress, networkName); err != nil {
+	if err = DeleteGatewayExtClients(node.ID, networkName); err != nil {
 		return models.Node{}, err
 	}
 
@@ -187,15 +179,11 @@ func DeleteIngressGateway(networkName string, macaddress string) (models.Node, e
 	node.IngressGatewayRange = ""
 	node.PullChanges = "yes"
 
-	key, err := GetRecordKey(node.MacAddress, node.Network)
-	if err != nil {
-		return models.Node{}, err
-	}
 	data, err := json.Marshal(&node)
 	if err != nil {
 		return models.Node{}, err
 	}
-	err = database.Insert(key, string(data), database.NODES_TABLE_NAME)
+	err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 	if err != nil {
 		return models.Node{}, err
 	}

logic/jwts.go

@@ -12,11 +12,12 @@ import (
 var jwtSecretKey = []byte("(BytesOverTheWire)")
 
 // CreateJWT func will used to create the JWT while signing in and signing out
-func CreateJWT(macaddress string, network string) (response string, err error) {
+func CreateJWT(uuid string, macAddress string, network string) (response string, err error) {
 	expirationTime := time.Now().Add(5 * time.Minute)
 	claims := &models.Claims{
-		MacAddress: macaddress,
+		ID:         uuid,
 		Network:    network,
+		MacAddress: macAddress,
 		StandardClaims: jwt.StandardClaims{
 			ExpiresAt: expirationTime.Unix(),
 		},
@@ -73,13 +74,13 @@ func VerifyUserToken(tokenString string) (username string, networks []string, is
 }
 
 // VerifyToken - gRPC [nodes] Only
-func VerifyToken(tokenString string) (macaddress string, network string, err error) {
+func VerifyToken(tokenString string) (nodeID string, mac string, network string, err error) {
 	claims := &models.Claims{}
 
 	//this may be a stupid way of serving up a master key
 	//TODO: look into a different method. Encryption?
 	if tokenString == servercfg.GetMasterKey() {
-		return "mastermac", "", nil
+		return "mastermac", "", "", nil
 	}
 
 	token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
@@ -87,7 +88,7 @@ func VerifyToken(tokenString string) (macaddress string, network string, err err
 	})
 
 	if token != nil {
-		return claims.MacAddress, claims.Network, nil
+		return claims.ID, claims.MacAddress, claims.Network, nil
 	}
-	return "", "", err
+	return "", "", "", err
 }

logic/networks.go

@@ -47,7 +47,7 @@ func DeleteNetwork(network string) error {
 		servers, err := GetSortedNetworkServerNodes(network)
 		if err == nil {
 			for _, s := range servers {
-				if err = DeleteNode(&s, true); err != nil {
+				if err = DeleteNodeByID(&s, true); err != nil {
 					logger.Log(2, "could not removed server", s.Name, "before deleting network", network)
 				} else {
 					logger.Log(2, "removed server", s.Name, "before deleting network", network)
@@ -110,7 +110,6 @@ func NetworkNodesUpdatePullChanges(networkName string) error {
 			if err != nil {
 				return err
 			}
-			node.SetID()
 			database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 		}
 	}
@@ -355,7 +354,6 @@ func UpdateNetworkLocalAddresses(networkName string) error {
 				fmt.Println("error in node  address assignment!")
 				return err
 			}
-			node.SetID()
 			database.Insert(node.ID, string(newNodeData), database.NODES_TABLE_NAME)
 		}
 	}
@@ -387,7 +385,6 @@ func RemoveNetworkNodeIPv6Addresses(networkName string) error {
 			if err != nil {
 				return err
 			}
-			node.SetID()
 			database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 		}
 	}
@@ -424,7 +421,6 @@ func UpdateNetworkNodeAddresses(networkName string) error {
 			if err != nil {
 				return err
 			}
-			node.SetID()
 			database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 		}
 	}
@@ -630,7 +626,6 @@ func networkNodesUpdateAction(networkName string, action string) error {
 			if err != nil {
 				return err
 			}
-			node.SetID()
 			database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 		}
 	}

logic/nodes.go

@@ -5,18 +5,20 @@ import (
 	"errors"
 	"fmt"
 	"sort"
+	"strings"
 	"time"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/servercfg"
 	"github.com/gravitl/netmaker/validation"
 )
 
 // GetNetworkNodes - gets the nodes of a network
 func GetNetworkNodes(network string) ([]models.Node, error) {
-	var nodes []models.Node
+	var nodes = []models.Node{}
 	collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
 	if err != nil {
 		if database.IsEmptyRecord(err) {
@@ -64,8 +66,8 @@ func GetSortedNetworkServerNodes(network string) ([]models.Node, error) {
 }
 
 // UncordonNode - approves a node to join a network
-func UncordonNode(network, macaddress string) (models.Node, error) {
-	node, err := GetNodeByMacAddress(network, macaddress)
+func UncordonNode(nodeid string) (models.Node, error) {
+	node, err := GetNodeByID(nodeid)
 	if err != nil {
 		return models.Node{}, err
 	}
@@ -76,12 +78,8 @@ func UncordonNode(network, macaddress string) (models.Node, error) {
 	if err != nil {
 		return node, err
 	}
-	key, err := GetRecordKey(node.MacAddress, node.Network)
-	if err != nil {
-		return node, err
-	}
 
-	err = database.Insert(key, string(data), database.NODES_TABLE_NAME)
+	err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 	return node, err
 }
 
@@ -125,7 +123,6 @@ func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
 	if err := ValidateNode(newNode, true); err != nil {
 		return err
 	}
-	newNode.SetID()
 	if newNode.ID == currentNode.ID {
 		newNode.SetLastModified()
 		if data, err := json.Marshal(newNode); err != nil {
@@ -285,7 +282,6 @@ func SetNodeDefaults(node *models.Node) {
 	node.SetRoamingDefault()
 	node.SetPullChangesDefault()
 	node.SetDefaultAction()
-	node.SetID()
 	node.SetIsServerDefault()
 	node.SetIsStaticDefault()
 	node.SetDefaultEgressGateway()
@@ -298,6 +294,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")
@@ -380,3 +377,84 @@ 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
+		}
+		logger.Log(2, "rewriting legacy node data; node now has id,", node.ID)
+		node.PullChanges = "yes"
+	}
+	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)
+	if err != nil {
+		return models.Node{}, err
+	}
+	var node models.Node
+	if err = json.Unmarshal([]byte(record), &node); err != nil {
+		return models.Node{}, err
+	}
+	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
+}
+
+// GetNetworkServerNodeID - get network server node ID if exists
+func GetNetworkServerNodeID(network string) (string, error) {
+	var nodes, err = GetNetworkNodes(network)
+	if err != nil {
+		return "", err
+	}
+	for _, node := range nodes {
+		if node.IsServer == "yes" {
+			if servercfg.GetNodeID() != "" {
+				if servercfg.GetNodeID() == node.MacAddress {
+					if strings.Contains(node.ID, "###") {
+						DeleteNodeByMacAddress(&node, true)
+						logger.Log(1, "deleted legacy server node on network "+node.Network)
+						return "", errors.New("deleted legacy server node on network " + node.Network)
+					}
+					return node.ID, nil
+				}
+				continue
+			}
+			return node.ID, nil
+		}
+	}
+	return "", errors.New("could not find server node")
+}

logic/relay.go

@@ -12,13 +12,14 @@ import (
 
 // CreateRelay - creates a relay
 func CreateRelay(relay models.RelayRequest) (models.Node, error) {
-	node, err := GetNodeByMacAddress(relay.NetID, relay.NodeID)
-	if node.OS == "macos" { // add in darwin later
-		return models.Node{}, errors.New(node.OS + " is unsupported for relay")
-	}
+	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")
+	}
+
 	err = ValidateRelay(relay)
 	if err != nil {
 		return models.Node{}, err
@@ -26,17 +27,13 @@ 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(key, string(nodeData), database.NODES_TABLE_NAME); err != nil {
+	if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
 		return models.Node{}, err
 	}
 	err = SetRelayedNodes("yes", node.Network, node.RelayAddrs)
@@ -73,7 +70,6 @@ func SetRelayedNodes(yesOrno string, networkName string, addrs []string) error {
 					if err != nil {
 						return err
 					}
-					node.SetID()
 					database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 				}
 			}
@@ -107,9 +103,9 @@ func UpdateRelay(network string, oldAddrs []string, newAddrs []string) {
 }
 
 // DeleteRelay - deletes a relay
-func DeleteRelay(network, macaddress string) (models.Node, error) {
+func DeleteRelay(network, nodeid string) (models.Node, error) {
 
-	node, err := GetNodeByMacAddress(network, macaddress)
+	node, err := GetNodeByID(nodeid)
 	if err != nil {
 		return models.Node{}, err
 	}
@@ -122,15 +118,12 @@ func DeleteRelay(network, macaddress string) (models.Node, error) {
 	node.RelayAddrs = []string{}
 	node.SetLastModified()
 	node.PullChanges = "yes"
-	key, err := GetRecordKey(node.MacAddress, node.Network)
-	if err != nil {
-		return models.Node{}, err
-	}
+
 	data, err := json.Marshal(&node)
 	if err != nil {
 		return models.Node{}, err
 	}
-	if err = database.Insert(key, string(data), database.NODES_TABLE_NAME); err != nil {
+	if err = database.Insert(nodeid, string(data), database.NODES_TABLE_NAME); err != nil {
 		return models.Node{}, err
 	}
 	if err = NetworkNodesUpdatePullChanges(network); err != nil {

logic/server.go

@@ -33,16 +33,19 @@ func ServerJoin(networkSettings *models.Network, serverID string) error {
 	}
 
 	var err error
+
 	var node = &models.Node{
 		IsServer:     "yes",
 		DNSOn:        "no",
 		IsStatic:     "yes",
 		Name:         models.NODE_SERVER_NAME,
-		MacAddress:   serverID,
+		MacAddress:   servercfg.GetNodeID(),
+		ID:           "", // will be set to new uuid
 		UDPHolePunch: "no",
 		IsLocal:      networkSettings.IsLocal,
 		LocalRange:   networkSettings.LocalRange,
 	}
+
 	SetNodeDefaults(node)
 
 	if servercfg.GetPlatform() == "Kubernetes" {
@@ -113,7 +116,6 @@ func ServerJoin(networkSettings *models.Network, serverID string) error {
 		node.Endpoint = node.LocalAddress
 	}
 
-	node.SetID()
 	if err = StorePrivKey(node.ID, privateKey); err != nil {
 		return err
 	}
@@ -136,9 +138,9 @@ func ServerJoin(networkSettings *models.Network, serverID string) error {
 }
 
 // ServerCheckin - runs pulls and pushes for server
-func ServerCheckin(mac string, network string) error {
+func ServerCheckin(serverID string, mac string, network string) error {
 	var serverNode = &models.Node{}
-	var currentNode, err = GetNode(mac, network)
+	var currentNode, err = GetNodeByIDorMacAddress(serverID, mac, network)
 	if err != nil {
 		return err
 	}
@@ -146,7 +148,7 @@ func ServerCheckin(mac string, network string) error {
 
 	err = ServerPull(serverNode, false)
 	if isDeleteError(err) {
-		return ServerLeave(mac, network)
+		return ServerLeave(currentNode.ID)
 	} else if err != nil {
 		return err
 	}
@@ -209,14 +211,13 @@ func ServerPush(serverNode *models.Node) error {
 }
 
 // ServerLeave - removes a server node
-func ServerLeave(mac string, network string) error {
+func ServerLeave(serverID string) error {
 
-	var serverNode, err = GetNode(mac, network)
+	var serverNode, err = GetNodeByID(serverID)
 	if err != nil {
 		return err
 	}
-	serverNode.SetID()
-	return DeleteNode(&serverNode, true)
+	return DeleteNodeByID(&serverNode, true)
 }
 
 /**
@@ -231,7 +232,7 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
 	var peers []wgtypes.PeerConfig
 	var nodes []models.Node // fill above fields from server or client
 
-	var nodecfg, err = GetNode(serverNode.MacAddress, serverNode.Network)
+	var nodecfg, err = GetNodeByIDorMacAddress(serverNode.ID, serverNode.MacAddress, serverNode.Network)
 	if err != nil {
 		return nil, hasGateway, gateways, err
 	}
@@ -350,7 +351,7 @@ func GetServerExtPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, error) {
 	var err error
 	var tempPeers []models.ExtPeersResponse
 
-	tempPeers, err = GetExtPeersList(serverNode.MacAddress, serverNode.Network)
+	tempPeers, err = GetExtPeersList(serverNode)
 	if err != nil {
 		return nil, err
 	}
@@ -421,7 +422,7 @@ func checkNodeActions(node *models.Node) string {
 		}
 	}
 	if node.Action == models.NODE_DELETE {
-		err := ServerLeave(node.MacAddress, node.Network)
+		err := ServerLeave(node.ID)
 		if err != nil {
 			logger.Log(1, "error deleting locally:", err.Error())
 		}

logic/util.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/models"
@@ -41,14 +42,13 @@ func SetNetworkServerPeers(node *models.Node) {
 	}
 }
 
-// DeleteNode - deletes a node from database or moves into delete nodes table
-func DeleteNode(node *models.Node, exterminate bool) error {
+// DeleteNodeByMacAddress - deletes a node from database or moves into delete nodes table
+func DeleteNodeByMacAddress(node *models.Node, exterminate bool) error {
 	var err error
-	node.SetID()
 	var key = node.ID
 	if !exterminate {
 		args := strings.Split(key, "###")
-		node, err := GetNode(args[0], args[1])
+		node, err := GetNodeByMacAddress(args[0], args[1])
 		if err != nil {
 			return err
 		}
@@ -104,8 +104,16 @@ func CreateNode(node *models.Node) error {
 	if err != nil {
 		return err
 	}
+
+	// TODO: This covers legacy nodes, eventually want to remove legacy check
+	if node.IsServer == "yes" {
+		node.ID = uuid.NewString()
+	} else if node.IsServer != "yes" || (node.ID == "" || strings.Contains(node.ID, "###")) {
+		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
@@ -114,15 +122,12 @@ func CreateNode(node *models.Node) error {
 	if err != nil {
 		return err
 	}
-	key, err := GetRecordKey(node.MacAddress, node.Network)
-	if err != nil {
-		return err
-	}
+
 	nodebytes, err := json.Marshal(&node)
 	if err != nil {
 		return err
 	}
-	err = database.Insert(key, string(nodebytes), database.NODES_TABLE_NAME)
+	err = database.Insert(node.ID, string(nodebytes), database.NODES_TABLE_NAME)
 	if err != nil {
 		return err
 	}
@@ -157,28 +162,56 @@ func SetNetworkNodesLastModified(networkName string) error {
 	return nil
 }
 
-// GetNode - fetches a node from database
-func GetNode(macaddress string, network string) (models.Node, error) {
-	var node models.Node
+// // GetNode - fetches a node from database
+// func GetNode(macaddress string, network string) (models.Node, error) {
+// 	var node models.Node
 
-	key, err := GetRecordKey(macaddress, network)
-	if err != nil {
-		return node, err
-	}
-	data, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
-	if err != nil {
-		if data == "" {
-			data, _ = database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
-			err = json.Unmarshal([]byte(data), &node)
+// 	key, err := GetRecordKey(macaddress, network)
+// 	if err != nil {
+// 		return node, err
+// 	}
+// 	data, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
+// 	if err != nil {
+// 		if data == "" {
+// 			data, _ = database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
+// 			err = json.Unmarshal([]byte(data), &node)
+// 		}
+// 		return node, err
+// 	}
+// 	if err = json.Unmarshal([]byte(data), &node); err != nil {
+// 		return node, err
+// 	}
+// 	SetNodeDefaults(&node)
+
+// 	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())
 		}
-		return node, err
 	}
-	if err = json.Unmarshal([]byte(data), &node); err != nil {
-		return node, err
+	if err = database.DeleteRecord(database.NODES_TABLE_NAME, key); err != nil {
+		return err
 	}
-	SetNodeDefaults(&node)
-
-	return node, err
+	if servercfg.IsDNSMode() {
+		SetDNS()
+	}
+	return removeLocalServer(node)
 }
 
 // GetNodePeers - fetches peers for a given node

logic/wireguard.go

@@ -283,7 +283,6 @@ func setServerPeers(iface string, keepalive int32, peers []wgtypes.PeerConfig) e
 
 func setWGConfig(node *models.Node, peerupdate bool) error {
 
-	node.SetID()
 	peers, hasGateway, gateways, err := GetServerPeers(node)
 	if err != nil {
 		return err
@@ -305,7 +304,6 @@ func setWGConfig(node *models.Node, peerupdate bool) error {
 
 func setWGKeyConfig(node *models.Node) error {
 
-	node.SetID()
 	privatekey, err := wgtypes.GeneratePrivateKey()
 	if err != nil {
 		return err

models/node.go

@@ -2,7 +2,6 @@ package models
 
 import (
 	"bytes"
-	"errors"
 	"math/rand"
 	"net"
 	"strings"
@@ -24,9 +23,9 @@ const NODE_NOOP = "noop"
 var seededRand *rand.Rand = rand.New(
 	rand.NewSource(time.Now().UnixNano()))
 
-// node struct
+// Node - struct for node model
 type Node struct {
-	ID                  string   `json:"id,omitempty" bson:"id,omitempty"`
+	ID                  string   `json:"id,omitempty" bson:"id,omitempty" yaml:"id,omitempty" validate:"required,min=5"`
 	Address             string   `json:"address" bson:"address" yaml:"address" validate:"omitempty,ipv4"`
 	Address6            string   `json:"address6" bson:"address6" yaml:"address6" validate:"omitempty,ipv6"`
 	LocalAddress        string   `json:"localaddress" bson:"localaddress" yaml:"localaddress" validate:"omitempty,ip"`
@@ -47,7 +46,7 @@ type Node struct {
 	ExpirationDateTime  int64    `json:"expdatetime" bson:"expdatetime" yaml:"expdatetime"`
 	LastPeerUpdate      int64    `json:"lastpeerupdate" bson:"lastpeerupdate" yaml:"lastpeerupdate"`
 	LastCheckIn         int64    `json:"lastcheckin" bson:"lastcheckin" yaml:"lastcheckin"`
-	MacAddress          string   `json:"macaddress" bson:"macaddress" yaml:"macaddress" validate:"required,min=5,macaddress_unique"`
+	MacAddress          string   `json:"macaddress" bson:"macaddress" yaml:"macaddress"`
 	// checkin interval is depreciated at the network level. Set on server with CHECKIN_INTERVAL
 	CheckInInterval     int32    `json:"checkininterval" bson:"checkininterval" yaml:"checkininterval"`
 	Password            string   `json:"password" bson:"password" yaml:"password" validate:"required,min=6"`
@@ -73,13 +72,20 @@ type Node struct {
 	IPForwarding        string   `json:"ipforwarding" bson:"ipforwarding" yaml:"ipforwarding" validate:"checkyesorno"`
 	OS                  string   `json:"os" bson:"os" yaml:"os"`
 	MTU                 int32    `json:"mtu" bson:"mtu" yaml:"mtu"`
+	Version             string   `json:"version" bson:"version" yaml:"version"`
 }
 
+// NodesArray - used for node sorting
 type NodesArray []Node
 
-func (a NodesArray) Len() int           { return len(a) }
+// NodesArray.Len - gets length of node array
+func (a NodesArray) Len() int { return len(a) }
+
+// NodesArray.Less - gets returns lower rank of two node addresses
 func (a NodesArray) Less(i, j int) bool { return isLess(a[i].Address, a[j].Address) }
-func (a NodesArray) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// NodesArray.Swap - swaps two nodes in array
+func (a NodesArray) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 
 func isLess(ipA string, ipB string) bool {
 	ipNetA := net.ParseIP(ipA)
@@ -87,12 +93,14 @@ func isLess(ipA string, ipB string) bool {
 	return bytes.Compare(ipNetA, ipNetB) < 0
 }
 
+// Node.SetDefaultMTU - sets default MTU of a node
 func (node *Node) SetDefaultMTU() {
 	if node.MTU == 0 {
 		node.MTU = 1280
 	}
 }
 
+// Node.SetDefaulIsPending - sets ispending default
 func (node *Node) SetDefaulIsPending() {
 	if node.IsPending == "" {
 		node.IsPending = "no"
@@ -191,10 +199,6 @@ func (node *Node) SetLastPeerUpdate() {
 	node.LastPeerUpdate = time.Now().Unix()
 }
 
-func (node *Node) SetID() {
-	node.ID = node.MacAddress + "###" + node.Network
-}
-
 func (node *Node) SetExpirationDateTime() {
 	node.ExpirationDateTime = time.Now().Unix() + TEN_YEARS_IN_SECONDS
 }
@@ -206,9 +210,8 @@ func (node *Node) SetDefaultName() {
 }
 
 func (newNode *Node) Fill(currentNode *Node) {
-	if newNode.ID == "" {
-		newNode.ID = currentNode.ID
-	}
+	newNode.ID = currentNode.ID
+
 	if newNode.Address == "" && newNode.IsStatic != "yes" {
 		newNode.Address = currentNode.Address
 	}
@@ -379,10 +382,3 @@ func (node *Node) NameInNodeCharSet() bool {
 	}
 	return true
 }
-
-func (node *Node) GetID() (string, error) {
-	if node.MacAddress == "" || node.Network == "" {
-		return "", errors.New("unable to get record key")
-	}
-	return node.MacAddress + "###" + node.Network, nil
-}

models/structs.go

@@ -8,6 +8,7 @@ const PLACEHOLDER_TOKEN_TEXT = "ACCESS_TOKEN"
 // AuthParams - struct for auth params
 type AuthParams struct {
 	MacAddress string `json:"macaddress"`
+	ID         string `json:"id"`
 	Password   string `json:"password"`
 }
 
@@ -49,8 +50,9 @@ type SuccessfulUserLoginResponse struct {
 // Claims is  a struct that will be encoded to a JWT.
 // jwt.StandardClaims is an embedded type to provide expiry time
 type Claims struct {
-	Network    string
+	ID         string
 	MacAddress string
+	Network    string
 	jwt.StandardClaims
 }
 
@@ -70,7 +72,8 @@ type ErrorResponse struct {
 type NodeAuth struct {
 	Network    string
 	Password   string
-	MacAddress string
+	MacAddress string // Depricated
+	ID         string
 }
 
 // SuccessResponse is struct for sending error message with code.

netclient/auth/auth.go

@@ -55,6 +55,7 @@ func AutoLogin(client nodepb.NodeServiceClient, network string) error {
 	node := models.Node{
 		Password:   pass,
 		MacAddress: cfg.Node.MacAddress,
+		ID:         cfg.Node.ID,
 		Network:    network,
 	}
 	data, err := json.Marshal(&node)
@@ -64,6 +65,7 @@ func AutoLogin(client nodepb.NodeServiceClient, network string) error {
 
 	login := &nodepb.Object{
 		Data: string(data),
+		Type: nodepb.NODE_TYPE,
 	}
 	// RPC call
 	res, err := client.Login(context.TODO(), login)
@@ -71,7 +73,7 @@ func AutoLogin(client nodepb.NodeServiceClient, network string) error {
 		return err
 	}
 	tokenstring := []byte(res.Data)
-	err = os.WriteFile(home+"nettoken-"+network, tokenstring, 0644)
+	err = os.WriteFile(home+"nettoken-"+network, tokenstring, 0644) // TODO: Proper permissions?
 	if err != nil {
 		return err
 	}

netclient/config/config.go

@@ -97,9 +97,6 @@ func (config *ClientConfig) ReadConfig() {
 			fmt.Println("no config or invalid")
 			fmt.Println(err)
 			log.Fatal(err)
-		} else {
-			config.Node.SetID()
-			//config = cfg
 		}
 	}
 }

netclient/functions/checkin.go

@@ -186,9 +186,15 @@ func Pull(network string, manual bool) (*models.Node, error) {
 			return nil, err
 		}
 
+		data, err := json.Marshal(&node)
+		if err != nil {
+			ncutils.PrintLog("Failed to parse node config: "+err.Error(), 1)
+			return nil, err
+		}
+
 		req := &nodepb.Object{
-			Data: node.MacAddress + "###" + node.Network,
-			Type: nodepb.STRING_TYPE,
+			Data: string(data),
+			Type: nodepb.NODE_TYPE,
 		}
 
 		readres, err := wcclient.ReadNode(ctx, req, grpc.Header(&header))

netclient/functions/common.go

@@ -1,6 +1,7 @@
 package functions
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log"
@@ -102,26 +103,6 @@ func getPrivateAddrBackup() (string, error) {
 	return local, err
 }
 
-// DEPRECATED
-// func needInterfaceUpdate(ctx context.Context, mac string, network string, iface string) (bool, string, error) {
-// 	var header metadata.MD
-// 	req := &nodepb.Object{
-// 		Data: mac + "###" + network,
-// 		Type: nodepb.STRING_TYPE,
-// 	}
-// 	readres, err := wcclient.ReadNode(ctx, req, grpc.Header(&header))
-// 	if err != nil {
-// 		return false, "", err
-// 	}
-// 	var resNode models.Node
-// 	if err := json.Unmarshal([]byte(readres.Data), &resNode); err != nil {
-// 		return false, iface, err
-// 	}
-// 	oldiface := resNode.Interface
-
-// 	return iface != oldiface, oldiface, err
-// }
-
 // GetNode - gets node locally
 func GetNode(network string) models.Node {
 
@@ -184,20 +165,22 @@ func LeaveNetwork(network string) error {
 		if err != nil {
 			log.Printf("Failed to authenticate: %v", err)
 		} else { // handle client side
-			node.SetID()
 			var header metadata.MD
-			_, err = wcclient.DeleteNode(
-				ctx,
-				&nodepb.Object{
-					Data: node.ID,
-					Type: nodepb.STRING_TYPE,
-				},
-				grpc.Header(&header),
-			)
-			if err != nil {
-				ncutils.PrintLog("encountered error deleting node: "+err.Error(), 1)
-			} else {
-				ncutils.PrintLog("removed machine from "+node.Network+" network on remote server", 1)
+			nodeData, err := json.Marshal(&node)
+			if err == nil {
+				_, err = wcclient.DeleteNode(
+					ctx,
+					&nodepb.Object{
+						Data: string(nodeData),
+						Type: nodepb.NODE_TYPE,
+					},
+					grpc.Header(&header),
+				)
+				if err != nil {
+					ncutils.PrintLog("encountered error deleting node: "+err.Error(), 1)
+				} else {
+					ncutils.PrintLog("removed machine from "+node.Network+" network on remote server", 1)
+				}
 			}
 		}
 	}

netclient/functions/join.go

@@ -8,6 +8,7 @@ import (
 	"log"
 	"os/exec"
 
+	"github.com/google/uuid"
 	nodepb "github.com/gravitl/netmaker/grpc"
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/auth"
@@ -76,12 +77,15 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 		macs, err := ncutils.GetMacAddr()
 		if err != nil {
 			return err
-		} else if len(macs) == 0 {
-			log.Fatal("could not retrieve mac address")
 		} else {
 			cfg.Node.MacAddress = macs[0]
 		}
 	}
+
+	if cfg.Node.ID == "" {
+		cfg.Node.ID = uuid.NewString()
+	}
+
 	if ncutils.IsLinux() {
 		_, err := exec.LookPath("resolvconf")
 		if err != nil {
@@ -100,6 +104,7 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 	var node models.Node // fill this node with appropriate calls
 	postnode := &models.Node{
 		Password:            cfg.Node.Password,
+		ID:                  cfg.Node.ID,
 		MacAddress:          cfg.Node.MacAddress,
 		AccessKey:           cfg.Server.AccessKey,
 		IsStatic:            cfg.Node.IsStatic,

netclient/functions/list.go

@@ -98,9 +98,14 @@ func getPeers(network string) ([]Peer, error) {
 	// Instantiate the BlogServiceClient with our client connection to the server
 	wcclient = nodepb.NewNodeServiceClient(conn)
 
+	nodeData, err := json.Marshal(&nodecfg)
+	if err != nil {
+		return []Peer{}, fmt.Errorf("could not parse config node on network %s : %w", network, err)
+	}
+
 	req := &nodepb.Object{
-		Data: nodecfg.MacAddress + "###" + nodecfg.Network,
-		Type: nodepb.STRING_TYPE,
+		Data: string(nodeData),
+		Type: nodepb.NODE_TYPE,
 	}
 
 	ctx, err := auth.SetJWT(wcclient, network)

netclient/main.go

@@ -18,7 +18,7 @@ func main() {
 	app := cli.NewApp()
 	app.Name = "Netclient CLI"
 	app.Usage = "Netmaker's netclient agent and CLI. Used to perform interactions with Netmaker server and set local WireGuard config."
-	app.Version = "v0.9.4"
+	app.Version = "v0.10.0"
 
 	cliFlags := cli_options.GetFlags(ncutils.GetHostname())
 	app.Commands = cli_options.GetCommands(cliFlags[:])

netclient/server/grpc.go

@@ -101,9 +101,15 @@ func GetPeers(macaddress string, network string, server string, dualstack bool,
 		// Instantiate the BlogServiceClient with our client connection to the server
 		wcclient = nodepb.NewNodeServiceClient(conn)
 
+		nodeData, err := json.Marshal(&nodecfg)
+		if err != nil {
+			ncutils.PrintLog("could not parse node data from config during peer fetch for network "+network, 1)
+			return peers, hasGateway, gateways, err
+		}
+
 		req := &nodepb.Object{
-			Data: macaddress + "###" + network,
-			Type: nodepb.STRING_TYPE,
+			Data: string(nodeData),
+			Type: nodepb.NODE_TYPE,
 		}
 
 		ctx, err := auth.SetJWT(wcclient, network)
@@ -274,9 +280,15 @@ func GetExtPeers(macaddress string, network string, server string, dualstack boo
 		// Instantiate the BlogServiceClient with our client connection to the server
 		wcclient = nodepb.NewNodeServiceClient(conn)
 
+		nodeData, err := json.Marshal(&nodecfg)
+		if err != nil {
+			ncutils.PrintLog("could not parse node data from config during peer fetch for network "+network, 1)
+			return peers, err
+		}
+
 		req := &nodepb.Object{
-			Data: macaddress + "###" + network,
-			Type: nodepb.STRING_TYPE,
+			Data: string(nodeData),
+			Type: nodepb.NODE_TYPE,
 		}
 
 		ctx, err := auth.SetJWT(wcclient, network)

servercfg/serverconf.go

@@ -113,7 +113,7 @@ func GetAPIConnString() string {
 
 // GetVersion - version of netmaker
 func GetVersion() string {
-	version := "0.9.4"
+	version := "0.10.0"
 	if config.Config.Server.Version != "" {
 		version = config.Config.Server.Version
 	}

serverctl/serverctl.go

@@ -42,7 +42,7 @@ func FileExists(f string) bool {
 
 // RemoveNetwork - removes a network locally on server
 func RemoveNetwork(network string) (bool, error) {
-	err := logic.ServerLeave(servercfg.GetNodeID(), network)
+	err := logic.ServerLeave(network)
 	return true, err
 }
 
@@ -70,7 +70,12 @@ func HandleContainedClient() error {
 			return err
 		}
 		for _, serverNet := range servernets {
-			err = logic.ServerCheckin(servercfg.GetNodeID(), serverNet.NetID)
+			var serverID, err = logic.GetNetworkServerNodeID(serverNet.NetID)
+			if err != nil {
+				logger.Log(1, "error occurred during server checkin:", err.Error())
+				continue
+			}
+			err = logic.ServerCheckin(serverID, servercfg.GetNodeID(), serverNet.NetID)
 			if err != nil {
 				logger.Log(1, "error occurred during server checkin:", err.Error())
 			} else {