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
}
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

6
controllers/node_grpc.go
View file

@ -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")
}

4
controllers/relay.go
View file

@ -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)

133
controllers/server_util.go
View file

@ -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 runServerPeerUpdate(network string, shouldPeerUpdate bool) error {
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)
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
// }

18
logic/nodes.go
View file

@ -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

23
logic/server.go
View file

@ -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)

24
logic/util.go
View file

@ -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())
}
}