gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2024-09-20 23:36:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor

Browse source
This commit is contained in:
0xdcarns 2022-01-18 10:55:02 -05:00
parent cbe54ef2cf
commit 134a09670f
7 changed files with 106 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
controllers/node.go
View file

@ -404,8 +404,8 @@ func createNode(w http.ResponseWriter, r *http.Request) {
return return
} }
if err = runServerPeerUpdate(); err != nil { if err = runServerPeerUpdate(node.Network, true); err != nil {
logger.Log(1, "internal error when approving node:", node.ID) 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) 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")) returnErrorResponse(w, r, formatError(err, "internal"))
return 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, "internal error when approving node:", nodeid)
} }
logger.Log(1, r.Header.Get("user"), "uncordoned node", node.Name) 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")) returnErrorResponse(w, r, formatError(err, "internal"))
return 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, "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) 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")) returnErrorResponse(w, r, formatError(err, "internal"))
return 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, "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) 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 = logic.SetDNS()
} }
err = runServerUpdateIfNeeded(shouldPeersUpdate, newNode) err = runServerPeerUpdate(node.Network, shouldPeersUpdate)
if err != nil { if err != nil {
returnErrorResponse(w, r, formatError(err, "internal")) returnErrorResponse(w, r, formatError(err, "internal"))
return return
@ -593,7 +593,7 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
return return
} }
err = runServerPeerUpdate() err = runServerPeerUpdate(node.Network, true)
if err != nil { if err != nil {
returnErrorResponse(w, r, formatError(err, "internal")) returnErrorResponse(w, r, formatError(err, "internal"))
return return

6
controllers/node_grpc.go
View file

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

4
controllers/relay.go
View file

@ -26,7 +26,7 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal")) returnErrorResponse(w, r, formatError(err, "internal"))
return 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, "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) 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")) returnErrorResponse(w, r, formatError(err, "internal"))
return 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, "internal error when deleting relay on node:", nodeid)
} }
logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid) logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)

133
controllers/server_util.go
View file

@ -3,71 +3,11 @@ package controller
import ( import (
"github.com/gravitl/netmaker/logger" "github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/logic" "github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/serverctl"
) )
func runServerPeerUpdate() error { func runServerPeerUpdate(network string, shouldPeerUpdate bool) 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 { var currentServerNodeID, err = logic.GetNetworkServerNodeID(network)
// 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 { if err != nil {
return err return err
} }
@ -75,11 +15,72 @@ func handlePeerUpdate(node *models.Node) error {
if currErr != nil { if currErr != nil {
return currErr 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 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 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
// }

18
logic/nodes.go
View file

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

23
logic/server.go
View file

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

24
logic/util.go
View file

@ -39,17 +39,6 @@ func FileExists(f string) bool {
return !info.IsDir() 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 // DeleteNodeByMacAddress - deletes a node from database or moves into delete nodes table
func DeleteNodeByMacAddress(node *models.Node, exterminate bool) error { func DeleteNodeByMacAddress(node *models.Node, exterminate bool) error {
var err error var err error
@ -344,3 +333,16 @@ func StringSliceContains(slice []string, item string) bool {
} }
return false 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())
}
}