zishuo/netmaker
1
0
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-19 23:26:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor join

Browse Source 
also removes server node
suspect there may be issues with proxy
and UI interactions with nodes
This commit is contained in:
Matthew R. Kasun
2022-12-20 15:29:09 -05:00
parent c086e9499d
commit 38cd4d7700
100 changed files with 1027 additions and 8833 deletions
Download Patch File Download Diff File Expand all files Collapse all files

484
logic/nodes.go
View File

@@ -5,7 +5,7 @@ import (
"encoding/json"
"errors"
"fmt"
"sort"
"net"
"time"
validator "github.com/go-playground/validator/v10"
@@ -19,7 +19,6 @@ import (
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/servercfg"
"github.com/gravitl/netmaker/validation"
"golang.org/x/crypto/bcrypt"
)
@@ -33,11 +32,11 @@ const (
)
// GetNetworkNodes - gets the nodes of a network
func GetNetworkNodes(network string) ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
func GetNetworkNodes(network string) ([]models.Node, error) {
var nodes []models.Node
allnodes, err := GetAllNodes()
if err != nil {
return []models.LegacyNode{}, err
return []models.Node{}, err
}
for _, node := range allnodes {
if node.Network == network {
@@ -47,92 +46,11 @@ func GetNetworkNodes(network string) ([]models.LegacyNode, error) {
return nodes, nil
}
// GetSortedNetworkServerNodes - gets nodes of a network, except sorted by update time
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.LegacyNode{}, nil
}
return nodes, err
}
for _, value := range collection {
var node models.LegacyNode
err := json.Unmarshal([]byte(value), &node)
if err != nil {
continue
}
if node.Network == network && node.IsServer == "yes" {
nodes = append(nodes, node)
}
}
sort.Sort(models.NodesArray(nodes))
return nodes, nil
}
// GetServerNodes - gets the server nodes of a network
func GetServerNodes(network string) []models.LegacyNode {
var serverNodes = make([]models.LegacyNode, 0)
var nodes, err = GetNetworkNodes(network)
if err != nil {
return serverNodes
}
for _, node := range nodes {
if node.IsServer == "yes" {
serverNodes = append(serverNodes, node)
}
}
return serverNodes
}
// UncordonNode - approves a node to join a network
func UncordonNode(nodeid string) (models.LegacyNode, error) {
node, err := GetNodeByID(nodeid)
if err != nil {
return models.LegacyNode{}, err
}
node.SetLastModified()
node.IsPending = "no"
data, err := json.Marshal(&node)
if err != nil {
return node, err
}
err = database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
return node, err
}
// SetIfLeader - gets the peers of a given server 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.LegacyNode) bool {
nodes, err := GetSortedNetworkServerNodes(node.Network)
if err != nil {
logger.Log(0, "ERROR: COULD NOT RETRIEVE SERVER NODES. THIS WILL BREAK HOLE PUNCHING.")
return false
}
for _, n := range nodes {
if n.LastModified > time.Now().Add(-1*time.Minute).Unix() {
return n.Address == node.Address
}
}
return len(nodes) <= 1 || nodes[1].Address == node.Address
}
// == DB related functions ==
// UpdateNode - takes a node and updates another node with it's values
func UpdateNode(currentNode *models.LegacyNode, newNode *models.LegacyNode) error {
if newNode.Address != currentNode.Address {
func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
if newNode.Address.String() != currentNode.Address.String() {
if network, err := GetParentNetwork(newNode.Network); err == nil {
if !IsAddressInCIDR(newNode.Address, network.AddressRange) {
if !IsAddressInCIDR(newNode.Address.String(), network.AddressRange) {
return fmt.Errorf("invalid address provided; out of network range for node %s", newNode.ID)
}
}
@@ -140,9 +58,6 @@ func UpdateNode(currentNode *models.LegacyNode, newNode *models.LegacyNode) erro
nodeACLDelta := currentNode.DefaultACL != newNode.DefaultACL
newNode.Fill(currentNode)
if currentNode.IsServer == "yes" && !validateServer(currentNode, newNode) {
return fmt.Errorf("this operation is not supported on server nodes")
}
// check for un-settable server values
if err := ValidateNode(newNode, true); err != nil {
return err
@@ -151,7 +66,7 @@ func UpdateNode(currentNode *models.LegacyNode, newNode *models.LegacyNode) erro
if newNode.ID == currentNode.ID {
if nodeACLDelta {
if err := updateProNodeACLS(newNode); err != nil {
logger.Log(1, "failed to apply node level ACLs during creation of node", newNode.ID, "-", err.Error())
logger.Log(1, "failed to apply node level ACLs during creation of node", newNode.ID.String(), "-", err.Error())
return err
}
}
@@ -160,15 +75,15 @@ func UpdateNode(currentNode *models.LegacyNode, newNode *models.LegacyNode) erro
if data, err := json.Marshal(newNode); err != nil {
return err
} else {
return database.Insert(newNode.ID, string(data), database.NODES_TABLE_NAME)
return database.Insert(newNode.ID.String(), string(data), database.NODES_TABLE_NAME)
}
}
return fmt.Errorf("failed to update node " + currentNode.ID + ", cannot change ID.")
return fmt.Errorf("failed to update node " + currentNode.ID.String() + ", cannot change ID.")
}
// DeleteNode - marks node for deletion if called by UI or deletes node if called by node
func DeleteNode(node *models.LegacyNode, purge bool) error {
func DeleteNode(node *models.Node, purge bool) error {
if !purge {
newnode := node
newnode.PendingDelete = true
@@ -182,8 +97,9 @@ func DeleteNode(node *models.LegacyNode, purge bool) error {
return err
}
if servercfg.Is_EE {
if err := EnterpriseResetAllPeersFailovers(node.ID, node.Network); err != nil {
logger.Log(0, "failed to reset failover lists during node delete for node", node.Name, node.Network)
host, _ := GetHost(node.HostID.String())
if err := EnterpriseResetAllPeersFailovers(node.ID.String(), node.Network); err != nil {
logger.Log(0, "failed to reset failover lists during node delete for node", host.Name, node.Network)
}
}
@@ -191,12 +107,12 @@ func DeleteNode(node *models.LegacyNode, purge bool) error {
}
// DeleteNodeByID - deletes a node from database
func DeleteNodeByID(node *models.LegacyNode) error {
func DeleteNodeByID(node *models.Node) error {
var err error
var key = node.ID
var key = node.ID.String()
//delete any ext clients as required
if node.IsIngressGateway == "yes" {
if err := DeleteGatewayExtClients(node.ID, node.Network); err != nil {
if node.IsIngressGateway {
if err := DeleteGatewayExtClients(node.ID.String(), node.Network); err != nil {
logger.Log(0, "failed to deleted ext clients", err.Error())
}
}
@@ -209,34 +125,31 @@ func DeleteNodeByID(node *models.LegacyNode) error {
SetDNS()
}
if node.OwnerID != "" {
err = pro.DissociateNetworkUserNode(node.OwnerID, node.Network, node.ID)
err = pro.DissociateNetworkUserNode(node.OwnerID, node.Network, node.ID.String())
if err != nil {
logger.Log(0, "failed to dissasociate", node.OwnerID, "from node", node.ID, ":", err.Error())
logger.Log(0, "failed to dissasociate", node.OwnerID, "from node", node.ID.String(), ":", err.Error())
}
}
_, err = nodeacls.RemoveNodeACL(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID))
_, err = nodeacls.RemoveNodeACL(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID.String()))
if err != nil {
// ignoring for now, could hit a nil pointer if delete called twice
logger.Log(2, "attempted to remove node ACL for node", node.Name, node.ID)
logger.Log(2, "attempted to remove node ACL for node", node.ID.String())
}
// removeZombie <- node.ID
if err = DeleteMetrics(node.ID); err != nil {
logger.Log(1, "unable to remove metrics from DB for node", node.ID, err.Error())
}
if node.IsServer == "yes" {
return removeLocalServer(node)
if err = DeleteMetrics(node.ID.String()); err != nil {
logger.Log(1, "unable to remove metrics from DB for node", node.ID.String(), err.Error())
}
return nil
}
// IsNodeIDUnique - checks if node id is unique
func IsNodeIDUnique(node *models.LegacyNode) (bool, error) {
_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID)
func IsNodeIDUnique(node *models.Node) (bool, error) {
_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID.String())
return database.IsEmptyRecord(err), err
}
// ValidateNode - validates node values
func ValidateNode(node *models.LegacyNode, isUpdate bool) error {
func ValidateNode(node *models.Node, isUpdate bool) error {
v := validator.New()
_ = v.RegisterValidation("id_unique", func(fl validator.FieldLevel) bool {
if isUpdate {
@@ -249,18 +162,7 @@ func ValidateNode(node *models.LegacyNode, isUpdate bool) error {
_, err := GetNetworkByNode(node)
return err == nil
})
_ = v.RegisterValidation("in_charset", func(fl validator.FieldLevel) bool {
isgood := node.NameInNodeCharSet()
return isgood
})
_ = v.RegisterValidation("checkyesorno", func(fl validator.FieldLevel) bool {
return validation.CheckYesOrNo(fl)
})
_ = v.RegisterValidation("checkyesornoorunset", func(fl validator.FieldLevel) bool {
return validation.CheckYesOrNoOrUnset(fl)
})
err := v.Struct(node)
return err
}
@@ -271,7 +173,7 @@ func IsFailoverPresent(network string) bool {
return false
}
for i := range netNodes {
if netNodes[i].Failover == "yes" {
if netNodes[i].Failover {
return true
}
}
@@ -279,23 +181,24 @@ func IsFailoverPresent(network string) bool {
}
// CreateNode - creates a node in database
func CreateNode(node *models.LegacyNode) error {
func CreateNode(node *models.Node) error {
host, err := GetHost(node.HostID.String())
if err != nil {
return err
}
//encrypt that password so we never see it
hash, err := bcrypt.GenerateFromPassword([]byte(node.Password), 5)
hash, err := bcrypt.GenerateFromPassword([]byte(host.HostPass), 5)
if err != nil {
return err
}
//set password to encrypted password
node.Password = string(hash)
if node.Name == models.NODE_SERVER_NAME {
node.IsServer = "yes"
}
if node.DNSOn == "" {
host.HostPass = string(hash)
if !node.DNSOn {
if servercfg.IsDNSMode() {
node.DNSOn = "yes"
node.DNSOn = true
} else {
node.DNSOn = "no"
node.DNSOn = false
}
}
@@ -313,34 +216,29 @@ func CreateNode(node *models.LegacyNode) error {
node.DefaultACL = "unset"
}
reverse := node.IsServer == "yes"
if node.Address == "" {
if node.Address.IP == nil {
if parentNetwork.IsIPv4 == "yes" {
if node.Address, err = UniqueAddress(node.Network, reverse); err != nil {
if node.Address.IP, err = UniqueAddress(node.Network, false); err != nil {
return err
}
}
} else if !IsIPUnique(node.Network, node.Address, database.NODES_TABLE_NAME, false) {
return fmt.Errorf("invalid address: ipv4 " + node.Address + " is not unique")
} else if !IsIPUnique(node.Network, node.Address.String(), database.NODES_TABLE_NAME, false) {
return fmt.Errorf("invalid address: ipv4 " + node.Address.String() + " is not unique")
}
if node.Address6 == "" {
if node.Address6.IP == nil {
if parentNetwork.IsIPv6 == "yes" {
if node.Address6, err = UniqueAddress6(node.Network, reverse); err != nil {
if node.Address6.IP, err = UniqueAddress6(node.Network, false); err != nil {
return err
}
}
} else if !IsIPUnique(node.Network, node.Address6, database.NODES_TABLE_NAME, true) {
return fmt.Errorf("invalid address: ipv6 " + node.Address6 + " is not unique")
}
node.ID = uuid.NewString()
if node.IsServer == "yes" {
node.HostID = uuid.NewString()
} else if !IsIPUnique(node.Network, node.Address6.String(), database.NODES_TABLE_NAME, true) {
return fmt.Errorf("invalid address: ipv6 " + node.Address6.String() + " is not unique")
}
node.ID = uuid.New()
//Create a JWT for the node
tokenString, _ := CreateJWT(node.ID, node.MacAddress, node.Network)
tokenString, _ := CreateJWT(node.ID.String(), host.MacAddress.String(), node.Network)
if tokenString == "" {
//logic.ReturnErrorResponse(w, r, errorResponse)
return err
@@ -349,34 +247,30 @@ func CreateNode(node *models.LegacyNode) error {
if err != nil {
return err
}
CheckZombies(node)
CheckZombies(node, host.MacAddress)
nodebytes, err := json.Marshal(&node)
if err != nil {
return err
}
err = database.Insert(node.ID, string(nodebytes), database.NODES_TABLE_NAME)
err = database.Insert(node.ID.String(), string(nodebytes), database.NODES_TABLE_NAME)
if err != nil {
return err
}
_, err = nodeacls.CreateNodeACL(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID), defaultACLVal)
_, err = nodeacls.CreateNodeACL(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID.String()), defaultACLVal)
if err != nil {
logger.Log(1, "failed to create node ACL for node,", node.ID, "err:", err.Error())
logger.Log(1, "failed to create node ACL for node,", node.ID.String(), "err:", err.Error())
return err
}
if err = updateProNodeACLS(node); err != nil {
logger.Log(1, "failed to apply node level ACLs during creation of node", node.ID, "-", err.Error())
logger.Log(1, "failed to apply node level ACLs during creation of node", node.ID.String(), "-", err.Error())
return err
}
if node.IsPending != "yes" {
DecrimentKey(node.Network, node.AccessKey)
}
if err = UpdateMetrics(node.ID, &models.Metrics{Connectivity: make(map[string]models.Metric)}); err != nil {
logger.Log(1, "failed to initialize metrics for node", node.Name, node.ID, err.Error())
if err = UpdateMetrics(node.ID.String(), &models.Metrics{Connectivity: make(map[string]models.Metric)}); err != nil {
logger.Log(1, "failed to initialize metrics for node", node.ID.String(), err.Error())
}
SetNetworkNodesLastModified(node.Network)
@@ -387,21 +281,21 @@ func CreateNode(node *models.LegacyNode) error {
}
// GetAllNodes - returns all nodes in the DB
func GetAllNodes() ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
func GetAllNodes() ([]models.Node, error) {
var nodes []models.Node
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
if err != nil {
if database.IsEmptyRecord(err) {
return []models.LegacyNode{}, nil
return []models.Node{}, nil
}
return []models.LegacyNode{}, err
return []models.Node{}, err
}
for _, value := range collection {
var node models.LegacyNode
var node models.Node
if err := json.Unmarshal([]byte(value), &node); err != nil {
return []models.LegacyNode{}, err
return []models.Node{}, err
}
// add node to our array
nodes = append(nodes, node)
@@ -410,24 +304,6 @@ func GetAllNodes() ([]models.LegacyNode, error) {
return nodes, nil
}
// CheckIsServer - check if a node is the server node
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.LegacyNode
if err := json.Unmarshal([]byte(value), &tmpNode); err != nil {
continue
}
if tmpNode.Network == node.Network && tmpNode.MacAddress != node.MacAddress {
return false
}
}
return true
}
// GetNetworkByNode - gets the network model from a node
func GetNetworkByNode(node *models.Node) (models.Network, error) {
@@ -443,28 +319,21 @@ func GetNetworkByNode(node *models.Node) (models.Network, error) {
}
// SetNodeDefaults - sets the defaults of a node to avoid empty fields
func SetNodeDefaults(node *models.LegacyNode) {
func SetNodeDefaults(node *models.Node) {
//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)
node.NetworkSettings = parentNetwork
node.NetworkSettings.AccessKeys = []models.AccessKey{}
_, cidr, _ := net.ParseCIDR(parentNetwork.AddressRange)
node.NetworkRange = *cidr
_, cidr, _ = net.ParseCIDR(parentNetwork.AddressRange6)
node.NetworkRange6 = *cidr
node.ExpirationDateTime = time.Now().Add(models.TEN_YEARS_IN_SECONDS)
node.ExpirationDateTime = time.Now().Unix() + models.TEN_YEARS_IN_SECONDS
if node.DefaultACL == "" && node.IsServer != "yes" {
if node.DefaultACL == "" {
node.DefaultACL = parentNetwork.DefaultACL
}
if node.ListenPort == 0 {
node.ListenPort = parentNetwork.DefaultListenPort
}
if node.Interface == "" {
node.Interface = parentNetwork.DefaultInterface
}
if node.PersistentKeepalive == 0 {
node.PersistentKeepalive = parentNetwork.DefaultKeepalive
node.PersistentKeepalive = int(parentNetwork.DefaultKeepalive)
}
if node.PostUp == "" {
postup := parentNetwork.DefaultPostUp
@@ -474,44 +343,41 @@ func SetNodeDefaults(node *models.LegacyNode) {
postdown := parentNetwork.DefaultPostDown
node.PostDown = postdown
}
if node.IsStatic == "" {
node.IsStatic = "no"
}
if node.UDPHolePunch == "" {
node.UDPHolePunch = parentNetwork.DefaultUDPHolePunch
if node.UDPHolePunch == "" {
node.UDPHolePunch = "yes"
}
}
// == Parent Network settings ==
if node.MTU == 0 {
node.MTU = parentNetwork.DefaultMTU
}
// == node defaults if not set by parent ==
node.SetIPForwardingDefault()
node.SetDNSOnDefault()
node.SetIsLocalDefault()
node.SetLastModified()
node.SetDefaultName()
node.SetLastCheckIn()
node.SetLastPeerUpdate()
node.SetDefaultAction()
node.SetIsServerDefault()
node.SetIsStaticDefault()
node.SetDefaultEgressGateway()
node.SetDefaultIngressGateway()
node.SetDefaulIsPending()
node.SetDefaultMTU()
node.SetDefaultNFTablesPresent()
node.SetDefaultIsRelayed()
node.SetDefaultIsRelay()
node.SetDefaultIsDocker()
node.SetDefaultIsK8S()
node.SetDefaultIsHub()
node.SetDefaultConnected()
node.SetDefaultACL()
node.SetDefaultFailover()
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
//node.SetIPForwardingDefault()
//node.SetDNSOnDefault()
//node.SetIsLocalDefault()
//node.SetLastModified()
//node.SetDefaultName()
//node.SetLastCheckIn()
//node.SetLastPeerUpdate()
//node.SetDefaultAction()
//node.SetIsServerDefault()
//node.SetIsStaticDefault()
//node.SetDefaultEgressGateway()
//node.SetDefaultIngressGateway()
//node.SetDefaulIsPending()
//node.SetDefaultMTU()
//node.SetDefaultNFTablesPresent()
//node.SetDefaultIsRelayed()
//node.SetDefaultIsRelay()
//node.SetDefaultIsDocker()
//node.SetDefaultIsK8S()
//node.SetDefaultIsHub()
//node.SetDefaultConnected()
//node.SetDefaultACL()
//node.SetDefaultFailover()
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
///TODO ___ REVISIT ------
}
// GetRecordKey - get record key
@@ -524,9 +390,9 @@ func GetRecordKey(id string, network string) (string, error) {
}
// GetNodeByMacAddress - gets a node by mac address
func GetNodeByMacAddress(network string, macaddress string) (models.LegacyNode, error) {
func GetNodeByMacAddress(network string, macaddress string) (models.Node, error) {
var node models.LegacyNode
var node models.Node
key, err := GetRecordKey(macaddress, network)
if err != nil {
@@ -535,11 +401,11 @@ func GetNodeByMacAddress(network string, macaddress string) (models.LegacyNode,
record, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
if err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
SetNodeDefaults(&node)
@@ -548,14 +414,14 @@ func GetNodeByMacAddress(network string, macaddress string) (models.LegacyNode,
}
// GetNodesByAddress - gets a node by mac address
func GetNodesByAddress(network string, addresses []string) ([]models.LegacyNode, error) {
var nodes []models.LegacyNode
func GetNodesByAddress(network string, addresses []string) ([]models.Node, error) {
var nodes []models.Node
allnodes, err := GetAllNodes()
if err != nil {
return []models.LegacyNode{}, err
return []models.Node{}, err
}
for _, node := range allnodes {
if node.Network == network && ncutils.StringSliceContains(addresses, node.Address) {
if node.Network == network && ncutils.StringSliceContains(addresses, node.Address.String()) {
nodes = append(nodes, node)
}
}
@@ -563,9 +429,9 @@ func GetNodesByAddress(network string, addresses []string) ([]models.LegacyNode,
}
// GetDeletedNodeByMacAddress - get a deleted node
func GetDeletedNodeByMacAddress(network string, macaddress string) (models.LegacyNode, error) {
func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Node, error) {
var node models.LegacyNode
var node models.Node
key, err := GetRecordKey(macaddress, network)
if err != nil {
@@ -574,11 +440,11 @@ func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Legac
record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
if err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
SetNodeDefaults(&node)
@@ -587,9 +453,9 @@ func GetDeletedNodeByMacAddress(network string, macaddress string) (models.Legac
}
// GetNodeRelay - gets the relay node of a given network
func GetNodeRelay(network string, relayedNodeAddr string) (models.LegacyNode, error) {
func GetNodeRelay(network string, relayedNodeAddr string) (models.Node, error) {
collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
var relay models.LegacyNode
var relay models.Node
if err != nil {
if database.IsEmptyRecord(err) {
return relay, nil
@@ -603,7 +469,7 @@ func GetNodeRelay(network string, relayedNodeAddr string) (models.LegacyNode, er
logger.Log(2, err.Error())
continue
}
if relay.IsRelay == "yes" {
if relay.IsRelay {
for _, addr := range relay.RelayAddrs {
if addr == relayedNodeAddr {
return relay, nil
@@ -614,30 +480,30 @@ func GetNodeRelay(network string, relayedNodeAddr string) (models.LegacyNode, er
return relay, errors.New(RELAY_NODE_ERR + " " + relayedNodeAddr)
}
func GetNodeByID(uuid string) (models.LegacyNode, error) {
func GetNodeByID(uuid string) (models.Node, error) {
var record, err = database.FetchRecord(database.NODES_TABLE_NAME, uuid)
if err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
var node models.LegacyNode
var node models.Node
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
return node, nil
}
// GetDeletedNodeByID - get a deleted node
func GetDeletedNodeByID(uuid string) (models.LegacyNode, error) {
func GetDeletedNodeByID(uuid string) (models.Node, error) {
var node models.LegacyNode
var node models.Node
record, err := database.FetchRecord(database.DELETED_NODES_TABLE_NAME, uuid)
if err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
if err = json.Unmarshal([]byte(record), &node); err != nil {
return models.LegacyNode{}, err
return models.Node{}, err
}
SetNodeDefaults(&node)
@@ -645,81 +511,9 @@ func GetDeletedNodeByID(uuid string) (models.LegacyNode, error) {
return node, nil
}
// GetNetworkServerNodeID - get network server node ID if exists
func GetNetworkServerLeader(network string) (models.LegacyNode, error) {
nodes, err := GetSortedNetworkServerNodes(network)
if err != nil {
return models.LegacyNode{}, err
}
for _, node := range nodes {
if IsLeader(&node) {
return node, nil
}
}
return models.LegacyNode{}, errors.New("could not find server leader")
}
// GetNetworkServerNodeID - get network server node ID if exists
func GetNetworkServerLocal(network string) (models.LegacyNode, error) {
nodes, err := GetSortedNetworkServerNodes(network)
if err != nil {
return models.LegacyNode{}, err
}
mac := servercfg.GetNodeID()
if mac == "" {
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.LegacyNode{}, errors.New("could not find node for local server")
}
// IsLocalServer - get network server node ID if exists
func IsLocalServer(node *models.LegacyNode) bool {
var islocal bool
local, err := GetNetworkServerLocal(node.Network)
if err != nil {
return islocal
}
return node.ID != "" && local.ID == node.ID
}
// validateServer - make sure servers dont change port or address
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.LegacyNode, error) {
var nodesToUpdate models.LegacyNode
nodes, err := GetNetworkNodes(networkName)
if err != nil {
return &nodesToUpdate, err
}
for i := range nodes {
if nodes[i].IsHub == "yes" {
nodes[i].IsHub = "no"
nodesToUpdate = nodes[i]
newNodeData, err := json.Marshal(&nodes[i])
if err != nil {
logger.Log(1, "error on node during hub update")
return &nodesToUpdate, err
}
database.Insert(nodes[i].ID, string(newNodeData), database.NODES_TABLE_NAME)
}
}
return &nodesToUpdate, nil
}
// FindRelay - returns the node that is the relay for a relayed node
func FindRelay(node *models.LegacyNode) *models.LegacyNode {
if node.IsRelayed == "no" {
func FindRelay(node *models.Node) *models.Node {
if !node.IsRelayed {
return nil
}
peers, err := GetNetworkNodes(node.Network)
@@ -727,11 +521,11 @@ func FindRelay(node *models.LegacyNode) *models.LegacyNode {
return nil
}
for _, peer := range peers {
if peer.IsRelay == "no" {
if !peer.IsRelay {
continue
}
for _, ip := range peer.RelayAddrs {
if ip == node.Address || ip == node.Address6 {
if ip == node.Address.IP.String() || ip == node.Address6.IP.String() {
return &peer
}
}
@@ -739,16 +533,16 @@ func FindRelay(node *models.LegacyNode) *models.LegacyNode {
return nil
}
func findNode(ip string) (*models.LegacyNode, error) {
func findNode(ip string) (*models.Node, error) {
nodes, err := GetAllNodes()
if err != nil {
return nil, err
}
for _, node := range nodes {
if node.Address == ip {
if node.Address.IP.String() == ip {
return &node, nil
}
if node.Address6 == ip {
if node.Address6.IP.String() == ip {
return &node, nil
}
}
@@ -756,14 +550,14 @@ func findNode(ip string) (*models.LegacyNode, error) {
}
// GetNetworkIngresses - gets the gateways of a network
func GetNetworkIngresses(network string) ([]models.LegacyNode, error) {
var ingresses []models.LegacyNode
func GetNetworkIngresses(network string) ([]models.Node, error) {
var ingresses []models.Node
netNodes, err := GetNetworkNodes(network)
if err != nil {
return []models.LegacyNode{}, err
return []models.Node{}, err
}
for i := range netNodes {
if netNodes[i].IsIngressGateway == "yes" {
if netNodes[i].IsIngressGateway {
ingresses = append(ingresses, netNodes[i])
}
}
@@ -772,7 +566,7 @@ func GetNetworkIngresses(network string) ([]models.LegacyNode, error) {
// == PRO ==
func updateProNodeACLS(node *models.LegacyNode) error {
func updateProNodeACLS(node *models.Node) error {
// == PRO node ACLs ==
networkNodes, err := GetNetworkNodes(node.Network)
if err != nil {
@@ -799,12 +593,12 @@ func PurgePendingNodes(ctx context.Context) {
}
for _, node := range nodes {
if node.PendingDelete {
modified := time.Unix(node.LastModified, 0)
modified := node.LastModified
if time.Since(modified) > NodePurgeTime {
if err := DeleteNode(&node, true); err != nil {
logger.Log(0, "failed to purge node", node.ID, err.Error())
logger.Log(0, "failed to purge node", node.ID.String(), err.Error())
} else {
logger.Log(0, "purged node ", node.ID)
logger.Log(0, "purged node ", node.ID.String())
}
}