refactor

controllers/node.go

@@ -404,8 +404,8 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if err = runServerPeerUpdate(); err != nil {
-		logger.Log(1, "internal error when approving node:", node.ID)
+	if err = runServerPeerUpdate(node.Network, true); err != nil {
+		logger.Log(1, "internal error when creating node:", node.ID)
 	}
 
 	logger.Log(1, r.Header.Get("user"), "created new node", node.Name, "on network", node.Network)
@@ -424,7 +424,7 @@ func uncordonNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(); err != nil {
+	if err = runServerPeerUpdate(node.Network, false); err != nil {
 		logger.Log(1, "internal error when approving node:", nodeid)
 	}
 	logger.Log(1, r.Header.Get("user"), "uncordoned node", node.Name)
@@ -448,7 +448,7 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(); err != nil {
+	if err = runServerPeerUpdate(gateway.NetID, true); err != nil {
 		logger.Log(1, "internal error when setting peers after creating egress on node:", gateway.NodeID)
 	}
 	logger.Log(1, r.Header.Get("user"), "created egress gateway on node", gateway.NodeID, "on network", gateway.NetID)
@@ -466,7 +466,7 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if err = runServerPeerUpdate(); err != nil {
+	if err = runServerPeerUpdate(netid, true); err != nil {
 		logger.Log(1, "internal error when setting peers after removing egress on node:", nodeid)
 	}
 	logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
@@ -565,7 +565,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 		err = logic.SetDNS()
 	}
 
-	err = runServerUpdateIfNeeded(shouldPeersUpdate, newNode)
+	err = runServerPeerUpdate(node.Network, shouldPeersUpdate)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
@@ -593,7 +593,7 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	err = runServerPeerUpdate()
+	err = runServerPeerUpdate(node.Network, true)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return

controllers/node_grpc.go

@@ -86,7 +86,7 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object)
 		return nil, err
 	}
 
-	err = runServerPeerUpdate()
+	err = runServerPeerUpdate(node.Network, true)
 	if err != nil {
 		logger.Log(1, "internal error when setting peers after node,", node.ID, "was created (gRPC)")
 	}
@@ -125,7 +125,7 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
 	if errN != nil {
 		return nil, err
 	}
-	err = runServerUpdateIfNeeded(shouldPeersUpdate, newnode)
+	err = runServerPeerUpdate(newnode.Network, shouldPeersUpdate)
 	if err != nil {
 		logger.Log(1, "could not update peers on gRPC after node,", newnode.ID, "updated (gRPC), \nerror:", err.Error())
 	}
@@ -148,7 +148,7 @@ func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object)
 		return nil, err
 	}
 
-	err = runServerPeerUpdate()
+	err = runServerPeerUpdate(node.Network, true)
 	if err != nil {
 		logger.Log(1, "internal error when setting peers after deleting node:", node.ID, "over gRPC")
 	}

controllers/relay.go

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

controllers/server_util.go

@@ -3,71 +3,11 @@ package controller
 import (
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
-	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/serverctl"
 )
 
-func runServerPeerUpdate() error {
-	var serverData = models.ServerUpdateData{
-		UpdatePeers: true,
-	}
-	serverctl.Push(serverData)
-	var settings, err = serverctl.Pop()
-	if err != nil {
-		logger.Log(1, "error during pop,", err.Error())
-		return err
-	}
-	return handlePeerUpdate(&settings.Node)
-}
-
-func runServerUpdateIfNeeded(shouldPeersUpdate bool, node models.Node) error {
-	// check if a peer/server update is needed
-	var serverData = models.ServerUpdateData{
-		UpdatePeers: shouldPeersUpdate,
-		Node:        node,
-	}
-	serverctl.Push(serverData)
-
-	return handleServerUpdate()
-}
+func runServerPeerUpdate(network string, shouldPeerUpdate bool) error {
 
-func handleServerUpdate() error {
-	var settings, settingsErr = serverctl.Pop()
-	if settingsErr != nil {
-		return settingsErr
-	}
-	var currentServerNodeID, err = logic.GetNetworkServerNodeID(settings.Node.Network)
-	if err != nil {
-		return err
-	}
-	// ensure server client is available
-	if settings.UpdatePeers || (settings.Node.ID == currentServerNodeID) {
-		err = serverctl.SyncServerNetwork(&settings.Node)
-		if err != nil {
-			logger.Log(1, "failed to sync,", settings.Node.Network, ", error:", err.Error())
-		}
-	}
-	// if peers should update, update peers on network
-	if settings.UpdatePeers {
-		if err = handlePeerUpdate(&settings.Node); err != nil {
-			return err
-		}
-		logger.Log(1, "updated peers on network:", settings.Node.Network)
-	}
-	// if the server node had an update, run the update function
-	if settings.Node.ID == currentServerNodeID {
-		if err = logic.ServerUpdate(&settings.Node); err != nil {
-			return err
-		}
-		logger.Log(1, "server node:", settings.Node.ID, "was updated")
-	}
-	return nil
-}
-
-// tells server to update it's peers
-func handlePeerUpdate(node *models.Node) error {
-	logger.Log(1, "updating peers on network:", node.Network)
-	var currentServerNodeID, err = logic.GetNetworkServerNodeID(node.Network)
+	var currentServerNodeID, err = logic.GetNetworkServerNodeID(network)
 	if err != nil {
 		return err
 	}
@@ -75,11 +15,72 @@ func handlePeerUpdate(node *models.Node) error {
 	if currErr != nil {
 		return currErr
 	}
-	if err = logic.ServerUpdate(&currentServerNode); err != nil {
+	if err = logic.ServerUpdate(&currentServerNode, shouldPeerUpdate); err != nil {
+		logger.Log(1, "server node:", currentServerNode.ID, "failed update")
 		return err
 	}
-	logger.Log(1, "server node:", currentServerNode.ID, "was updated")
-	logic.SetNetworkServerPeers(&currentServerNode)
-	logger.Log(1, "finished a peer update for network,", currentServerNode.Network)
 	return nil
 }
+
+// func runServerUpdateIfNeeded(shouldPeersUpdate bool, node models.Node) error {
+// 	// check if a peer/server update is needed
+// 	var serverData = models.ServerUpdateData{
+// 		UpdatePeers: shouldPeersUpdate,
+// 		Node:        node,
+// 	}
+// 	serverctl.Push(serverData)
+
+// 	return handleServerUpdate()
+// }
+
+// func handleServerUpdate() error {
+// 	var settings, settingsErr = serverctl.Pop()
+// 	if settingsErr != nil {
+// 		return settingsErr
+// 	}
+// 	var currentServerNodeID, err = logic.GetNetworkServerNodeID(settings.Node.Network)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	// ensure server client is available
+// 	if settings.UpdatePeers || (settings.Node.ID == currentServerNodeID) {
+// 		err = serverctl.SyncServerNetwork(&settings.Node)
+// 		if err != nil {
+// 			logger.Log(1, "failed to sync,", settings.Node.Network, ", error:", err.Error())
+// 		}
+// 	}
+// 	// if peers should update, update peers on network
+// 	if settings.UpdatePeers {
+// 		if err = handlePeerUpdate(&settings.Node); err != nil {
+// 			return err
+// 		}
+// 		logger.Log(1, "updated peers on network:", settings.Node.Network)
+// 	}
+// 	// if the server node had an update, run the update function
+// 	if settings.Node.ID == currentServerNodeID {
+// 		if err = logic.ServerUpdate(&settings.Node); err != nil {
+// 			return err
+// 		}
+// 		logger.Log(1, "server node:", settings.Node.ID, "was updated")
+// 	}
+// 	return nil
+// }
+
+// // tells server to update it's peers
+// func handlePeerUpdate(node *models.Node) error {
+// 	logger.Log(1, "updating peers on network:", node.Network)
+// 	var currentServerNodeID, err = logic.GetNetworkServerNodeID(node.Network)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	var currentServerNode, currErr = logic.GetNodeByID(currentServerNodeID)
+// 	if currErr != nil {
+// 		return currErr
+// 	}
+// 	if err = logic.ServerUpdate(&currentServerNode); err != nil {
+// 		logger.Log(1, "server node:", currentServerNode.ID, "failed update")
+// 		return err
+// 	}
+// 	logger.Log(1, "finished a peer update for network,", currentServerNode.Network)
+// 	return nil
+// }

logic/nodes.go

@@ -20,21 +20,11 @@ import (
 
 // GetNetworkNodes - gets the nodes of a network
 func GetNetworkNodes(network string) ([]models.Node, error) {
-	var nodes = []models.Node{}
-	collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
+	var nodes, err = GetAllNodes()
 	if err != nil {
-		if database.IsEmptyRecord(err) {
-			return []models.Node{}, nil
-		}
-		return nodes, err
+		return []models.Node{}, err
 	}
-	for _, value := range collection {
-
-		var node models.Node
-		err := json.Unmarshal([]byte(value), &node)
-		if err != nil {
-			continue
-		}
+	for _, node := range nodes {
 		if node.Network == network {
 			nodes = append(nodes, node)
 		}
@@ -88,7 +78,7 @@ func UncordonNode(nodeid string) (models.Node, error) {
 // GetPeers - gets the peers of a given node
 func GetPeers(node *models.Node) ([]models.Node, error) {
 	if IsLeader(node) {
-		SetNetworkServerPeers(node)
+		setNetworkServerPeers(node)
 	}
 	excludeIsRelayed := node.IsRelay != "yes"
 	var relayedNode string

logic/server.go

@@ -140,8 +140,8 @@ func ServerJoin(networkSettings *models.Network) error {
 
 // ServerUpdate - updates the server
 // replaces legacy Checkin code
-func ServerUpdate(serverNode *models.Node) error {
-	var err = serverPull(serverNode, false)
+func ServerUpdate(serverNode *models.Node, shouldPeerUpdate bool) error {
+	var err = serverPull(serverNode, shouldPeerUpdate)
 	if isDeleteError(err) {
 		return DeleteNodeByID(serverNode, true)
 	} else if err != nil {
@@ -167,17 +167,14 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
 	var gateways []string
 	var peers []wgtypes.PeerConfig
 	var nodes []models.Node // fill above fields from server or client
+	var err error
 
-	var nodecfg, err = GetNodeByIDorMacAddress(serverNode.ID, serverNode.MacAddress, serverNode.Network)
-	if err != nil {
-		return nil, hasGateway, gateways, err
-	}
-	nodes, err = GetPeers(&nodecfg)
+	nodes, err = GetPeers(serverNode)
 	if err != nil {
 		return nil, hasGateway, gateways, err
 	}
 
-	keepalive := nodecfg.PersistentKeepalive
+	keepalive := serverNode.PersistentKeepalive
 	keepalivedur, err := time.ParseDuration(strconv.FormatInt(int64(keepalive), 10) + "s")
 	if err != nil {
 		logger.Log(1, "Issue with format of keepalive duration value, Please view server config:", err.Error())
@@ -191,11 +188,11 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
 			return peers, hasGateway, gateways, err
 		}
 
-		if nodecfg.PublicKey == node.PublicKey {
+		if serverNode.PublicKey == node.PublicKey {
 			continue
 		}
-		if nodecfg.Endpoint == node.Endpoint {
-			if nodecfg.LocalAddress != node.LocalAddress && node.LocalAddress != "" {
+		if serverNode.Endpoint == node.Endpoint {
+			if serverNode.LocalAddress != node.LocalAddress && node.LocalAddress != "" {
 				node.Endpoint = node.LocalAddress
 			} else {
 				continue
@@ -240,8 +237,8 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
 					logger.Log(2, "egress IP range of", iprange, "overlaps with", node.Endpoint, ", omitting")
 					continue // skip adding egress range if overlaps with node's ip
 				}
-				if ipnet.Contains(net.ParseIP(nodecfg.LocalAddress)) { // ensuring egress gateway range does not contain public ip of node
-					logger.Log(2, "egress IP range of", iprange, "overlaps with", nodecfg.LocalAddress, ", omitting")
+				if ipnet.Contains(net.ParseIP(serverNode.LocalAddress)) { // ensuring egress gateway range does not contain public ip of node
+					logger.Log(2, "egress IP range of", iprange, "overlaps with", serverNode.LocalAddress, ", omitting")
 					continue // skip adding egress range if overlaps with node's local ip
 				}
 				gateways = append(gateways, iprange)

logic/util.go

@@ -39,17 +39,6 @@ func FileExists(f string) bool {
 	return !info.IsDir()
 }
 
-// SetNetworkServerPeers - sets the network server peers of a given node
-func SetNetworkServerPeers(serverNode *models.Node) {
-	if currentPeersList, err := getSystemPeers(serverNode); err == nil {
-		if database.SetPeers(currentPeersList, serverNode.Network) {
-			logger.Log(1, "set new peers on network", serverNode.Network)
-		}
-	} else {
-		logger.Log(1, "could not set peers on network", serverNode.Network, ":", err.Error())
-	}
-}
-
 // DeleteNodeByMacAddress - deletes a node from database or moves into delete nodes table
 func DeleteNodeByMacAddress(node *models.Node, exterminate bool) error {
 	var err error
@@ -344,3 +333,16 @@ func StringSliceContains(slice []string, item string) bool {
 	}
 	return false
 }
+
+// == private ==
+
+// sets the network server peers of a given node
+func setNetworkServerPeers(serverNode *models.Node) {
+	if currentPeersList, err := getSystemPeers(serverNode); err == nil {
+		if database.SetPeers(currentPeersList, serverNode.Network) {
+			logger.Log(1, "set new peers on network", serverNode.Network)
+		}
+	} else {
+		logger.Log(1, "could not set peers on network", serverNode.Network, ":", err.Error())
+	}
+}