modified getpeers for hub network

controllers/node_grpc.go

@@ -232,12 +232,7 @@ func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*
 		return nil, err
 	}
 
-	excludeIsRelayed := node.IsRelay != "yes"
+	peers, err := logic.GetPeersList(&node)
-	var relayedNode string
-	if node.IsRelayed == "yes" {
-		relayedNode = node.Address
-	}
-	peers, err := logic.GetPeersList(node.Network, excludeIsRelayed, relayedNode)
 	if err != nil {
 		if strings.Contains(err.Error(), logic.RELAY_NODE_ERR) {
 			peers, err = logic.PeerListUnRelay(node.ID, node.Network)

database/database.go

@@ -32,9 +32,6 @@ const DNS_TABLE_NAME = "dns"
 // EXT_CLIENT_TABLE_NAME - ext client table
 const EXT_CLIENT_TABLE_NAME = "extclients"
 
-// INT_CLIENTS_TABLE_NAME - int client table
-const INT_CLIENTS_TABLE_NAME = "intclients"
-
 // PEERS_TABLE_NAME - peers table
 const PEERS_TABLE_NAME = "peers"
 
@@ -126,7 +123,6 @@ func createTables() {
 	createTable(USERS_TABLE_NAME)
 	createTable(DNS_TABLE_NAME)
 	createTable(EXT_CLIENT_TABLE_NAME)
-	createTable(INT_CLIENTS_TABLE_NAME)
 	createTable(PEERS_TABLE_NAME)
 	createTable(SERVERCONF_TABLE_NAME)
 	createTable(SERVER_UUID_TABLE_NAME)

functions/helpers.go

@@ -2,100 +2,12 @@ package functions
 
 import (
 	"encoding/json"
-	"log"
 	"strings"
 
 	"github.com/gravitl/netmaker/database"
-	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
 )
 
-// ParseNode - parses a node into a model
-func ParseNode(value string) (models.Node, error) {
-	var node models.Node
-	err := json.Unmarshal([]byte(value), &node)
-	return node, err
-}
-
-// ParseExtClient - parses an extclient into a model
-func ParseExtClient(value string) (models.ExtClient, error) {
-	var extClient models.ExtClient
-	err := json.Unmarshal([]byte(value), &extClient)
-	return extClient, err
-}
-
-// ParseIntClient - parses int client
-func ParseIntClient(value string) (models.IntClient, error) {
-	var intClient models.IntClient
-	err := json.Unmarshal([]byte(value), &intClient)
-	return intClient, err
-}
-
-// GetPeersList - gets peers for given network
-func GetPeersList(networkName string) ([]models.PeersResponse, error) {
-
-	var peers []models.PeersResponse
-	collection, err := database.FetchRecords(database.NODES_TABLE_NAME)
-	if err != nil {
-		return peers, err
-	}
-
-	for _, value := range collection {
-
-		var peer models.PeersResponse
-		err := json.Unmarshal([]byte(value), &peer)
-		if err != nil {
-			continue // try the rest
-		}
-		peers = append(peers, peer)
-	}
-
-	return peers, err
-}
-
-// GetIntPeersList - get int peers list
-func GetIntPeersList() ([]models.PeersResponse, error) {
-
-	var peers []models.PeersResponse
-	records, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
-
-	if err != nil {
-		return peers, err
-	}
-	// parse the peers
-
-	for _, value := range records {
-
-		var peer models.PeersResponse
-		err := json.Unmarshal([]byte(value), &peer)
-		if err != nil {
-			log.Fatal(err)
-		}
-		// add the node to our node array
-		//maybe better to just return this? But then that's just GetNodes...
-		peers = append(peers, peer)
-	}
-
-	return peers, err
-}
-
-// GetServerIntClient - get server int client
-func GetServerIntClient() (*models.IntClient, error) {
-
-	intClients, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
-	for _, value := range intClients {
-		var intClient models.IntClient
-		err = json.Unmarshal([]byte(value), &intClient)
-		if err != nil {
-			return nil, err
-		}
-		if intClient.IsServer == "yes" && intClient.Network == "comms" {
-			return &intClient, nil
-		}
-	}
-	return nil, err
-}
-
 // NetworkExists - check if network exists
 func NetworkExists(name string) (bool, error) {
 
@@ -107,34 +19,6 @@ func NetworkExists(name string) (bool, error) {
 	return len(network) > 0, nil
 }
 
-// IsKeyValidGlobal - checks if a key is valid globally
-func IsKeyValidGlobal(keyvalue string) bool {
-
-	networks, _ := logic.GetNetworks()
-	var key models.AccessKey
-	foundkey := false
-	isvalid := false
-	for _, network := range networks {
-		for i := len(network.AccessKeys) - 1; i >= 0; i-- {
-			currentkey := network.AccessKeys[i]
-			if currentkey.Value == keyvalue {
-				key = currentkey
-				foundkey = true
-				break
-			}
-		}
-		if foundkey {
-			break
-		}
-	}
-	if foundkey {
-		if key.Uses > 0 {
-			isvalid = true
-		}
-	}
-	return isvalid
-}
-
 // NameInDNSCharSet - name in dns char set
 func NameInDNSCharSet(name string) bool {
 
@@ -166,37 +50,6 @@ func RemoveDeletedNode(nodeid string) bool {
 	return database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, nodeid) == nil
 }
 
-// DeleteAllIntClients - delete all int clients
-func DeleteAllIntClients() error {
-	err := database.DeleteAllRecords(database.INT_CLIENTS_TABLE_NAME)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// GetAllIntClients - get all int clients
-func GetAllIntClients() ([]models.IntClient, error) {
-	var clients []models.IntClient
-	collection, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
-
-	if err != nil {
-		return clients, err
-	}
-
-	for _, value := range collection {
-		var client models.IntClient
-		err := json.Unmarshal([]byte(value), &client)
-		if err != nil {
-			return []models.IntClient{}, err
-		}
-		// add node to our array
-		clients = append(clients, client)
-	}
-
-	return clients, nil
-}
-
 // GetAllExtClients - get all ext clients
 func GetAllExtClients() ([]models.ExtClient, error) {
 	var extclients []models.ExtClient

logic/networks.go

@@ -187,14 +187,8 @@ func UniqueAddress(networkName string) (string, error) {
 			offset = false
 			continue
 		}
-		if networkName == "comms" {
+		if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, false) && IsIPUnique(networkName, ip.String(), database.EXT_CLIENT_TABLE_NAME, false) {
-			if IsIPUnique(networkName, ip.String(), database.INT_CLIENTS_TABLE_NAME, false) {
+			return ip.String(), err
-				return ip.String(), err
-			}
-		} else {
-			if IsIPUnique(networkName, ip.String(), database.NODES_TABLE_NAME, false) && IsIPUnique(networkName, ip.String(), database.EXT_CLIENT_TABLE_NAME, false) {
-				return ip.String(), err
-			}
 		}
 	}
 

logic/nodes.go

@@ -99,12 +99,7 @@ func GetPeers(node *models.Node) ([]models.Node, error) {
 	if IsLeader(node) {
 		setNetworkServerPeers(node)
 	}
-	excludeIsRelayed := node.IsRelay != "yes"
+	peers, err := GetPeersList(node)
-	var relayedNode string
-	if node.IsRelayed == "yes" {
-		relayedNode = node.Address
-	}
-	peers, err := GetPeersList(node.Network, excludeIsRelayed, relayedNode)
 	if err != nil {
 		if strings.Contains(err.Error(), RELAY_NODE_ERR) {
 			peers, err = PeerListUnRelay(node.ID, node.Network)

logic/peers.go

@@ -7,12 +7,135 @@ import (
 	"strings"
 	"time"
 
+	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
+// GetHubPeer - in HubAndSpoke networks, if not the hub, return the hub
+func GetHubPeer(networkName string) []models.Node {
+	var hubpeer = make([]models.Node, 0)
+	servernodes, err := GetNetworkNodes(networkName)
+	if err != nil {
+		return hubpeer
+	}
+	for i := range servernodes {
+		if servernodes[i].IsHub == "yes" {
+			return []models.Node{servernodes[i]}
+		}
+	}
+	return hubpeer
+}
+
+// GetNodePeers - fetches peers for a given node
+func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error) {
+	var peers []models.Node
+	var networkNodes, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
+	if err != nil {
+		return peers, nil
+	}
+
+	udppeers, errN := database.GetPeers(networkName)
+	if errN != nil {
+		logger.Log(2, errN.Error())
+	}
+
+	for _, node := range networkNodes {
+		var peer = models.Node{}
+		if node.IsEgressGateway == "yes" { // handle egress stuff
+			peer.EgressGatewayRanges = node.EgressGatewayRanges
+			peer.IsEgressGateway = node.IsEgressGateway
+		}
+		allow := node.IsRelayed != "yes" || !excludeRelayed
+
+		if node.Network == networkName && node.IsPending != "yes" && allow {
+			peer = setPeerInfo(&node)
+			if node.UDPHolePunch == "yes" && errN == nil && CheckEndpoint(udppeers[node.PublicKey]) {
+				endpointstring := udppeers[node.PublicKey]
+				endpointarr := strings.Split(endpointstring, ":")
+				if len(endpointarr) == 2 {
+					port, err := strconv.Atoi(endpointarr[1])
+					if err == nil {
+						// peer.Endpoint = endpointarr[0]
+						peer.ListenPort = int32(port)
+					}
+				}
+			}
+			if node.IsRelay == "yes" {
+				network, err := GetNetwork(networkName)
+				if err == nil {
+					peer.AllowedIPs = append(peer.AllowedIPs, network.AddressRange)
+				} else {
+					peer.AllowedIPs = append(peer.AllowedIPs, node.RelayAddrs...)
+				}
+				for _, egressNode := range egressNetworkNodes {
+					if egressNode.IsRelayed == "yes" && StringSliceContains(node.RelayAddrs, egressNode.Address) {
+						peer.AllowedIPs = append(peer.AllowedIPs, egressNode.EgressGatewayRanges...)
+					}
+				}
+			}
+			peers = append(peers, peer)
+		}
+	}
+
+	return peers, err
+}
+
+// GetPeersList - gets the peers of a given network
+func GetPeersList(refnode *models.Node) ([]models.Node, error) {
+	var peers []models.Node
+	var err error
+	var networkName = refnode.Network
+	var excludeRelayed = refnode.IsRelay != "yes"
+	var relayedNodeAddr string
+	if refnode.IsRelayed == "yes" {
+		relayedNodeAddr = refnode.Address
+	}
+	network, err := GetNetwork(networkName)
+	if err != nil {
+		return peers, err
+	} else if network.IsHubAndSpoke == "yes" && refnode.IsHub != "yes" {
+		return GetHubPeer(networkName), nil
+	}
+	if relayedNodeAddr == "" {
+		peers, err = GetNodePeers(networkName, excludeRelayed)
+	} else {
+		var relayNode models.Node
+		relayNode, err = GetNodeRelay(networkName, relayedNodeAddr)
+		if relayNode.Address != "" {
+			var peerNode = setPeerInfo(&relayNode)
+			network, err := GetNetwork(networkName)
+			if err == nil {
+				peerNode.AllowedIPs = append(peerNode.AllowedIPs, network.AddressRange)
+				var _, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
+				if err == nil {
+					for _, egress := range egressNetworkNodes {
+						if egress.Address != relayedNodeAddr {
+							peerNode.AllowedIPs = append(peerNode.AllowedIPs, egress.EgressGatewayRanges...)
+						}
+					}
+				}
+			} else {
+				peerNode.AllowedIPs = append(peerNode.AllowedIPs, peerNode.RelayAddrs...)
+			}
+			nodepeers, err := GetNodePeers(networkName, false)
+			if err == nil && peerNode.UDPHolePunch == "yes" {
+				for _, nodepeer := range nodepeers {
+					if nodepeer.Address == peerNode.Address {
+						// peerNode.Endpoint = nodepeer.Endpoint
+						peerNode.ListenPort = nodepeer.ListenPort
+					}
+				}
+			}
+
+			peers = append(peers, peerNode)
+		}
+	}
+	return peers, err
+}
+
 // GetPeerUpdate - gets a wireguard peer config for each peer of a node
 func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
 	var peerUpdate models.PeerUpdate

logic/relay.go

@@ -89,14 +89,14 @@ func SetRelayedNodes(yesOrno string, networkName string, addrs []string) ([]mode
 }
 
 // SetNodeIsRelayed - Sets IsRelayed to on or off for relay
-func SetNodeIsRelayed(yesOrno string, id string) error {
+func SetNodeIsRelayed(yesOrno string, id string) (models.Node, error) {
 	node, err := GetNodeByID(id)
 	if err != nil {
-		return err
+		return node, err
 	}
 	network, err := GetNetworkByNode(&node)
 	if err != nil {
-		return err
+		return node, err
 	}
 	node.IsRelayed = yesOrno
 	if yesOrno == "yes" {
@@ -106,18 +106,18 @@ func SetNodeIsRelayed(yesOrno string, id string) error {
 	}
 	data, err := json.Marshal(&node)
 	if err != nil {
-		return err
+		return node, err
 	}
-	return database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
+	return node, database.Insert(node.ID, string(data), database.NODES_TABLE_NAME)
 }
 
 // PeerListUnRelay - call this function if a relayed node fails to get its relay: unrelays node and gets new peer list
 func PeerListUnRelay(id string, network string) ([]models.Node, error) {
-	err := SetNodeIsRelayed("no", id)
+	node, err := SetNodeIsRelayed("no", id)
 	if err != nil {
 		return nil, err
 	}
-	return GetPeersList(network, true, "")
+	return GetPeersList(&node)
 }
 
 // ValidateRelay - checks if relay is valid

logic/util.go

@@ -10,7 +10,6 @@ import (
 	"math/rand"
 	"net"
 	"os"
-	"strconv"
 	"strings"
 	"time"
 
@@ -130,101 +129,6 @@ func DeleteNodeByID(node *models.Node, exterminate bool) error {
 	return removeLocalServer(node)
 }
 
-// GetNodePeers - fetches peers for a given node
-func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error) {
-	var peers []models.Node
-	var networkNodes, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
-	if err != nil {
-		return peers, nil
-	}
-
-	udppeers, errN := database.GetPeers(networkName)
-	if errN != nil {
-		logger.Log(2, errN.Error())
-	}
-
-	for _, node := range networkNodes {
-		var peer = models.Node{}
-		if node.IsEgressGateway == "yes" { // handle egress stuff
-			peer.EgressGatewayRanges = node.EgressGatewayRanges
-			peer.IsEgressGateway = node.IsEgressGateway
-		}
-		allow := node.IsRelayed != "yes" || !excludeRelayed
-
-		if node.Network == networkName && node.IsPending != "yes" && allow {
-			peer = setPeerInfo(&node)
-			if node.UDPHolePunch == "yes" && errN == nil && CheckEndpoint(udppeers[node.PublicKey]) {
-				endpointstring := udppeers[node.PublicKey]
-				endpointarr := strings.Split(endpointstring, ":")
-				if len(endpointarr) == 2 {
-					port, err := strconv.Atoi(endpointarr[1])
-					if err == nil {
-						// peer.Endpoint = endpointarr[0]
-						peer.ListenPort = int32(port)
-					}
-				}
-			}
-			if node.IsRelay == "yes" {
-				network, err := GetNetwork(networkName)
-				if err == nil {
-					peer.AllowedIPs = append(peer.AllowedIPs, network.AddressRange)
-				} else {
-					peer.AllowedIPs = append(peer.AllowedIPs, node.RelayAddrs...)
-				}
-				for _, egressNode := range egressNetworkNodes {
-					if egressNode.IsRelayed == "yes" && StringSliceContains(node.RelayAddrs, egressNode.Address) {
-						peer.AllowedIPs = append(peer.AllowedIPs, egressNode.EgressGatewayRanges...)
-					}
-				}
-			}
-			peers = append(peers, peer)
-		}
-	}
-
-	return peers, err
-}
-
-// GetPeersList - gets the peers of a given network
-func GetPeersList(networkName string, excludeRelayed bool, relayedNodeAddr string) ([]models.Node, error) {
-	var peers []models.Node
-	var err error
-	if relayedNodeAddr == "" {
-		peers, err = GetNodePeers(networkName, excludeRelayed)
-	} else {
-		var relayNode models.Node
-		relayNode, err = GetNodeRelay(networkName, relayedNodeAddr)
-		if relayNode.Address != "" {
-			var peerNode = setPeerInfo(&relayNode)
-			network, err := GetNetwork(networkName)
-			if err == nil {
-				peerNode.AllowedIPs = append(peerNode.AllowedIPs, network.AddressRange)
-				var _, egressNetworkNodes, err = getNetworkEgressAndNodes(networkName)
-				if err == nil {
-					for _, egress := range egressNetworkNodes {
-						if egress.Address != relayedNodeAddr {
-							peerNode.AllowedIPs = append(peerNode.AllowedIPs, egress.EgressGatewayRanges...)
-						}
-					}
-				}
-			} else {
-				peerNode.AllowedIPs = append(peerNode.AllowedIPs, peerNode.RelayAddrs...)
-			}
-			nodepeers, err := GetNodePeers(networkName, false)
-			if err == nil && peerNode.UDPHolePunch == "yes" {
-				for _, nodepeer := range nodepeers {
-					if nodepeer.Address == peerNode.Address {
-						// peerNode.Endpoint = nodepeer.Endpoint
-						peerNode.ListenPort = nodepeer.ListenPort
-					}
-				}
-			}
-
-			peers = append(peers, peerNode)
-		}
-	}
-	return peers, err
-}
-
 // RandomString - returns a random string in a charset
 func RandomString(length int) string {
 	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

serverctl/serverctl.go

@@ -22,6 +22,7 @@ const (
 	COMMS_NETID = "n37m8k3r"
 )
 
+// InitializeCommsNetwork - Check if comms network exists (for MQ, DNS, SSH traffic), if not, create
 func InitializeCommsNetwork() error {
 
 	_, err := logic.GetNetwork(COMMS_NETID)