rebase

Signed-off-by: Matthew R. Kasun <[email protected]>

controllers/dns_test.go

@@ -53,7 +53,7 @@ func TestGetNodeDNS(t *testing.T) {
 		assert.Equal(t, "10.0.0.1", dns[0].Address)
 	})
 	t.Run("MultipleNodes", func(t *testing.T) {
-		createnode := &models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.100.100.3", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet"}
+		createnode := &models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Endpoint: "10.100.100.3", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet"}
 		err := logic.CreateNode(createnode)
 		assert.Nil(t, err)
 		dns, err := logic.GetNodeDNS("skynet")
@@ -249,33 +249,33 @@ func TestGetDNSEntry(t *testing.T) {
 	})
 }
 
-// func TestUpdateDNS(t *testing.T) {
-// 	var newentry models.DNSEntry
-// 	database.InitializeDatabase()
-// 	deleteAllDNS(t)
-// 	deleteAllNetworks()
-// 	createNet()
-// 	entry := models.DNSEntry{"10.0.0.2", "newhost", "skynet"}
-// 	CreateDNS(entry)
-// 	t.Run("change address", func(t *testing.T) {
-// 		newentry.Address = "10.0.0.75"
-// 		updated, err := UpdateDNS(newentry, entry)
-// 		assert.Nil(t, err)
-// 		assert.Equal(t, newentry.Address, updated.Address)
-// 	})
-// 	t.Run("change name", func(t *testing.T) {
-// 		newentry.Name = "newname"
-// 		updated, err := UpdateDNS(newentry, entry)
-// 		assert.Nil(t, err)
-// 		assert.Equal(t, newentry.Name, updated.Name)
-// 	})
-// 	t.Run("change network", func(t *testing.T) {
-// 		newentry.Network = "wirecat"
-// 		updated, err := UpdateDNS(newentry, entry)
-// 		assert.Nil(t, err)
-// 		assert.NotEqual(t, newentry.Network, updated.Network)
-// 	})
-// }
+//	func TestUpdateDNS(t *testing.T) {
+//		var newentry models.DNSEntry
+//		database.InitializeDatabase()
+//		deleteAllDNS(t)
+//		deleteAllNetworks()
+//		createNet()
+//		entry := models.DNSEntry{"10.0.0.2", "newhost", "skynet"}
+//		CreateDNS(entry)
+//		t.Run("change address", func(t *testing.T) {
+//			newentry.Address = "10.0.0.75"
+//			updated, err := UpdateDNS(newentry, entry)
+//			assert.Nil(t, err)
+//			assert.Equal(t, newentry.Address, updated.Address)
+//		})
+//		t.Run("change name", func(t *testing.T) {
+//			newentry.Name = "newname"
+//			updated, err := UpdateDNS(newentry, entry)
+//			assert.Nil(t, err)
+//			assert.Equal(t, newentry.Name, updated.Name)
+//		})
+//		t.Run("change network", func(t *testing.T) {
+//			newentry.Network = "wirecat"
+//			updated, err := UpdateDNS(newentry, entry)
+//			assert.Nil(t, err)
+//			assert.NotEqual(t, newentry.Network, updated.Network)
+//		})
+//	}
 func TestDeleteDNS(t *testing.T) {
 	database.InitializeDatabase()
 	deleteAllDNS(t)

controllers/docs.go

@@ -243,21 +243,21 @@ type aclContainerResponse struct {
 type nodeSliceResponse struct {
 	// Nodes
 	// in: body
-	Nodes []models.Node `json:"nodes"`
+	Nodes []models.LegacyNode `json:"nodes"`
 }
 
 // swagger:response nodeResponse
 type nodeResponse struct {
 	// Node
 	// in: body
-	Node models.Node `json:"node"`
+	Node models.LegacyNode `json:"node"`
 }
 
 // swagger:parameters updateNode deleteNode
 type nodeBodyParam struct {
 	// Node
 	// in: body
-	Node models.Node `json:"node"`
+	Node models.LegacyNode `json:"node"`
 }
 
 // swagger:parameters createRelay

controllers/network_test.go

@@ -305,7 +305,7 @@ func TestIpv6Network(t *testing.T) {
 		assert.Nil(t, err)
 		assert.Equal(t, network.AddressRange6, "fde6:be04:fa5e:d076::/64")
 	})
-	node1 := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet6", OS: "linux"}
+	node1 := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet6", OS: "linux"}
 	nodeErr := logic.CreateNode(&node1)
 	t.Run("Test node on network IPv6", func(t *testing.T) {
 		assert.Nil(t, nodeErr)

controllers/node.go

@@ -53,7 +53,7 @@ func nodeHandlers(r *mux.Router) {
 func authenticate(response http.ResponseWriter, request *http.Request) {
 
 	var authRequest models.AuthParams
-	var result models.Node
+	var result models.LegacyNode
 	var errorResponse = models.ErrorResponse{
 		Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
 	}
@@ -357,7 +357,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
-	var nodes []models.Node
+	var nodes []models.LegacyNode
 	var params = mux.Vars(r)
 	networkName := params["network"]
 
@@ -403,7 +403,7 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
-	var nodes []models.Node
+	var nodes []models.LegacyNode
 	if user.IsAdmin || r.Header.Get("ismasterkey") == "yes" {
 		nodes, err = logic.GetAllNodes()
 		if err != nil {
@@ -426,8 +426,8 @@ func getAllNodes(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(nodes)
 }
 
-func getUsersNodes(user models.User) ([]models.Node, error) {
-	var nodes []models.Node
+func getUsersNodes(user models.User) ([]models.LegacyNode, error) {
+	var nodes []models.LegacyNode
 	var err error
 	for _, networkName := range user.Networks {
 		tmpNodes, err := logic.GetNetworkNodes(networkName)
@@ -479,8 +479,8 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 	}
 
 	response := models.NodeGet{
-		Node:         node,
-		Peers:        peerUpdate.Peers,
+		Node: node,
+		//Peers:        peerUpdate.Peers,
 		ServerConfig: servercfg.GetServerInfo(),
 		PeerIDs:      peerUpdate.PeerIDs,
 	}
@@ -541,60 +541,47 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var node = models.Node{}
-
-	//get node from body of request
-	err = json.NewDecoder(r.Body).Decode(&node)
+	//get data from body of request
+	data := models.JoinData{}
+	err = json.NewDecoder(r.Body).Decode(&data)
 	if err != nil {
 		logger.Log(0, r.Header.Get("user"), "error decoding request body: ", err.Error())
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
 		return
 	}
 
-	if !logic.IsVersionComptatible(node.Version) {
+	if !logic.IsVersionComptatible(data.Host.Version) {
 		err := errors.New("incomatible netclient version")
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "badrequest"))
 		return
 	}
 
-	node.Network = networkName
+	data.Node.Network = networkName
 
-	network, err := logic.GetNetworkByNode(&node)
+	networkSettings, err := logic.GetNetworkSettings(networkName)
 	if err != nil {
 		logger.Log(0, r.Header.Get("user"),
-			fmt.Sprintf("failed to get network [%s] info: %v", node.Network, err))
+			fmt.Sprintf("failed to get network [%s] settings: %v", networkName, err))
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
-	node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
-	if err != nil {
-		logger.Log(0, r.Header.Get("user"),
-			fmt.Sprintf("failed to get network [%s] settings: %v", node.Network, err))
-		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
-		return
-	}
-	keyName, validKey := logic.IsKeyValid(networkName, node.AccessKey)
+	data.Node.NetworkSettings(networkSettings)
+	keyName, validKey := logic.IsKeyValid(networkName, data.Key)
 	if !validKey {
-		// Check to see if network will allow manual sign up
-		// may want to switch this up with the valid key check and avoid a DB call that way.
-		if network.AllowManualSignUp == "yes" {
-			node.IsPending = "yes"
-		} else {
-			errorResponse = models.ErrorResponse{
-				Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
-			}
-			logger.Log(0, r.Header.Get("user"),
-				fmt.Sprintf("failed to create node on network [%s]: %s",
-					node.Network, errorResponse.Message))
-			logic.ReturnErrorResponse(w, r, errorResponse)
-			return
+		errorResponse = models.ErrorResponse{
+			Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
 		}
+		logger.Log(0, r.Header.Get("user"),
+			fmt.Sprintf("failed to create node on network [%s]: %s",
+				data.Node.Network, errorResponse.Message))
+		logic.ReturnErrorResponse(w, r, errorResponse)
+		return
 	}
 	user, err := pro.GetNetworkUser(networkName, promodels.NetworkUserID(keyName))
 	if err == nil {
 		if user.ID != "" {
 			logger.Log(1, "associating new node with user", keyName)
-			node.OwnerID = string(user.ID)
+			data.Node.OwnerID = string(user.ID)
 		}
 	}
 
@@ -609,23 +596,22 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
-	if node.TrafficKeys.Mine == nil {
+	if data.Host.TrafficKeyPublic == nil {
 		logger.Log(0, "error: node traffic key is nil")
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
-	node.TrafficKeys = models.TrafficKeys{
-		Mine:   node.TrafficKeys.Mine,
-		Server: key,
-	}
+	server := servercfg.GetServerInfo()
+	server.TrafficKey = key
 	// consume password before hashing for mq client creation
-	nodePassword := node.Password
-	node.Server = servercfg.GetServer()
-	err = logic.CreateNode(&node)
+	nodePassword := data.Host.HostPass
+	data.Node.Server = servercfg.GetServer()
+
+	err = logic.CreateNode(&data.Node)
 	if err != nil {
 		logger.Log(0, r.Header.Get("user"),
 			fmt.Sprintf("failed to create node on network [%s]: %s",
-				node.Network, err))
+				networkName, err))
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
@@ -635,52 +621,53 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	// if it fails remove the node and fail request
 	if user != nil {
 		var updatedUserNode bool
-		user.Nodes = append(user.Nodes, node.ID) // add new node to user
+		user.Nodes = append(user.Nodes, data.Node.ID.String()) // add new node to user
 		if err = pro.UpdateNetworkUser(networkName, user); err == nil {
-			logger.Log(1, "added node", node.ID, node.Name, "to user", string(user.ID))
+			logger.Log(1, "added node", data.Node.ID.String(), data.Host.Name, "to user", string(user.ID))
 			updatedUserNode = true
 		}
 		if !updatedUserNode { // user was found but not updated, so delete node
 			logger.Log(0, "failed to add node to user", keyName)
-			logic.DeleteNode(&node, true)
+			logic.DeleteNode(&data.Node, true)
 			logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 			return
 		}
 	}
 
-	peerUpdate, err := logic.GetPeerUpdate(&node)
+	peerUpdate, err := logic.GetPeerUpdate(&data.Node)
 	if err != nil && !database.IsEmptyRecord(err) {
 		logger.Log(0, r.Header.Get("user"),
-			fmt.Sprintf("error fetching wg peers config for node [ %s ]: %v", node.ID, err))
+			fmt.Sprintf("error fetching wg peers config for node [ %s ]: %v", data.Node.ID.String(), err))
 		logic.ReturnErrorResponse(w, r, logic.FormatError(err, "internal"))
 		return
 	}
+	data.Node.Peers = peerUpdate.Peers
 
 	// Create client for this host in Mq
 	event := mq.MqDynsecPayload{
 		Commands: []mq.MqDynSecCmd{
 			{ // delete if any client exists already
 				Command:  mq.DeleteClientCmd,
-				Username: node.HostID,
+				Username: data.Host.ID.String(),
 			},
 			{
 				Command:  mq.CreateRoleCmd,
-				RoleName: node.Network,
+				RoleName: networkName,
 				Textname: "Network wide role with Acls for nodes",
-				Acls:     mq.FetchNetworkAcls(node.Network),
+				Acls:     mq.FetchNetworkAcls(networkName),
 			},
 			{
 				Command:  mq.CreateClientCmd,
-				Username: node.HostID,
+				Username: data.Host.ID.String(),
 				Password: nodePassword,
-				Textname: node.Name,
+				Textname: data.Host.Name,
 				Roles: []mq.MqDynSecRole{
 					{
 						Rolename: mq.NodeRole,
 						Priority: -1,
 					},
 					{
-						Rolename: node.Network,
+						Rolename: networkName,
 						Priority: -1,
 					},
 				},
@@ -695,16 +682,26 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	}
 
 	response := models.NodeGet{
-		Node:         node,
-		Peers:        peerUpdate.Peers,
-		ServerConfig: servercfg.GetServerInfo(),
+		Node: data.Node,
+		//Peers:        peerUpdate.Peers,
+		ServerConfig: server,
 		PeerIDs:      peerUpdate.PeerIDs,
 	}
 
-	logger.Log(1, r.Header.Get("user"), "created new node", node.Name, "on network", node.Network)
+	//host, newNode := node.ConvertToNewNode()
+	logic.SaveHost(data.Host)
+	logic.SaveNode(data.Node)
+
+	logger.Log(1, r.Header.Get("user"), "created new node", data.Host.Name, "on network", networkName)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(response)
-	runForceServerUpdate(&node, true)
+
+	go func() {
+		if err := mq.PublishPeerUpdate(data.Node, true); err != nil {
+			logger.Log(1, "failed a peer update after creation of node", data.Host.Name)
+		}
+	}()
+	//runForceServerUpdate(&data.Node, true)
 }
 
 // swagger:route POST /api/nodes/{network}/{nodeid}/approve nodes uncordonNode
@@ -912,7 +909,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 
 	var params = mux.Vars(r)
 
-	var node models.Node
+	var node models.LegacyNode
 	//start here
 	nodeid := params["nodeid"]
 	node, err := logic.GetNodeByID(nodeid)
@@ -923,7 +920,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var newNode models.Node
+	var newNode models.LegacyNode
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&newNode)
 	if err != nil {
@@ -1088,7 +1085,7 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 	runForceServerUpdate(&node, false)
 }
 
-func runUpdates(node *models.Node, ifaceDelta bool) {
+func runUpdates(node *models.LegacyNode, ifaceDelta bool) {
 	go func() { // don't block http response
 		// publish node update if not server
 		if err := mq.NodeUpdate(node); err != nil {
@@ -1103,7 +1100,7 @@ func runUpdates(node *models.Node, ifaceDelta bool) {
 }
 
 // updates local peers for a server on a given node's network
-func runServerUpdate(node *models.Node, ifaceDelta bool) error {
+func runServerUpdate(node *models.LegacyNode, ifaceDelta bool) error {
 	if servercfg.IsClientMode() != "on" || !isServer(node) {
 		return nil
 	}
@@ -1126,7 +1123,7 @@ func runServerUpdate(node *models.Node, ifaceDelta bool) error {
 	return nil
 }
 
-func runForceServerUpdate(node *models.Node, publishPeerUpdateToNode bool) {
+func runForceServerUpdate(node *models.LegacyNode, publishPeerUpdateToNode bool) {
 	go func() {
 		if err := mq.PublishPeerUpdate(node, publishPeerUpdateToNode); err != nil {
 			logger.Log(1, "failed a peer update after creation of node", node.Name)
@@ -1141,11 +1138,11 @@ func runForceServerUpdate(node *models.Node, publishPeerUpdateToNode bool) {
 	}()
 }
 
-func isServer(node *models.Node) bool {
+func isServer(node *models.LegacyNode) bool {
 	return node.IsServer == "yes"
 }
 
-func updateRelay(oldnode, newnode *models.Node) {
+func updateRelay(oldnode, newnode *models.LegacyNode) {
 	relay := logic.FindRelay(oldnode)
 	newrelay := relay
 	//check if node's address has been updated and if so, update the relayAddrs of the relay node with the updated address of the relayed node

controllers/node_test.go

@@ -21,16 +21,16 @@ func TestCreateEgressGateway(t *testing.T) {
 	createNet()
 	t.Run("NoNodes", func(t *testing.T) {
 		node, err := logic.CreateEgressGateway(gateway)
-		assert.Equal(t, models.Node{}, node)
+		assert.Equal(t, models.LegacyNode{}, node)
 		assert.EqualError(t, err, "could not find any records")
 	})
 	t.Run("Non-linux node", func(t *testing.T) {
-		createnode := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "windows"}
+		createnode := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "windows"}
 		err := logic.CreateNode(&createnode)
 		assert.Nil(t, err)
 		gateway.NodeID = createnode.ID
 		node, err := logic.CreateEgressGateway(gateway)
-		assert.Equal(t, models.Node{}, node)
+		assert.Equal(t, models.LegacyNode{}, node)
 		assert.EqualError(t, err, "windows is unsupported for egress gateways")
 	})
 	t.Run("Success-Nat-Enabled", func(t *testing.T) {
@@ -113,7 +113,7 @@ func TestDeleteEgressGateway(t *testing.T) {
 	t.Run("BadNode", func(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)
+		assert.Equal(t, models.LegacyNode{}, node)
 		deleteAllNodes()
 	})
 }
@@ -136,7 +136,7 @@ func TestGetNetworkNodes(t *testing.T) {
 		createTestNode()
 		node, err := logic.GetNetworkNodes("skynet")
 		assert.Nil(t, err)
-		assert.NotEqual(t, []models.Node(nil), node)
+		assert.NotEqual(t, []models.LegacyNode(nil), node)
 	})
 
 }
@@ -147,7 +147,7 @@ func TestUncordonNode(t *testing.T) {
 	node := createTestNode()
 	t.Run("BadID", func(t *testing.T) {
 		resp, err := logic.UncordonNode("blahblah")
-		assert.Equal(t, models.Node{}, resp)
+		assert.Equal(t, models.LegacyNode{}, resp)
 		assert.EqualError(t, err, "no result found")
 	})
 	t.Run("Success", func(t *testing.T) {
@@ -181,8 +181,8 @@ func TestValidateEgressGateway(t *testing.T) {
 
 func TestNodeACLs(t *testing.T) {
 	deleteAllNodes()
-	node1 := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
-	node2 := models.Node{PublicKey: "DM5qhLAE20FG7BbfBCger+Ac9D2NDOwCtY1rbYDXf14=", Name: "testnode", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
+	node1 := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.50", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
+	node2 := models.LegacyNode{PublicKey: "DM5qhLAE20FG7BbfBCger+Ac9D2NDOwCtY1rbYDXf14=", Name: "testnode", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
 	logic.CreateNode(&node1)
 	logic.CreateNode(&node2)
 	t.Run("acls not present", func(t *testing.T) {
@@ -222,7 +222,7 @@ func TestNodeACLs(t *testing.T) {
 		currentACL.Save(acls.ContainerID(node1.Network))
 	})
 	t.Run("node acls correct after add new node not allowed", func(t *testing.T) {
-		node3 := models.Node{PublicKey: "this-is-not-valid", Name: "testnode3", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
+		node3 := models.LegacyNode{PublicKey: "this-is-not-valid", Name: "testnode3", Endpoint: "10.0.0.100", MacAddress: "01:02:03:04:05:07", Password: "password", Network: "skynet", OS: "linux"}
 		logic.CreateNode(&node3)
 		var currentACL, err = nodeacls.FetchAllACLs(nodeacls.NetworkID(node3.Network))
 		assert.Nil(t, err)
@@ -249,8 +249,8 @@ func deleteAllNodes() {
 	database.DeleteAllRecords(database.NODES_TABLE_NAME)
 }
 
-func createTestNode() *models.Node {
-	createnode := models.Node{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
+func createTestNode() *models.LegacyNode {
+	createnode := models.LegacyNode{PublicKey: "DM5qhLAE20PG9BbfBCger+Ac9D2NDOwCtY1rbYDLf34=", Name: "testnode", Endpoint: "10.0.0.1", MacAddress: "01:02:03:04:05:06", Password: "password", Network: "skynet", OS: "linux"}
 	logic.CreateNode(&createnode)
 	return &createnode
 }

database/database.go

@@ -142,7 +142,7 @@ func createTable(tableName string) error {
 // IsJSONString - checks if valid json
 func IsJSONString(value string) bool {
 	var jsonInt interface{}
-	var nodeInt models.Node
+	var nodeInt models.LegacyNode
 	return json.Unmarshal([]byte(value), &jsonInt) == nil || json.Unmarshal([]byte(value), &nodeInt) == nil
 }
 

ee/ee_controllers/networkusers.go

@@ -34,9 +34,9 @@ type NetworkUserDataMap map[NetworkName]NetworkUserData
 
 // NetworkUserData - data struct for network users
 type NetworkUserData struct {
-	Nodes    []models.Node         `json:"nodes" bson:"nodes" yaml:"nodes"`
+	Nodes    []models.LegacyNode   `json:"nodes" bson:"nodes" yaml:"nodes"`
 	Clients  []models.ExtClient    `json:"clients" bson:"clients" yaml:"clients"`
-	Vpn      []models.Node         `json:"vpns" bson:"vpns" yaml:"vpns"`
+	Vpn      []models.LegacyNode   `json:"vpns" bson:"vpns" yaml:"vpns"`
 	Networks []models.Network      `json:"networks" bson:"networks" yaml:"networks"`
 	User     promodels.NetworkUser `json:"user" bson:"user" yaml:"user"`
 }
@@ -80,9 +80,9 @@ func getNetworkUserData(w http.ResponseWriter, r *http.Request) {
 
 		netID := networks[i].NetID
 		newData := NetworkUserData{
-			Nodes:    []models.Node{},
+			Nodes:    []models.LegacyNode{},
 			Clients:  []models.ExtClient{},
-			Vpn:      []models.Node{},
+			Vpn:      []models.LegacyNode{},
 			Networks: []models.Network{},
 		}
 		netUser, err := pro.GetNetworkUser(netID, promodels.NetworkUserID(networkUserName))

ee/logic/failover.go

@@ -7,7 +7,7 @@ import (
 )
 
 // SetFailover - finds a suitable failover candidate and sets it
-func SetFailover(node *models.Node) error {
+func SetFailover(node *models.LegacyNode) error {
 	failoverNode := determineFailoverCandidate(node)
 	if failoverNode != nil {
 		return setFailoverNode(failoverNode, node)
@@ -36,7 +36,7 @@ func ResetFailover(network string) error {
 
 // determineFailoverCandidate - returns a list of nodes that
 // are suitable for relaying a given node
-func determineFailoverCandidate(nodeToBeRelayed *models.Node) *models.Node {
+func determineFailoverCandidate(nodeToBeRelayed *models.LegacyNode) *models.LegacyNode {
 
 	currentNetworkNodes, err := logic.GetNetworkNodes(nodeToBeRelayed.Network)
 	if err != nil {
@@ -49,7 +49,7 @@ func determineFailoverCandidate(nodeToBeRelayed *models.Node) *models.Node {
 	}
 
 	minLatency := int64(9223372036854775807) // max signed int64 value
-	var fastestCandidate *models.Node
+	var fastestCandidate *models.LegacyNode
 	for i := range currentNetworkNodes {
 		if currentNetworkNodes[i].ID == nodeToBeRelayed.ID {
 			continue
@@ -67,7 +67,7 @@ func determineFailoverCandidate(nodeToBeRelayed *models.Node) *models.Node {
 }
 
 // setFailoverNode - changes node's failover node
-func setFailoverNode(failoverNode, node *models.Node) error {
+func setFailoverNode(failoverNode, node *models.LegacyNode) error {
 
 	node.FailoverNode = failoverNode.ID
 	nodeToUpdate, err := logic.GetNodeByID(node.ID)

logic/dns.go

@@ -75,7 +75,7 @@ func GetNodeDNS(network string) ([]models.DNSEntry, error) {
 
 	for _, value := range collection {
 		var entry models.DNSEntry
-		var node models.Node
+		var node models.LegacyNode
 		if err = json.Unmarshal([]byte(value), &node); err != nil {
 			continue
 		}

logic/extpeers.go

@@ -11,7 +11,7 @@ import (
 )
 
 // GetExtPeersList - gets the ext peers lists
-func GetExtPeersList(node *models.Node) ([]models.ExtPeersResponse, error) {
+func GetExtPeersList(node *models.LegacyNode) ([]models.ExtPeersResponse, error) {
 
 	var peers []models.ExtPeersResponse
 	records, err := database.FetchRecords(database.EXT_CLIENT_TABLE_NAME)
@@ -50,7 +50,7 @@ func GetEgressRangesOnNetwork(client *models.ExtClient) ([]string, error) {
 		return []string{}, err
 	}
 	for _, nodeData := range nodesData {
-		var currentNode models.Node
+		var currentNode models.LegacyNode
 		if err = json.Unmarshal([]byte(nodeData), &currentNode); err != nil {
 			continue
 		}

logic/gateway.go

@@ -14,31 +14,31 @@ import (
 )
 
 // CreateEgressGateway - creates an egress gateway
-func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, error) {
+func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.LegacyNode, error) {
 	for i, cidr := range gateway.Ranges {
 		normalized, err := NormalizeCIDR(cidr)
 		if err != nil {
-			return models.Node{}, err
+			return models.LegacyNode{}, err
 		}
 		gateway.Ranges[i] = normalized
 
 	}
 	node, err := GetNodeByID(gateway.NodeID)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	if node.OS != "linux" && node.OS != "freebsd" { // add in darwin later
-		return models.Node{}, errors.New(node.OS + " is unsupported for egress gateways")
+		return models.LegacyNode{}, errors.New(node.OS + " is unsupported for egress gateways")
 	}
 	if node.OS == "linux" && node.FirewallInUse == models.FIREWALL_NONE {
-		return models.Node{}, errors.New("firewall is not supported for egress gateways")
+		return models.LegacyNode{}, errors.New("firewall is not supported for egress gateways")
 	}
 	if gateway.NatEnabled == "" {
 		gateway.NatEnabled = "yes"
 	}
 	err = ValidateEgressGateway(gateway)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	node.IsEgressGateway = "yes"
 	node.EgressGatewayRanges = gateway.Ranges
@@ -109,7 +109,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
 		return node, err
 	}
 	if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	return node, nil
 }
@@ -130,11 +130,11 @@ func ValidateEgressGateway(gateway models.EgressGatewayRequest) error {
 }
 
 // DeleteEgressGateway - deletes egress from node
-func DeleteEgressGateway(network, nodeid string) (models.Node, error) {
+func DeleteEgressGateway(network, nodeid string) (models.LegacyNode, error) {
 
 	node, err := GetNodeByID(nodeid)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	node.IsEgressGateway = "no"
@@ -168,31 +168,31 @@ func DeleteEgressGateway(network, nodeid string) (models.Node, error) {
 
 	data, err := json.Marshal(&node)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	if err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME); err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	return node, nil
 }
 
 // CreateIngressGateway - creates an ingress gateway
-func CreateIngressGateway(netid string, nodeid string, failover bool) (models.Node, error) {
+func CreateIngressGateway(netid string, nodeid string, failover bool) (models.LegacyNode, error) {
 
 	var postUpCmd, postDownCmd string
 	node, err := GetNodeByID(nodeid)
 
 	if node.FirewallInUse == models.FIREWALL_NONE {
-		return models.Node{}, errors.New("firewall is not supported for ingress gateways")
+		return models.LegacyNode{}, errors.New("firewall is not supported for ingress gateways")
 	}
 
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	network, err := GetParentNetwork(netid)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	node.IsIngressGateway = "yes"
 	cidrs := []string{}
@@ -236,30 +236,30 @@ func CreateIngressGateway(netid string, nodeid string, failover bool) (models.No
 	}
 	data, err := json.Marshal(&node)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	err = SetNetworkNodesLastModified(netid)
 	return node, err
 }
 
 // DeleteIngressGateway - deletes an ingress gateway
-func DeleteIngressGateway(networkName string, nodeid string) (models.Node, bool, error) {
+func DeleteIngressGateway(networkName string, nodeid string) (models.LegacyNode, bool, error) {
 
 	node, err := GetNodeByID(nodeid)
 	if err != nil {
-		return models.Node{}, false, err
+		return models.LegacyNode{}, false, err
 	}
 	network, err := GetParentNetwork(networkName)
 	if err != nil {
-		return models.Node{}, false, err
+		return models.LegacyNode{}, false, err
 	}
 	// delete ext clients belonging to ingress gateway
 	if err = DeleteGatewayExtClients(node.ID, networkName); err != nil {
-		return models.Node{}, false, err
+		return models.LegacyNode{}, false, err
 	}
 	logger.Log(3, "deleting ingress gateway")
 	wasFailover := node.Failover == "yes"
@@ -286,11 +286,11 @@ func DeleteIngressGateway(networkName string, nodeid string) (models.Node, bool,
 
 	data, err := json.Marshal(&node)
 	if err != nil {
-		return models.Node{}, false, err
+		return models.LegacyNode{}, false, err
 	}
 	err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 	if err != nil {
-		return models.Node{}, wasFailover, err
+		return models.LegacyNode{}, wasFailover, err
 	}
 	err = SetNetworkNodesLastModified(networkName)
 	return node, wasFailover, err

logic/metrics.go

@@ -40,10 +40,10 @@ func DeleteMetrics(nodeid string) error {
 }
 
 // CollectServerMetrics - collects metrics for given server node
-func CollectServerMetrics(serverID string, networkNodes []models.Node) *models.Metrics {
+func CollectServerMetrics(serverID string, networkNodes []models.LegacyNode) *models.Metrics {
 	newServerMetrics := models.Metrics{}
 	newServerMetrics.Connectivity = make(map[string]models.Metric)
-	var serverNode models.Node
+	var serverNode models.LegacyNode
 	for i := range networkNodes {
 		currNodeID := networkNodes[i].ID
 		if currNodeID == serverID {

logic/metrics/metrics.go

@@ -90,7 +90,7 @@ func Collect(iface, network string, proxy bool, peerMap models.PeerMap) (*models
 }
 
 // GetExchangedBytesForNode - get exchanged bytes for current node peers
-func GetExchangedBytesForNode(node *models.Node, metrics *models.Metrics) error {
+func GetExchangedBytesForNode(node *models.LegacyNode, metrics *models.Metrics) error {
 
 	peers, err := logic.GetPeerUpdate(node)
 	if err != nil {

logic/networks.go

@@ -135,7 +135,7 @@ func GetNetworkNonServerNodeCount(networkName string) (int, error) {
 		return count, err
 	}
 	for _, value := range collection {
-		var node models.Node
+		var node models.LegacyNode
 		if err = json.Unmarshal([]byte(value), &node); err != nil {
 			return count, err
 		} else {
@@ -231,7 +231,7 @@ func IsIPUnique(network string, ip string, tableName string, isIpv6 bool) bool {
 	}
 
 	for _, value := range collection { // filter
-		var node models.Node
+		var node models.LegacyNode
 		if err = json.Unmarshal([]byte(value), &node); err != nil {
 			continue
 		}
@@ -295,7 +295,7 @@ func UniqueAddress6(networkName string, reverse bool) (string, error) {
 }
 
 // GetLocalIP - gets the local ip
-func GetLocalIP(node models.Node) string {
+func GetLocalIP(node models.LegacyNode) string {
 
 	var local string
 
@@ -361,7 +361,7 @@ func UpdateNetworkLocalAddresses(networkName string) error {
 
 	for _, value := range collection {
 
-		var node models.Node
+		var node models.LegacyNode
 
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
@@ -426,7 +426,7 @@ func RemoveNetworkNodeIPv6Addresses(networkName string) error {
 
 	for _, value := range collections {
 
-		var node models.Node
+		var node models.LegacyNode
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
 			fmt.Println("error in node address assignment!")
@@ -455,7 +455,7 @@ func UpdateNetworkNodeAddresses(networkName string) error {
 
 	for _, value := range collections {
 
-		var node models.Node
+		var node models.LegacyNode
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
 			logger.Log(1, "error in node ipv4 address assignment!")
@@ -496,7 +496,7 @@ func UpdateNetworkNodeAddresses6(networkName string) error {
 
 	for _, value := range collections {
 
-		var node models.Node
+		var node models.LegacyNode
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
 			logger.Log(1, "error in node ipv6 address assignment!")
@@ -687,7 +687,7 @@ func networkNodesUpdateAction(networkName string, action string) error {
 	}
 
 	for _, value := range collections {
-		var node models.Node
+		var node models.LegacyNode
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
 			fmt.Println("error in node address assignment!")

logic/nodes.go

@@ -33,11 +33,11 @@ const (
 )
 
 // GetNetworkNodes - gets the nodes of a network
-func GetNetworkNodes(network string) ([]models.Node, error) {
-	var nodes []models.Node
+func GetNetworkNodes(network string) ([]models.LegacyNode, error) {
+	var nodes []models.LegacyNode
 	allnodes, err := GetAllNodes()
 	if err != nil {
-		return []models.Node{}, err
+		return []models.LegacyNode{}, err
 	}
 	for _, node := range allnodes {
 		if node.Network == network {
@@ -48,18 +48,18 @@ func GetNetworkNodes(network string) ([]models.Node, error) {
 }
 
 // GetSortedNetworkServerNodes - gets nodes of a network, except sorted by update time
-func GetSortedNetworkServerNodes(network string) ([]models.Node, error) {
-	var nodes []models.Node
+func GetSortedNetworkServerNodes(network string) ([]models.LegacyNode, error) {
+	var nodes []models.LegacyNode
 	collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
 	if err != nil {
 		if database.IsEmptyRecord(err) {
-			return []models.Node{}, nil
+			return []models.LegacyNode{}, nil
 		}
 		return nodes, err
 	}
 	for _, value := range collection {
 
-		var node models.Node
+		var node models.LegacyNode
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
 			continue
@@ -73,8 +73,8 @@ func GetSortedNetworkServerNodes(network string) ([]models.Node, error) {
 }
 
 // GetServerNodes - gets the server nodes of a network
-func GetServerNodes(network string) []models.Node {
-	var serverNodes = make([]models.Node, 0)
+func GetServerNodes(network string) []models.LegacyNode {
+	var serverNodes = make([]models.LegacyNode, 0)
 	var nodes, err = GetNetworkNodes(network)
 	if err != nil {
 		return serverNodes
@@ -88,10 +88,10 @@ func GetServerNodes(network string) []models.Node {
 }
 
 // UncordonNode - approves a node to join a network
-func UncordonNode(nodeid string) (models.Node, error) {
+func UncordonNode(nodeid string) (models.LegacyNode, error) {
 	node, err := GetNodeByID(nodeid)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	node.SetLastModified()
 	node.IsPending = "no"
@@ -105,14 +105,14 @@ func UncordonNode(nodeid string) (models.Node, error) {
 }
 
 // SetIfLeader - gets the peers of a given server node
-func SetPeersIfLeader(node *models.Node) {
+func SetPeersIfLeader(node *models.LegacyNode) {
 	if IsLeader(node) {
 		setNetworkServerPeers(node)
 	}
 }
 
 // IsLeader - determines if a given server node is a leader
-func IsLeader(node *models.Node) bool {
+func IsLeader(node *models.LegacyNode) bool {
 	nodes, err := GetSortedNetworkServerNodes(node.Network)
 	if err != nil {
 		logger.Log(0, "ERROR: COULD NOT RETRIEVE SERVER NODES. THIS WILL BREAK HOLE PUNCHING.")
@@ -129,7 +129,7 @@ func IsLeader(node *models.Node) bool {
 // == DB related functions ==
 
 // UpdateNode - takes a node and updates another node with it's values
-func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
+func UpdateNode(currentNode *models.LegacyNode, newNode *models.LegacyNode) error {
 	if newNode.Address != currentNode.Address {
 		if network, err := GetParentNetwork(newNode.Network); err == nil {
 			if !IsAddressInCIDR(newNode.Address, network.AddressRange) {
@@ -168,7 +168,7 @@ func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
 }
 
 // DeleteNode - marks node for deletion if called by UI or deletes node if called by node
-func DeleteNode(node *models.Node, purge bool) error {
+func DeleteNode(node *models.LegacyNode, purge bool) error {
 	if !purge {
 		newnode := node
 		newnode.PendingDelete = true
@@ -191,7 +191,7 @@ func DeleteNode(node *models.Node, purge bool) error {
 }
 
 // DeleteNodeByID - deletes a node from database
-func DeleteNodeByID(node *models.Node) error {
+func DeleteNodeByID(node *models.LegacyNode) error {
 	var err error
 	var key = node.ID
 	//delete any ext clients as required
@@ -230,13 +230,13 @@ func DeleteNodeByID(node *models.Node) error {
 }
 
 // IsNodeIDUnique - checks if node id is unique
-func IsNodeIDUnique(node *models.Node) (bool, error) {
+func IsNodeIDUnique(node *models.LegacyNode) (bool, error) {
 	_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID)
 	return database.IsEmptyRecord(err), err
 }
 
 // ValidateNode - validates node values
-func ValidateNode(node *models.Node, isUpdate bool) error {
+func ValidateNode(node *models.LegacyNode, isUpdate bool) error {
 	v := validator.New()
 	_ = v.RegisterValidation("id_unique", func(fl validator.FieldLevel) bool {
 		if isUpdate {
@@ -279,7 +279,7 @@ func IsFailoverPresent(network string) bool {
 }
 
 // CreateNode - creates a node in database
-func CreateNode(node *models.Node) error {
+func CreateNode(node *models.LegacyNode) error {
 
 	//encrypt that password so we never see it
 	hash, err := bcrypt.GenerateFromPassword([]byte(node.Password), 5)
@@ -387,21 +387,21 @@ func CreateNode(node *models.Node) error {
 }
 
 // GetAllNodes - returns all nodes in the DB
-func GetAllNodes() ([]models.Node, error) {
-	var nodes []models.Node
+func GetAllNodes() ([]models.LegacyNode, error) {
+	var nodes []models.LegacyNode
 
 	collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
 	if err != nil {
 		if database.IsEmptyRecord(err) {
-			return []models.Node{}, nil
+			return []models.LegacyNode{}, nil
 		}
-		return []models.Node{}, err
+		return []models.LegacyNode{}, err
 	}
 
 	for _, value := range collection {
-		var node models.Node
+		var node models.LegacyNode
 		if err := json.Unmarshal([]byte(value), &node); err != nil {
-			return []models.Node{}, err
+			return []models.LegacyNode{}, err
 		}
 		// add node to our array
 		nodes = append(nodes, node)
@@ -411,13 +411,13 @@ func GetAllNodes() ([]models.Node, error) {
 }
 
 // CheckIsServer - check if a node is the server node
-func CheckIsServer(node *models.Node) bool {
+func CheckIsServer(node *models.LegacyNode) bool {
 	nodeData, err := database.FetchRecords(database.NODES_TABLE_NAME)
 	if err != nil && !database.IsEmptyRecord(err) {
 		return false
 	}
 	for _, value := range nodeData {
-		var tmpNode models.Node
+		var tmpNode models.LegacyNode
 		if err := json.Unmarshal([]byte(value), &tmpNode); err != nil {
 			continue
 		}
@@ -443,7 +443,7 @@ func GetNetworkByNode(node *models.Node) (models.Network, error) {
 }
 
 // SetNodeDefaults - sets the defaults of a node to avoid empty fields
-func SetNodeDefaults(node *models.Node) {
+func SetNodeDefaults(node *models.LegacyNode) {
 
 	//TODO: Maybe I should make Network a part of the node struct. Then we can just query the Network object for stuff.
 	parentNetwork, _ := GetNetworkByNode(node)
@@ -524,9 +524,9 @@ func GetRecordKey(id string, network string) (string, error) {
 }
 
 // GetNodeByMacAddress - gets a node by mac address
-func GetNodeByMacAddress(network string, macaddress string) (models.Node, error) {
+func GetNodeByMacAddress(network string, macaddress string) (models.LegacyNode, error) {
 
-	var node models.Node
+	var node models.LegacyNode
 
 	key, err := GetRecordKey(macaddress, network)
 	if err != nil {
@@ -535,11 +535,11 @@ func GetNodeByMacAddress(network string, macaddress string) (models.Node, error)
 
 	record, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	if err = json.Unmarshal([]byte(record), &node); err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	SetNodeDefaults(&node)
@@ -548,11 +548,11 @@ func GetNodeByMacAddress(network string, macaddress string) (models.Node, error)
 }
 
 // GetNodesByAddress - gets a node by mac address
-func GetNodesByAddress(network string, addresses []string) ([]models.Node, error) {
-	var nodes []models.Node
+func GetNodesByAddress(network string, addresses []string) ([]models.LegacyNode, error) {
+	var nodes []models.LegacyNode
 	allnodes, err := GetAllNodes()
 	if err != nil {
-		return []models.Node{}, err
+		return []models.LegacyNode{}, err
 	}
 	for _, node := range allnodes {
 		if node.Network == network && ncutils.StringSliceContains(addresses, node.Address) {
@@ -563,9 +563,9 @@ func GetNodesByAddress(network string, addresses []string) ([]models.Node, error
 }
 
 // GetDeletedNodeByMacAddress - get a deleted node
-func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node, error) {
+func GetDeletedNodeByMacAddress(network string, macaddress string) (models.LegacyNode, error) {
 
-	var node models.Node
+	var node models.LegacyNode
 
 	key, err := GetRecordKey(macaddress, network)
 	if err != nil {
@@ -574,11 +574,11 @@ func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node,
 
 	record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	if err = json.Unmarshal([]byte(record), &node); err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	SetNodeDefaults(&node)
@@ -587,9 +587,9 @@ func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node,
 }
 
 // GetNodeRelay - gets the relay node of a given network
-func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
+func GetNodeRelay(network string, relayedNodeAddr string) (models.LegacyNode, error) {
 	collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
-	var relay models.Node
+	var relay models.LegacyNode
 	if err != nil {
 		if database.IsEmptyRecord(err) {
 			return relay, nil
@@ -614,30 +614,30 @@ func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
 	return relay, errors.New(RELAY_NODE_ERR + " " + relayedNodeAddr)
 }
 
-func GetNodeByID(uuid string) (models.Node, error) {
+func GetNodeByID(uuid string) (models.LegacyNode, error) {
 	var record, err = database.FetchRecord(database.NODES_TABLE_NAME, uuid)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
-	var node models.Node
+	var node models.LegacyNode
 	if err = json.Unmarshal([]byte(record), &node); err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	return node, nil
 }
 
 // GetDeletedNodeByID - get a deleted node
-func GetDeletedNodeByID(uuid string) (models.Node, error) {
+func GetDeletedNodeByID(uuid string) (models.LegacyNode, error) {
 
-	var node models.Node
+	var node models.LegacyNode
 
 	record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, uuid)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	if err = json.Unmarshal([]byte(record), &node); err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 
 	SetNodeDefaults(&node)
@@ -646,39 +646,39 @@ func GetDeletedNodeByID(uuid string) (models.Node, error) {
 }
 
 // GetNetworkServerNodeID - get network server node ID if exists
-func GetNetworkServerLeader(network string) (models.Node, error) {
+func GetNetworkServerLeader(network string) (models.LegacyNode, error) {
 	nodes, err := GetSortedNetworkServerNodes(network)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	for _, node := range nodes {
 		if IsLeader(&node) {
 			return node, nil
 		}
 	}
-	return models.Node{}, errors.New("could not find server leader")
+	return models.LegacyNode{}, errors.New("could not find server leader")
 }
 
 // GetNetworkServerNodeID - get network server node ID if exists
-func GetNetworkServerLocal(network string) (models.Node, error) {
+func GetNetworkServerLocal(network string) (models.LegacyNode, error) {
 	nodes, err := GetSortedNetworkServerNodes(network)
 	if err != nil {
-		return models.Node{}, err
+		return models.LegacyNode{}, err
 	}
 	mac := servercfg.GetNodeID()
 	if mac == "" {
-		return models.Node{}, fmt.Errorf("error retrieving local server node: server node ID is unset")
+		return models.LegacyNode{}, fmt.Errorf("error retrieving local server node: server node ID is unset")
 	}
 	for _, node := range nodes {
 		if mac == node.MacAddress {
 			return node, nil
 		}
 	}
-	return models.Node{}, errors.New("could not find node for local server")
+	return models.LegacyNode{}, errors.New("could not find node for local server")
 }
 
 // IsLocalServer - get network server node ID if exists
-func IsLocalServer(node *models.Node) bool {
+func IsLocalServer(node *models.LegacyNode) bool {
 	var islocal bool
 	local, err := GetNetworkServerLocal(node.Network)
 	if err != nil {
@@ -688,15 +688,15 @@ func IsLocalServer(node *models.Node) bool {
 }
 
 // validateServer - make sure servers dont change port or address
-func validateServer(currentNode, newNode *models.Node) bool {
+func validateServer(currentNode, newNode *models.LegacyNode) bool {
 	return (newNode.Address == currentNode.Address &&
 		newNode.ListenPort == currentNode.ListenPort &&
 		newNode.IsServer == "yes")
 }
 
 // unsetHub - unset hub on network nodes
-func UnsetHub(networkName string) (*models.Node, error) {
-	var nodesToUpdate models.Node
+func UnsetHub(networkName string) (*models.LegacyNode, error) {
+	var nodesToUpdate models.LegacyNode
 	nodes, err := GetNetworkNodes(networkName)
 	if err != nil {
 		return &nodesToUpdate, err
@@ -718,7 +718,7 @@ func UnsetHub(networkName string) (*models.Node, error) {
 }
 
 // FindRelay - returns the node that is the relay for a relayed node
-func FindRelay(node *models.Node) *models.Node {
+func FindRelay(node *models.LegacyNode) *models.LegacyNode {
 	if node.IsRelayed == "no" {
 		return nil
 	}
@@ -739,7 +739,7 @@ func FindRelay(node *models.Node) *models.Node {
 	return nil
 }
 
-func findNode(ip string) (*models.Node, error) {
+func findNode(ip string) (*models.LegacyNode, error) {
 	nodes, err := GetAllNodes()
 	if err != nil {
 		return nil, err
@@ -756,11 +756,11 @@ func findNode(ip string) (*models.Node, error) {
 }
 
 // GetNetworkIngresses - gets the gateways of a network
-func GetNetworkIngresses(network string) ([]models.Node, error) {
-	var ingresses []models.Node
+func GetNetworkIngresses(network string) ([]models.LegacyNode, error) {
+	var ingresses []models.LegacyNode
 	netNodes, err := GetNetworkNodes(network)
 	if err != nil {
-		return []models.Node{}, err
+		return []models.LegacyNode{}, err
 	}
 	for i := range netNodes {
 		if netNodes[i].IsIngressGateway == "yes" {
@@ -772,7 +772,7 @@ func GetNetworkIngresses(network string) ([]models.Node, error) {
 
 // == PRO ==
 
-func updateProNodeACLS(node *models.Node) error {
+func updateProNodeACLS(node *models.LegacyNode) error {
 	// == PRO node ACLs ==
 	networkNodes, err := GetNetworkNodes(node.Network)
 	if err != nil {

logic/peers.go

@@ -21,7 +21,7 @@ import (
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
-func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ProxyManagerPayload, error) {
+func GetPeersForProxy(node *models.LegacyNode, onlyPeers bool) (manager.ProxyManagerPayload, error) {
 	proxyPayload := manager.ProxyManagerPayload{}
 	var peers []wgtypes.PeerConfig
 	peerConfMap := make(map[string]proxy_models.PeerConf)
@@ -167,7 +167,7 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ProxyManagerPa
 }
 
 // GetPeerUpdate - gets a wireguard peer config for each peer of a node
-func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
+func GetPeerUpdate(node *models.LegacyNode) (models.PeerUpdate, error) {
 	var peerUpdate models.PeerUpdate
 	var peers []wgtypes.PeerConfig
 	var serverNodeAddresses = []models.ServerAddr{}
@@ -349,7 +349,7 @@ func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
 	return peerUpdate, nil
 }
 
-func getExtPeers(node *models.Node, forIngressNode bool) ([]wgtypes.PeerConfig, []models.IDandAddr, error) {
+func getExtPeers(node *models.LegacyNode, forIngressNode bool) ([]wgtypes.PeerConfig, []models.IDandAddr, error) {
 	var peers []wgtypes.PeerConfig
 	var idsAndAddr []models.IDandAddr
 	extPeers, err := GetNetworkExtClients(node.Network)
@@ -428,7 +428,7 @@ func getExtPeers(node *models.Node, forIngressNode bool) ([]wgtypes.PeerConfig,
 
 }
 
-func getExtPeersForProxy(node *models.Node, proxyPeerConf map[string]proxy_models.PeerConf) ([]wgtypes.PeerConfig, map[string]proxy_models.PeerConf, error) {
+func getExtPeersForProxy(node *models.LegacyNode, proxyPeerConf map[string]proxy_models.PeerConf) ([]wgtypes.PeerConfig, map[string]proxy_models.PeerConf, error) {
 	var peers []wgtypes.PeerConfig
 
 	extPeers, err := GetNetworkExtClients(node.Network)
@@ -499,7 +499,7 @@ func getExtPeersForProxy(node *models.Node, proxyPeerConf map[string]proxy_model
 }
 
 // GetAllowedIPs - calculates the wireguard allowedip field for a peer of a node based on the peer and node settings
-func GetAllowedIPs(node, peer *models.Node, metrics *models.Metrics, fetchRelayedIps bool) []net.IPNet {
+func GetAllowedIPs(node, peer *models.LegacyNode, metrics *models.Metrics, fetchRelayedIps bool) []net.IPNet {
 	var allowedips []net.IPNet
 	allowedips = getNodeAllowedIPs(peer, node)
 
@@ -611,7 +611,7 @@ func getPeerDNS(network string) string {
 
 // GetPeerUpdateForRelayedNode - calculates peer update for a relayed node by getting the relay
 // copying the relay node's allowed ips and making appropriate substitutions
-func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string) (models.PeerUpdate, error) {
+func GetPeerUpdateForRelayedNode(node *models.LegacyNode, udppeers map[string]string) (models.PeerUpdate, error) {
 	var peerUpdate models.PeerUpdate
 	var peers []wgtypes.PeerConfig
 	var serverNodeAddresses = []models.ServerAddr{}
@@ -757,7 +757,7 @@ func GetPeerUpdateForRelayedNode(node *models.Node, udppeers map[string]string)
 	return peerUpdate, nil
 }
 
-func getEgressIPs(node, peer *models.Node) []net.IPNet {
+func getEgressIPs(node, peer *models.LegacyNode) []net.IPNet {
 	//check for internet gateway
 	internetGateway := false
 	if slices.Contains(peer.EgressGatewayRanges, "0.0.0.0/0") || slices.Contains(peer.EgressGatewayRanges, "::/0") {
@@ -789,7 +789,7 @@ func getEgressIPs(node, peer *models.Node) []net.IPNet {
 	return allowedips
 }
 
-func getNodeAllowedIPs(peer, node *models.Node) []net.IPNet {
+func getNodeAllowedIPs(peer, node *models.LegacyNode) []net.IPNet {
 	var allowedips = []net.IPNet{}
 
 	if peer.Address != "" {

logic/pro/networkuser.go

@@ -175,7 +175,7 @@ func RemoveAllNetworkUsers(network string) error {
 
 // IsUserNodeAllowed - given a list of nodes, determine if the user's node is allowed based on ID
 // Checks if node is in given nodes list as well as being in user's list
-func IsUserNodeAllowed(nodes []models.Node, network, userID, nodeID string) bool {
+func IsUserNodeAllowed(nodes []models.LegacyNode, network, userID, nodeID string) bool {
 
 	netUser, err := GetNetworkUser(network, promodels.NetworkUserID(userID))
 	if err != nil {

logic/pro/networkuser_test.go

@@ -18,8 +18,8 @@ func TestNetworkUserLogic(t *testing.T) {
 		NetID:        "skynet",
 		AddressRange: "192.168.0.0/24",
 	}
-	nodes := []models.Node{
-		models.Node{ID: "coolnode"},
+	nodes := []models.LegacyNode{
+		models.LegacyNode{ID: "coolnode"},
 	}
 
 	clients := []models.ExtClient{

logic/pro/proacls/nodes.go

@@ -7,7 +7,7 @@ import (
 )
 
 // AdjustNodeAcls - adjusts ACLs based on a node's default value
-func AdjustNodeAcls(node *models.Node, networkNodes []models.Node) error {
+func AdjustNodeAcls(node *models.LegacyNode, networkNodes []models.LegacyNode) error {
 	networkID := nodeacls.NetworkID(node.Network)
 	nodeID := nodeacls.NodeID(node.ID)
 	currentACLs, err := nodeacls.FetchAllACLs(networkID)

logic/relay.go

@@ -12,19 +12,19 @@ import (
 )
 
 // CreateRelay - creates a relay
-func CreateRelay(relay models.RelayRequest) ([]models.Node, models.Node, error) {
-	var returnnodes []models.Node
+func CreateRelay(relay models.RelayRequest) ([]models.LegacyNode, models.LegacyNode, error) {
+	var returnnodes []models.LegacyNode
 
 	node, err := GetNodeByID(relay.NodeID)
 	if err != nil {
-		return returnnodes, models.Node{}, err
+		return returnnodes, models.LegacyNode{}, err
 	}
 	if node.OS != "linux" {
-		return returnnodes, models.Node{}, fmt.Errorf("only linux machines can be relay nodes")
+		return returnnodes, models.LegacyNode{}, fmt.Errorf("only linux machines can be relay nodes")
 	}
 	err = ValidateRelay(relay)
 	if err != nil {
-		return returnnodes, models.Node{}, err
+		return returnnodes, models.LegacyNode{}, err
 	}
 	node.IsRelay = "yes"
 	node.RelayAddrs = relay.RelayAddrs
@@ -35,7 +35,7 @@ func CreateRelay(relay models.RelayRequest) ([]models.Node, models.Node, error)
 		return returnnodes, node, err
 	}
 	if err = database.Insert(node.ID, string(nodeData), database.NODES_TABLE_NAME); err != nil {
-		return returnnodes, models.Node{}, err
+		return returnnodes, models.LegacyNode{}, err
 	}
 	returnnodes, err = SetRelayedNodes(true, node.Network, node.RelayAddrs)
 	if err != nil {
@@ -45,8 +45,8 @@ func CreateRelay(relay models.RelayRequest) ([]models.Node, models.Node, error)
 }
 
 // SetRelayedNodes- set relayed nodes
-func SetRelayedNodes(setRelayed bool, networkName string, addrs []string) ([]models.Node, error) {
-	var returnnodes []models.Node
+func SetRelayedNodes(setRelayed bool, networkName string, addrs []string) ([]models.LegacyNode, error) {
+	var returnnodes []models.LegacyNode
 	networkNodes, err := GetNetworkNodes(networkName)
 	if err != nil {
 		return returnnodes, err
@@ -72,8 +72,8 @@ func SetRelayedNodes(setRelayed bool, networkName string, addrs []string) ([]mod
 	}
 	return returnnodes, nil
 }
-func GetRelayedNodes(relayNode *models.Node) ([]models.Node, error) {
-	var returnnodes []models.Node
+func GetRelayedNodes(relayNode *models.LegacyNode) ([]models.LegacyNode, error) {
+	var returnnodes []models.LegacyNode
 	networkNodes, err := GetNetworkNodes(relayNode.Network)
 	if err != nil {
 		return returnnodes, err
@@ -102,8 +102,8 @@ func ValidateRelay(relay models.RelayRequest) error {
 }
 
 // UpdateRelay - updates a relay
-func UpdateRelay(network string, oldAddrs []string, newAddrs []string) []models.Node {
-	var returnnodes []models.Node
+func UpdateRelay(network string, oldAddrs []string, newAddrs []string) []models.LegacyNode {
+	var returnnodes []models.LegacyNode
 	time.Sleep(time.Second / 4)
 	_, err := SetRelayedNodes(false, network, oldAddrs)
 	if err != nil {
@@ -117,11 +117,11 @@ func UpdateRelay(network string, oldAddrs []string, newAddrs []string) []models.
 }
 
 // DeleteRelay - deletes a relay
-func DeleteRelay(network, nodeid string) ([]models.Node, models.Node, error) {
-	var returnnodes []models.Node
+func DeleteRelay(network, nodeid string) ([]models.LegacyNode, models.LegacyNode, error) {
+	var returnnodes []models.LegacyNode
 	node, err := GetNodeByID(nodeid)
 	if err != nil {
-		return returnnodes, models.Node{}, err
+		return returnnodes, models.LegacyNode{}, err
 	}
 	returnnodes, err = SetRelayedNodes(false, node.Network, node.RelayAddrs)
 	if err != nil {
@@ -134,10 +134,10 @@ func DeleteRelay(network, nodeid string) ([]models.Node, models.Node, error) {
 
 	data, err := json.Marshal(&node)
 	if err != nil {
-		return returnnodes, models.Node{}, err
+		return returnnodes, models.LegacyNode{}, err
 	}
 	if err = database.Insert(nodeid, string(data), database.NODES_TABLE_NAME); err != nil {
-		return returnnodes, models.Node{}, err
+		return returnnodes, models.LegacyNode{}, err
 	}
 	return returnnodes, node, nil
 }

logic/server.go

@@ -25,7 +25,7 @@ var ProxyMgmChan = make(chan *manager.ProxyManagerPayload, 100)
 var EnterpriseCheckFuncs []func()
 
 // EnterpriseFailoverFunc - interface to control failover funcs
-var EnterpriseFailoverFunc func(node *models.Node) error
+var EnterpriseFailoverFunc func(node *models.LegacyNode) error
 
 // EnterpriseResetFailoverFunc - interface to control reset failover funcs
 var EnterpriseResetFailoverFunc func(network string) error
@@ -42,8 +42,8 @@ const KUBERNETES_LISTEN_PORT = 31821
 const KUBERNETES_SERVER_MTU = 1024
 
 // ServerJoin - responsible for joining a server to a network
-func ServerJoin(networkSettings *models.Network) (models.Node, error) {
-	var returnNode models.Node
+func ServerJoin(networkSettings *models.Network) (models.LegacyNode, error) {
+	var returnNode models.LegacyNode
 	if networkSettings == nil || networkSettings.NetID == "" {
 		return returnNode, errors.New("no network provided")
 	}
@@ -73,7 +73,7 @@ func ServerJoin(networkSettings *models.Network) (models.Node, error) {
 			}
 		}
 	}
-	var node = &models.Node{
+	var node = &models.LegacyNode{
 		IsServer:        "yes",
 		DNSOn:           "no",
 		IsStatic:        "yes",
@@ -197,7 +197,7 @@ func EnterpriseCheck() {
 
 // ServerUpdate - updates the server
 // replaces legacy Checkin code
-func ServerUpdate(serverNode *models.Node, ifaceDelta bool) error {
+func ServerUpdate(serverNode *models.LegacyNode, ifaceDelta bool) error {
 	if !IsLocalServer(serverNode) {
 		logger.Log(1, "skipping server update as not the leader")
 		return nil
@@ -227,7 +227,7 @@ func isDeleteError(err error) bool {
 	return err != nil && strings.Contains(err.Error(), models.NODE_DELETE)
 }
 
-func checkNodeActions(node *models.Node) string {
+func checkNodeActions(node *models.LegacyNode) string {
 	if node.Action == models.NODE_UPDATE_KEY {
 		err := setWGKeyConfig(node)
 		if err != nil {
@@ -248,7 +248,7 @@ func checkNodeActions(node *models.Node) string {
 // == Private ==
 
 // ServerPull - performs a server pull
-func ServerPull(serverNode *models.Node, ifaceDelta bool) error {
+func ServerPull(serverNode *models.LegacyNode, ifaceDelta bool) error {
 	if serverNode.IsServer != "yes" {
 		return fmt.Errorf("attempted pull from non-server node: %s - %s", serverNode.Name, serverNode.ID)
 	}
@@ -313,7 +313,7 @@ func getServerLocalIP(networkSettings *models.Network) (string, error) {
 	return "", errors.New("could not find a local ip for server")
 }
 
-func serverPush(serverNode *models.Node) error {
+func serverPush(serverNode *models.LegacyNode) error {
 	serverNode.OS = runtime.GOOS
 	serverNode.SetLastCheckIn()
 	return UpdateNode(serverNode, serverNode)

logic/telemetry.go

@@ -111,7 +111,7 @@ func setTelemetryTimestamp(telRecord *models.Telemetry) error {
 }
 
 // getClientCount - returns counts of nodes with various OS types and conditions
-func getClientCount(nodes []models.Node) clientCount {
+func getClientCount(nodes []models.LegacyNode) clientCount {
 	var count clientCount
 	for _, node := range nodes {
 		switch node.OS {

logic/util.go

@@ -147,7 +147,7 @@ func StringSliceContains(slice []string, item string) bool {
 // == private ==
 
 // sets the network server peers of a given node
-func setNetworkServerPeers(serverNode *models.Node) {
+func setNetworkServerPeers(serverNode *models.LegacyNode) {
 	if currentPeersList, err := getSystemPeers(serverNode); err == nil {
 		if currentPeersList == nil {
 			currentPeersList = make(map[string]string)
@@ -161,7 +161,7 @@ func setNetworkServerPeers(serverNode *models.Node) {
 }
 
 // ShouldPublishPeerPorts - Gets ports from iface, sets, and returns true if they are different
-func ShouldPublishPeerPorts(serverNode *models.Node) bool {
+func ShouldPublishPeerPorts(serverNode *models.LegacyNode) bool {
 	if currentPeersList, err := getSystemPeers(serverNode); err == nil {
 		if database.SetPeers(currentPeersList, serverNode.Network) {
 			logger.Log(1, "set new peers on network", serverNode.Network)

logic/wireguard.go

@@ -23,7 +23,7 @@ func RemoveConf(iface string, printlog bool) error {
 }
 
 // HasPeerConnected - checks if a client node has connected over WG
-func HasPeerConnected(node *models.Node) bool {
+func HasPeerConnected(node *models.LegacyNode) bool {
 	client, err := wgctrl.New()
 	if err != nil {
 		return false
@@ -44,7 +44,7 @@ func HasPeerConnected(node *models.Node) bool {
 }
 
 // IfaceDelta - checks if the new node causes an interface change
-func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
+func IfaceDelta(currentNode *models.LegacyNode, newNode *models.LegacyNode) bool {
 	// single comparison statements
 	if newNode.Endpoint != currentNode.Endpoint ||
 		newNode.PublicKey != currentNode.PublicKey ||
@@ -99,7 +99,7 @@ func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
 // == Private Functions ==
 
 // gets the server peers locally
-func getSystemPeers(node *models.Node) (map[string]string, error) {
+func getSystemPeers(node *models.LegacyNode) (map[string]string, error) {
 	peers := make(map[string]string)
 
 	client, err := wgctrl.New()
@@ -127,7 +127,7 @@ func removeWGQuickConf(confPath string, printlog bool) error {
 	return nil
 }
 
-func setWGConfig(node *models.Node, peerupdate bool) error {
+func setWGConfig(node *models.LegacyNode, peerupdate bool) error {
 	peers, err := GetPeerUpdate(node)
 	if err != nil {
 		return err
@@ -174,7 +174,7 @@ func setWGConfig(node *models.Node, peerupdate bool) error {
 	return nil
 }
 
-func setWGKeyConfig(node *models.Node) error {
+func setWGKeyConfig(node *models.LegacyNode) error {
 
 	privatekey, err := wgtypes.GeneratePrivateKey()
 	if err != nil {
@@ -195,7 +195,7 @@ func setWGKeyConfig(node *models.Node) error {
 	return setWGConfig(node, false)
 }
 
-func removeLocalServer(node *models.Node) error {
+func removeLocalServer(node *models.LegacyNode) error {
 
 	var err error
 	var ifacename = node.Interface

logic/zombie.go

@@ -23,7 +23,7 @@ var (
 
 // CheckZombies - checks if new node has same macaddress as existing node
 // if so, existing node is added to zombie node quarantine list
-func CheckZombies(newnode *models.Node) {
+func CheckZombies(newnode *models.LegacyNode) {
 	nodes, err := GetNetworkNodes(newnode.Network)
 	if err != nil {
 		logger.Log(1, "Failed to retrieve network nodes", newnode.Network, err.Error())

models/node.go

@@ -7,7 +7,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/google/uuid"
 	"golang.org/x/crypto/bcrypt"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
 const (
@@ -53,8 +55,46 @@ type Iface struct {
 	AddressString string    `json:"addressString"`
 }
 
-// Node - struct for node model
+// CommonNode - represents a commonn node data elements shared by netmaker and netclient
+type CommonNode struct {
+	ID                  uuid.UUID            `json:"id" yaml:"id"`
+	Network             string               `json:"network" yaml:"network"`
+	NetworkRange        net.IPNet            `json:"networkrange" yaml:"networkrange"`
+	NetworkRange6       net.IPNet            `json:"networkrange6" yaml:"networkrange6"`
+	InternetGateway     *net.UDPAddr         `json:"internetgateway" yaml:"internetgateway"`
+	Server              string               `json:"server" yaml:"server"`
+	Connected           bool                 `json:"connected" yaml:"connected"`
+	Interfaces          []Iface              `json:"interfaces" yaml:"interfaces"`
+	EndpointIP          net.IP               `json:"endpointip" yaml:"endpointip"`
+	Address             net.IPNet            `json:"address" yaml:"address"`
+	Address6            net.IPNet            `json:"address6" yaml:"address6"`
+	PostUp              string               `json:"postup" yaml:"postup"`
+	PostDown            string               `json:"postdown" yaml:"postdown"`
+	Action              string               `json:"action" yaml:"action"`
+	IsServer            bool                 `json:"isserver" yaml:"isserver"`
+	IsLocal             bool                 `json:"islocal" yaml:"islocal"`
+	IsEgressGateway     bool                 `json:"isegressgateway" yaml:"isegressgateway"`
+	IsIngressGateway    bool                 `json:"isingressgateway" yaml:"isingressgateway"`
+	IsStatic            bool                 `json:"isstatic" yaml:"isstatic"`
+	IsPending           bool                 `json:"ispending" yaml:"ispending"`
+	DNSOn               bool                 `json:"dnson" yaml:"dnson"`
+	IsHub               bool                 `json:"ishub" yaml:"ishub"`
+	PersistentKeepalive int                  `json:"persistentkeepalive" yaml:"persistentkeepalive"`
+	Peers               []wgtypes.PeerConfig `json:"peers" yaml:"peers"`
+	Proxy               bool                 `json:"proxy" bson:"proxy" yaml:"proxy"`
+}
+
+// Node - a model of a network node
 type Node struct {
+	CommonNode
+	PendingDelete bool `json:"pendingdelete" bson:"pendingdelete" yaml:"pendingdelete"`
+	// == PRO ==
+	DefaultACL string `json:"defaultacl,omitempty" bson:"defaultacl,omitempty" yaml:"defaultacl,omitempty" validate:"checkyesornoorunset"`
+	OwnerID    string `json:"ownerid,omitempty" bson:"ownerid,omitempty" yaml:"ownerid,omitempty"`
+}
+
+// LegacyNode - legacy struct for node model
+type LegacyNode struct {
 	ID                      string               `json:"id,omitempty" bson:"id,omitempty" yaml:"id,omitempty" validate:"required,min=5,id_unique"`
 	HostID                  string               `json:"hostid,omitempty" bson:"id,omitempty" yaml:"hostid,omitempty" validate:"required,min=5,id_unique"`
 	Address                 string               `json:"address" bson:"address" yaml:"address" validate:"omitempty,ipv4"`
@@ -122,7 +162,7 @@ type Node struct {
 }
 
 // NodesArray - used for node sorting
-type NodesArray []Node
+type NodesArray []LegacyNode
 
 // NodesArray.Len - gets length of node array
 func (a NodesArray) Len() int { return len(a) }
@@ -140,7 +180,7 @@ func isLess(ipA string, ipB string) bool {
 }
 
 // Node.PrimaryAddress - return ipv4 address if present, else return ipv6
-func (node *Node) PrimaryAddress() string {
+func (node *LegacyNode) PrimaryAddress() string {
 	if node.Address != "" {
 		return node.Address
 	}
@@ -148,7 +188,7 @@ func (node *Node) PrimaryAddress() string {
 }
 
 // Node.SetDefaultConnected
-func (node *Node) SetDefaultConnected() {
+func (node *LegacyNode) SetDefaultConnected() {
 	if node.Connected == "" {
 		node.Connected = "yes"
 	}
@@ -158,84 +198,84 @@ func (node *Node) SetDefaultConnected() {
 }
 
 // Node.SetDefaultACL
-func (node *Node) SetDefaultACL() {
+func (node *LegacyNode) SetDefaultACL() {
 	if node.DefaultACL == "" {
 		node.DefaultACL = "yes"
 	}
 }
 
 // Node.SetDefaultMTU - sets default MTU of a node
-func (node *Node) SetDefaultMTU() {
+func (node *LegacyNode) SetDefaultMTU() {
 	if node.MTU == 0 {
 		node.MTU = 1280
 	}
 }
 
 // Node.SetDefaultNFTablesPresent - sets default for nftables check
-func (node *Node) SetDefaultNFTablesPresent() {
+func (node *LegacyNode) SetDefaultNFTablesPresent() {
 	if node.FirewallInUse == "" {
 		node.FirewallInUse = FIREWALL_IPTABLES // default to iptables
 	}
 }
 
 // Node.SetDefaulIsPending - sets ispending default
-func (node *Node) SetDefaulIsPending() {
+func (node *LegacyNode) SetDefaulIsPending() {
 	if node.IsPending == "" {
 		node.IsPending = "no"
 	}
 }
 
 // Node.SetDefaultIsRelayed - set default is relayed
-func (node *Node) SetDefaultIsRelayed() {
+func (node *LegacyNode) SetDefaultIsRelayed() {
 	if node.IsRelayed == "" {
 		node.IsRelayed = "no"
 	}
 }
 
 // Node.SetDefaultIsRelayed - set default is relayed
-func (node *Node) SetDefaultIsHub() {
+func (node *LegacyNode) SetDefaultIsHub() {
 	if node.IsHub == "" {
 		node.IsHub = "no"
 	}
 }
 
 // Node.SetDefaultIsRelay - set default isrelay
-func (node *Node) SetDefaultIsRelay() {
+func (node *LegacyNode) SetDefaultIsRelay() {
 	if node.IsRelay == "" {
 		node.IsRelay = "no"
 	}
 }
 
 // Node.SetDefaultIsDocker - set default isdocker
-func (node *Node) SetDefaultIsDocker() {
+func (node *LegacyNode) SetDefaultIsDocker() {
 	if node.IsDocker == "" {
 		node.IsDocker = "no"
 	}
 }
 
 // Node.SetDefaultIsK8S - set default isk8s
-func (node *Node) SetDefaultIsK8S() {
+func (node *LegacyNode) SetDefaultIsK8S() {
 	if node.IsK8S == "" {
 		node.IsK8S = "no"
 	}
 }
 
 // Node.SetDefaultEgressGateway - sets default egress gateway status
-func (node *Node) SetDefaultEgressGateway() {
+func (node *LegacyNode) SetDefaultEgressGateway() {
 	if node.IsEgressGateway == "" {
 		node.IsEgressGateway = "no"
 	}
 }
 
 // Node.SetDefaultIngressGateway - sets default ingress gateway status
-func (node *Node) SetDefaultIngressGateway() {
+func (node *LegacyNode) SetDefaultIngressGateway() {
 	if node.IsIngressGateway == "" {
 		node.IsIngressGateway = "no"
 	}
 }
 
 // Node.SetDefaultAction - sets default action status
-func (node *Node) SetDefaultAction() {
+func (node *LegacyNode) SetDefaultAction() {
 	if node.Action == "" {
 		node.Action = NODE_NOOP
 	}
@@ -249,35 +289,35 @@ func (node *Node) SetDefaultAction() {
 //}
 
 // Node.SetIPForwardingDefault - set ip forwarding default
-func (node *Node) SetIPForwardingDefault() {
+func (node *LegacyNode) SetIPForwardingDefault() {
 	if node.IPForwarding == "" {
 		node.IPForwarding = "yes"
 	}
 }
 
 // Node.SetIsLocalDefault - set is local default
-func (node *Node) SetIsLocalDefault() {
+func (node *LegacyNode) SetIsLocalDefault() {
 	if node.IsLocal == "" {
 		node.IsLocal = "no"
 	}
 }
 
 // Node.SetDNSOnDefault - sets dns on default
-func (node *Node) SetDNSOnDefault() {
+func (node *LegacyNode) SetDNSOnDefault() {
 	if node.DNSOn == "" {
 		node.DNSOn = "yes"
 	}
 }
 
 // Node.SetIsServerDefault - sets node isserver default
-func (node *Node) SetIsServerDefault() {
+func (node *LegacyNode) SetIsServerDefault() {
 	if node.IsServer != "yes" {
 		node.IsServer = "no"
 	}
 }
 
 // Node.SetIsStaticDefault - set is static default
-func (node *Node) SetIsStaticDefault() {
+func (node *LegacyNode) SetIsStaticDefault() {
 	if node.IsServer == "yes" {
 		node.IsStatic = "yes"
 	} else if node.IsStatic != "yes" {
@@ -286,41 +326,41 @@ func (node *Node) SetIsStaticDefault() {
 }
 
 // Node.SetLastModified - set last modified initial time
-func (node *Node) SetLastModified() {
+func (node *LegacyNode) SetLastModified() {
 	node.LastModified = time.Now().Unix()
 }
 
 // Node.SetLastCheckIn - time.Now().Unix()
-func (node *Node) SetLastCheckIn() {
+func (node *LegacyNode) SetLastCheckIn() {
 	node.LastCheckIn = time.Now().Unix()
 }
 
 // Node.SetLastPeerUpdate - sets last peer update time
-func (node *Node) SetLastPeerUpdate() {
+func (node *LegacyNode) SetLastPeerUpdate() {
 	node.LastPeerUpdate = time.Now().Unix()
 }
 
 // Node.SetExpirationDateTime - sets node expiry time
-func (node *Node) SetExpirationDateTime() {
+func (node *LegacyNode) SetExpirationDateTime() {
 	node.ExpirationDateTime = time.Now().Unix() + TEN_YEARS_IN_SECONDS
 }
 
 // Node.SetDefaultName - sets a random name to node
-func (node *Node) SetDefaultName() {
+func (node *LegacyNode) SetDefaultName() {
 	if node.Name == "" {
 		node.Name = GenerateNodeName()
 	}
 }
 
 // Node.SetDefaultFailover - sets default value of failover status to no if not set
-func (node *Node) SetDefaultFailover() {
+func (node *LegacyNode) SetDefaultFailover() {
 	if node.Failover == "" {
 		node.Failover = "no"
 	}
 }
 
 // Node.Fill - fills other node data into calling node data if not set on calling node
-func (newNode *Node) Fill(currentNode *Node) { // TODO add new field for nftables present
+func (newNode *LegacyNode) Fill(currentNode *LegacyNode) { // TODO add new field for nftables present
 	newNode.ID = currentNode.ID
 
 	if newNode.Address == "" {
@@ -498,7 +538,7 @@ func IsIpv4Net(host string) bool {
 }
 
 // Node.NameInNodeCharset - returns if name is in charset below or not
-func (node *Node) NameInNodeCharSet() bool {
+func (node *LegacyNode) NameInNodeCharSet() bool {
 
 	charset := "abcdefghijklmnopqrstuvwxyz1234567890-"
 
@@ -513,11 +553,91 @@ func (node *Node) NameInNodeCharSet() bool {
 // == PRO ==
 
 // Node.DoesACLAllow - checks if default ACL on node is "yes"
-func (node *Node) DoesACLAllow() bool {
+func (node *LegacyNode) DoesACLAllow() bool {
 	return node.DefaultACL == "yes"
 }
 
 // Node.DoesACLDeny - checks if default ACL on node is "no"
-func (node *Node) DoesACLDeny() bool {
+func (node *LegacyNode) DoesACLDeny() bool {
 	return node.DefaultACL == "no"
 }
+
+func (ln *LegacyNode) ConvertToNewNode() (*Host, *Node) {
+	var node Node
+	//host:= logic.GetHost(node.HostID)
+	var host Host
+	if host.ID.String() == "" {
+		host.ID = uuid.New()
+		host.FirewallInUse = ln.FirewallInUse
+		host.Version = ln.Version
+		host.IPForwarding = parseBool(ln.IPForwarding)
+		host.HostPass = ln.Password
+		host.Name = ln.Name
+		host.ListenPort = int(ln.ListenPort)
+		_, cidr, _ := net.ParseCIDR(ln.LocalAddress)
+		host.LocalAddress = *cidr
+		_, cidr, _ = net.ParseCIDR(ln.LocalRange)
+		host.LocalRange = *cidr
+		host.LocalListenPort = int(ln.LocalListenPort)
+		host.ProxyListenPort = int(ln.ProxyListenPort)
+		host.MTU = int(ln.MTU)
+		host.PublicKey, _ = wgtypes.ParseKey(ln.PublicKey)
+		host.MacAddress, _ = net.ParseMAC(ln.MacAddress)
+		host.TrafficKeyPublic = ln.TrafficKeys.Mine
+		gateway, _ := net.ResolveUDPAddr("udp", ln.InternetGateway)
+		host.InternetGateway = *gateway
+		id, _ := uuid.Parse(ln.ID)
+		host.Nodes = append(host.Nodes, id)
+	}
+	id, _ := uuid.Parse(ln.ID)
+	node.ID = id
+	node.Network = ln.Network
+	_, cidr, _ := net.ParseCIDR(ln.NetworkSettings.AddressRange)
+	node.NetworkRange = *cidr
+	_, cidr, _ = net.ParseCIDR(ln.NetworkSettings.AddressRange6)
+	node.NetworkRange6 = *cidr
+	node.Server = ln.Server
+	node.Connected = parseBool(ln.Connected)
+	node.Interfaces = ln.Interfaces
+	node.EndpointIP = net.ParseIP(ln.Endpoint)
+	_, cidr, _ = net.ParseCIDR(ln.Address)
+	node.Address = *cidr
+	_, cidr, _ = net.ParseCIDR(ln.Address6)
+	node.Address6 = *cidr
+	node.PostUp = ln.PostUp
+	node.PostDown = ln.PostDown
+	node.Action = ln.Action
+	node.IsServer = parseBool(ln.IsServer)
+	node.IsLocal = parseBool(ln.IsLocal)
+	node.IsEgressGateway = parseBool(ln.IsEgressGateway)
+	node.IsIngressGateway = parseBool(ln.IsIngressGateway)
+	node.IsStatic = parseBool(ln.IsStatic)
+	node.DNSOn = parseBool(ln.DNSOn)
+	node.PersistentKeepalive = int(ln.PersistentKeepalive)
+	node.Proxy = ln.Proxy
+
+	return &host, &node
+}
+
+// Node.NetworkSettings updates a node with network settings
+func (node *Node) NetworkSettings(n Network) {
+	_, cidr, _ := net.ParseCIDR(n.AddressRange)
+	node.NetworkRange = *cidr
+
+}
+
+func parseBool(s string) bool {
+	b := false
+	if s == "yes" {
+		b = true
+	}
+	return b
+}
+
+func formatBool(b bool) string {
+	s := "no"
+	if b {
+		s = "yes"
+	}
+	return s
+}

models/structs.go

@@ -6,7 +6,6 @@ import (
 
 	jwt "github.com/golang-jwt/jwt/v4"
 	"github.com/gravitl/netclient/nmproxy/manager"
-	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
 const PLACEHOLDER_KEY_TEXT = "ACCESS_KEY"
@@ -176,8 +175,8 @@ type RelayRequest struct {
 // ServerUpdateData - contains data to configure server
 // and if it should set peers
 type ServerUpdateData struct {
-	UpdatePeers bool `json:"updatepeers" bson:"updatepeers"`
-	Node        Node `json:"servernode" bson:"servernode"`
+	UpdatePeers bool       `json:"updatepeers" bson:"updatepeers"`
+	Node        LegacyNode `json:"servernode" bson:"servernode"`
 }
 
 // Telemetry - contains UUID of the server and timestamp of last send to posthog
@@ -203,8 +202,10 @@ type TrafficKeys struct {
 
 // NodeGet - struct for a single node get response
 type NodeGet struct {
-	Node         Node                        `json:"node" bson:"node" yaml:"node"`
-	Peers        []wgtypes.PeerConfig        `json:"peers" bson:"peers" yaml:"peers"`
+	Node Node `json:"node" bson:"node" yaml:"node"`
+	Host Host `json:"host" yaml:"host"`
+	// Peers are included in Node
+	//Peers        []wgtypes.PeerConfig        `json:"peers" bson:"peers" yaml:"peers"`
 	ServerConfig ServerConfig                `json:"serverconfig" bson:"serverconfig" yaml:"serverconfig"`
 	PeerIDs      PeerMap                     `json:"peerids,omitempty" bson:"peerids,omitempty" yaml:"peerids,omitempty"`
 	ProxyUpdate  manager.ProxyManagerPayload `json:"proxy_update,omitempty" bson:"proxy_update,omitempty" yaml:"proxy_update,omitempty"`
@@ -224,6 +225,7 @@ type ServerConfig struct {
 	Is_EE       bool   `yaml:"isee"`
 	StunPort    int    `yaml:"stun_port"`
 	StunHost    string `yaml:"stun_host"`
+	TrafficKey  []byte `yaml:"traffickey"`
 }
 
 // User.NameInCharset - returns if name is in charset below or not
@@ -241,3 +243,10 @@ func (user *User) NameInCharSet() bool {
 type ServerIDs struct {
 	ServerIDs []string `json:"server_ids"`
 }
+
+// JoinData - struct to hold data required for node to join a network on server
+type JoinData struct {
+	Host Host   `json:"host yaml:"host"`
+	Node Node   `json:"node" yaml:"node"`
+	Key  string `json:"key" yaml:"key"`
+}

mq/handlers.go

@@ -85,7 +85,7 @@ func UpdateNode(client mqtt.Client, msg mqtt.Message) {
 			logger.Log(1, "failed to decrypt message for node ", id, decryptErr.Error())
 			return
 		}
-		var newNode models.Node
+		var newNode models.LegacyNode
 		if err := json.Unmarshal(decrypted, &newNode); err != nil {
 			logger.Log(1, "error unmarshaling payload ", err.Error())
 			return
@@ -205,7 +205,7 @@ func ClientPeerUpdate(client mqtt.Client, msg mqtt.Message) {
 	}()
 }
 
-func updateNodePeers(currentNode *models.Node) {
+func updateNodePeers(currentNode *models.LegacyNode) {
 	currentServerNode, err := logic.GetNetworkServerLocal(currentNode.Network)
 	if err != nil {
 		logger.Log(1, "failed to get server node failed update\n", err.Error())
@@ -223,7 +223,7 @@ func updateNodePeers(currentNode *models.Node) {
 	}
 }
 
-func updateNodeMetrics(currentNode *models.Node, newMetrics *models.Metrics) bool {
+func updateNodeMetrics(currentNode *models.LegacyNode, newMetrics *models.Metrics) bool {
 	if newMetrics.FailoverPeers == nil {
 		newMetrics.FailoverPeers = make(map[string]string)
 	}

mq/publishers.go

@@ -16,7 +16,7 @@ import (
 )
 
 // PublishPeerUpdate --- deterines and publishes a peer update to all the peers of a node
-func PublishPeerUpdate(newNode *models.Node, publishToSelf bool) error {
+func PublishPeerUpdate(newNode *models.LegacyNode, publishToSelf bool) error {
 	if !servercfg.IsMessageQueueBackend() {
 		return nil
 	}
@@ -50,7 +50,7 @@ func PublishPeerUpdate(newNode *models.Node, publishToSelf bool) error {
 	return err
 }
 
-func PublishProxyPeerUpdate(node *models.Node) error {
+func PublishProxyPeerUpdate(node *models.LegacyNode) error {
 	proxyUpdate, err := logic.GetPeersForProxy(node, false)
 	if err != nil {
 		return err
@@ -65,7 +65,7 @@ func PublishProxyPeerUpdate(node *models.Node) error {
 }
 
 // PublishSinglePeerUpdate --- determines and publishes a peer update to one node
-func PublishSinglePeerUpdate(node *models.Node) error {
+func PublishSinglePeerUpdate(node *models.LegacyNode) error {
 
 	peerUpdate, err := logic.GetPeerUpdate(node)
 	if err != nil {
@@ -89,7 +89,7 @@ func PublishSinglePeerUpdate(node *models.Node) error {
 }
 
 // PublishPeerUpdate --- publishes a peer update to all the peers of a node
-func PublishExtPeerUpdate(node *models.Node) error {
+func PublishExtPeerUpdate(node *models.LegacyNode) error {
 	var err error
 	if logic.IsLocalServer(node) {
 		if err = logic.ServerUpdate(node, false); err != nil {
@@ -125,7 +125,7 @@ func PublishExtPeerUpdate(node *models.Node) error {
 }
 
 // NodeUpdate -- publishes a node update
-func NodeUpdate(node *models.Node) error {
+func NodeUpdate(node *models.LegacyNode) error {
 	var err error
 	if !servercfg.IsMessageQueueBackend() || node.IsServer == "yes" {
 
@@ -157,7 +157,7 @@ func NodeUpdate(node *models.Node) error {
 }
 
 // ProxyUpdate -- publishes updates to peers related to proxy
-func ProxyUpdate(proxyPayload *manager.ProxyManagerPayload, node *models.Node) error {
+func ProxyUpdate(proxyPayload *manager.ProxyManagerPayload, node *models.LegacyNode) error {
 	if !servercfg.IsMessageQueueBackend() || !node.Proxy {
 		return nil
 	}

mq/util.go

@@ -11,7 +11,7 @@ import (
 	"github.com/gravitl/netmaker/netclient/ncutils"
 )
 
-func decryptMsg(node *models.Node, msg []byte) ([]byte, error) {
+func decryptMsg(node *models.LegacyNode, msg []byte) ([]byte, error) {
 	if len(msg) <= 24 { // make sure message is of appropriate length
 		return nil, fmt.Errorf("recieved invalid message from broker %v", msg)
 	}
@@ -36,7 +36,7 @@ func decryptMsg(node *models.Node, msg []byte) ([]byte, error) {
 	return ncutils.DeChunk(msg, nodePubTKey, serverPrivTKey)
 }
 
-func encryptMsg(node *models.Node, msg []byte) ([]byte, error) {
+func encryptMsg(node *models.LegacyNode, msg []byte) ([]byte, error) {
 	// fetch server public key to be certain hasn't changed in transit
 	trafficKey, trafficErr := logic.RetrievePrivateTrafficKey()
 	if trafficErr != nil {
@@ -60,7 +60,7 @@ func encryptMsg(node *models.Node, msg []byte) ([]byte, error) {
 	return ncutils.Chunk(msg, nodePubKey, serverPrivKey)
 }
 
-func publish(node *models.Node, dest string, msg []byte) error {
+func publish(node *models.LegacyNode, dest string, msg []byte) error {
 	encrypted, encryptErr := encryptMsg(node, msg)
 	if encryptErr != nil {
 		return encryptErr

netclient/config/config.go

@@ -25,7 +25,7 @@ var (
 // ClientConfig - struct for dealing with client configuration
 type ClientConfig struct {
 	Server          models.ServerConfig `yaml:"server"`
-	Node            models.Node         `yaml:"node"`
+	Node            models.LegacyNode   `yaml:"node"`
 	NetworkSettings models.Network      `yaml:"networksettings"`
 	Network         string              `yaml:"network"`
 	Daemon          string              `yaml:"daemon"`
@@ -138,7 +138,7 @@ func (config *ClientConfig) ReadConfig() {
 }
 
 // ModNodeConfig - overwrites the node inside client config on disk
-func ModNodeConfig(node *models.Node) error {
+func ModNodeConfig(node *models.LegacyNode) error {
 	network := node.Network
 	if network == "" {
 		return errors.New("no network provided")
@@ -339,13 +339,13 @@ func FileExists(f string) bool {
 }
 
 // GetNode - parses a network specified client config for node data
-func GetNode(network string) models.Node {
+func GetNode(network string) models.LegacyNode {
 
 	modcfg, err := ReadConfig(network)
 	if err != nil {
 		log.Fatalf("Error: %v", err)
 	}
-	var node models.Node
+	var node models.LegacyNode
 	node.Fill(&modcfg.Node)
 
 	return node

netclient/functions/common.go

@@ -160,7 +160,7 @@ func getInterfaces() (*[]models.Iface, error) {
 }
 
 // GetNode - gets node locally
-func GetNode(network string) models.Node {
+func GetNode(network string) models.LegacyNode {
 
 	modcfg, err := config.ReadConfig(network)
 	if err != nil {
@@ -422,7 +422,7 @@ func SetServerInfo(cfg *config.ClientConfig) error {
 	return nil
 }
 
-func informPortChange(node *models.Node) {
+func informPortChange(node *models.LegacyNode) {
 	if node.ListenPort == 0 {
 		logger.Log(0, "network:", node.Network, "UDP hole punching enabled for node", node.Name)
 	} else {

netclient/functions/join.go

@@ -395,7 +395,7 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string) error {
 }
 
 // format name appropriately. Set to blank on failure
-func formatName(node models.Node) string {
+func formatName(node models.LegacyNode) string {
 	// Logic to properly format name
 	if !node.NameInNodeCharSet() {
 		node.Name = ncutils.DNSFormatString(node.Name)

netclient/functions/mqhandlers.go

@@ -52,7 +52,7 @@ func ProxyUpdate(client mqtt.Client, msg mqtt.Message) {
 
 // NodeUpdate -- mqtt message handler for /update/<NodeID> topic
 func NodeUpdate(client mqtt.Client, msg mqtt.Message) {
-	var newNode models.Node
+	var newNode models.LegacyNode
 	var nodeCfg config.ClientConfig
 	var network = parseNetworkFromTopic(msg.Topic())
 	nodeCfg.Network = network

netclient/functions/pull.go

@@ -20,7 +20,7 @@ import (
 )
 
 // Pull - pulls the latest config from the server, if manual it will overwrite
-func Pull(network string, iface bool) (*models.Node, error) {
+func Pull(network string, iface bool) (*models.LegacyNode, error) {
 	cfg, err := config.ReadConfig(network)
 	if err != nil {
 		return nil, err

netclient/ncutils/iface.go

@@ -7,7 +7,7 @@ import (
 )
 
 // IfaceDelta - checks if the new node causes an interface change
-func IfaceDelta(currentNode *models.Node, newNode *models.Node) bool {
+func IfaceDelta(currentNode *models.LegacyNode, newNode *models.LegacyNode) bool {
 	// single comparison statements
 	if newNode.Endpoint != currentNode.Endpoint ||
 		newNode.PublicKey != currentNode.PublicKey ||

netclient/ncutils/netclientutils.go

@@ -633,7 +633,7 @@ func GetIPNetFromString(ip string) (net.IPNet, error) {
 }
 
 // ModPort - Change Node Port if UDP Hole Punching or ListenPort is not free
-func ModPort(node *models.Node) error {
+func ModPort(node *models.LegacyNode) error {
 	var err error
 	if node.UDPHolePunch == "yes" {
 		node.ListenPort = 0

netclient/wireguard/common.go

@@ -24,7 +24,7 @@ const (
 )
 
 // SetPeers - sets peers on a given WireGuard interface
-func SetPeers(iface string, node *models.Node, peers []wgtypes.PeerConfig) error {
+func SetPeers(iface string, node *models.LegacyNode, peers []wgtypes.PeerConfig) error {
 	var devicePeers []wgtypes.Peer
 	var keepalive = node.PersistentKeepalive
 	var oldPeerAllowedIps = make(map[string]bool, len(peers))
@@ -120,7 +120,7 @@ func SetPeers(iface string, node *models.Node, peers []wgtypes.PeerConfig) error
 }
 
 // Initializes a WireGuard interface
-func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig) error {
+func InitWireguard(node *models.LegacyNode, privkey string, peers []wgtypes.PeerConfig) error {
 
 	key, err := wgtypes.ParseKey(privkey)
 	if err != nil {
@@ -268,7 +268,7 @@ func RemoveConf(iface string, printlog bool) error {
 }
 
 // ApplyConf - applys a conf on disk to WireGuard interface
-func ApplyConf(node *models.Node, ifacename string, confPath string) error {
+func ApplyConf(node *models.LegacyNode, ifacename string, confPath string) error {
 	os := runtime.GOOS
 	if ncutils.IsLinux() && !ncutils.HasWgQuick() {
 		os = "nowgquick"
@@ -305,7 +305,7 @@ func ApplyConf(node *models.Node, ifacename string, confPath string) error {
 }
 
 // WriteWgConfig - creates a wireguard config file
-func WriteWgConfig(node *models.Node, privateKey string, peers []wgtypes.PeerConfig) error {
+func WriteWgConfig(node *models.LegacyNode, privateKey string, peers []wgtypes.PeerConfig) error {
 	options := ini.LoadOptions{
 		AllowNonUniqueSections: true,
 		AllowShadows:           true,
@@ -434,7 +434,7 @@ func UpdateWgPeers(file string, peers []wgtypes.PeerConfig) (*net.UDPAddr, error
 }
 
 // UpdateWgInterface - updates the interface section of a wireguard config file
-func UpdateWgInterface(file, privateKey, nameserver string, node models.Node) error {
+func UpdateWgInterface(file, privateKey, nameserver string, node models.LegacyNode) error {
 	options := ini.LoadOptions{
 		AllowNonUniqueSections: true,
 		AllowShadows:           true,

netclient/wireguard/noquick.go

@@ -19,7 +19,7 @@ import (
 const disconnect_error = "node disconnected"
 
 // ApplyWithoutWGQuick - Function for running the equivalent of "wg-quick up" for linux if wg-quick is missing
-func ApplyWithoutWGQuick(node *models.Node, ifacename, confPath string, isConnected bool) error {
+func ApplyWithoutWGQuick(node *models.LegacyNode, ifacename, confPath string, isConnected bool) error {
 
 	ipExec, err := exec.LookPath("ip")
 	if err != nil {

test/main.go

@@ -39,7 +39,7 @@ func main() {
 		pretty.Println(string(bytes))
 	}
 	defer response.Body.Close()
-	node := models.Node{}
+	node := models.LegacyNode{}
 	if err := json.NewDecoder(response.Body).Decode(&node); err != nil {
 		fmt.Println(err)
 	}