Merge pull request #795 from gravitl/feature_v0.11.0_comms_2

logic for comms network + hub & spoke

config/config.go

@@ -77,6 +77,7 @@ type ServerConfig struct {
 	ManageIPTables        string `yaml:"manageiptables"`
 	PortForwardServices   string `yaml:"portforwardservices"`
 	HostNetwork           string `yaml:"hostnetwork"`
+	CommsCIDR             string `yaml:"commscidr"`
 }
 
 // SQLConfig - Generic SQL Config

controllers/node_grpc.go

@@ -174,10 +174,10 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
 }
 
 func getServerAddrs(node *models.Node) {
-	serverNodes := logic.GetServerNodes(node.Network)
+	serverNodes := logic.GetServerNodes(serverctl.COMMS_NETID)
 	//pubIP, _ := servercfg.GetPublicIP()
 	if len(serverNodes) == 0 {
-		if err := serverctl.SyncServerNetwork(node.Network); err != nil {
+		if err := serverctl.SyncServerNetwork(serverctl.COMMS_NETID); err != nil {
 			return
 		}
 	}
@@ -232,12 +232,7 @@ func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*
 		return nil, err
 	}
 
-	excludeIsRelayed := node.IsRelay != "yes"
-	var relayedNode string
-	if node.IsRelayed == "yes" {
-		relayedNode = node.Address
-	}
-	peers, err := logic.GetPeersList(node.Network, excludeIsRelayed, relayedNode)
+	peers, err := logic.GetPeersList(&node)
 	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/accesskeys.go

@@ -142,7 +142,7 @@ func DecrimentKey(networkName string, keyvalue string) {
 	var network models.Network
 
 	network, err := GetParentNetwork(networkName)
-	if err != nil {
+	if err != nil || network.IsComms == "yes" {
 		return
 	}
 
@@ -170,13 +170,21 @@ func DecrimentKey(networkName string, keyvalue string) {
 // IsKeyValid - check if key is valid
 func IsKeyValid(networkname string, keyvalue string) bool {
 
-	network, _ := GetParentNetwork(networkname)
+	network, err := GetParentNetwork(networkname)
+	if err != nil {
+		return false
+	}
+	accesskeys := network.AccessKeys
+	if network.IsComms == "yes" {
+		accesskeys = getAllAccessKeys()
+	}
+
 	var key models.AccessKey
 	foundkey := false
 	isvalid := false
 
-	for i := len(network.AccessKeys) - 1; i >= 0; i-- {
-		currentkey := network.AccessKeys[i]
+	for i := len(accesskeys) - 1; i >= 0; i-- {
+		currentkey := accesskeys[i]
 		if currentkey.Value == keyvalue {
 			key = currentkey
 			foundkey = true
@@ -230,3 +238,15 @@ func genKey() string {
 	}
 	return string(b)
 }
+
+func getAllAccessKeys() []models.AccessKey {
+	var accesskeys = make([]models.AccessKey, 0)
+	networks, err := GetNetworks()
+	if err != nil {
+		return accesskeys
+	}
+	for i := range networks {
+		accesskeys = append(accesskeys, networks[i].AccessKeys...)
+	}
+	return accesskeys
+}

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.INT_CLIENTS_TABLE_NAME, false) {
-				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
-			}
+		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"
-	var relayedNode string
-	if node.IsRelayed == "yes" {
-		relayedNode = node.Address
-	}
-	peers, err := GetPeersList(node.Network, excludeIsRelayed, relayedNode)
+	peers, err := GetPeersList(node)
 	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/server.go

@@ -39,7 +39,10 @@ func ServerJoin(networkSettings *models.Network) (models.Node, error) {
 	if currentServers != nil {
 		serverCount = len(currentServers) + 1
 	}
-
+	var ishub = "no"
+	if serverCount == 1 && (networkSettings.IsHubAndSpoke == "yes" || networkSettings.IsComms == "yes") {
+		ishub = "yes"
+	}
 	var node = &models.Node{
 		IsServer:     "yes",
 		DNSOn:        "no",
@@ -52,6 +55,7 @@ func ServerJoin(networkSettings *models.Network) (models.Node, error) {
 		LocalRange:   networkSettings.LocalRange,
 		OS:           runtime.GOOS,
 		Version:      servercfg.Version,
+		IsHub:        ishub,
 	}
 
 	SetNodeDefaults(node)

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"

main.go

@@ -81,6 +81,9 @@ func initialize() { // Client Mode Prereq Check
 		if err := serverctl.InitServerNetclient(); err != nil {
 			logger.FatalLog("Did not find netclient to use CLIENT_MODE")
 		}
+		if err := serverctl.InitializeCommsNetwork(); err != nil {
+			logger.FatalLog("could not inintialize comms network")
+		}
 	}
 	// initialize iptables to ensure gateways work correctly and mq is forwarded if containerized
 	if servercfg.ManageIPTables() != "off" {

models/network.go

@@ -27,6 +27,7 @@ type Network struct {
 	IsIPv4              string      `json:"isipv4" bson:"isipv4" validate:"checkyesorno"`
 	IsIPv6              string      `json:"isipv6" bson:"isipv6" validate:"checkyesorno"`
 	IsHubAndSpoke       string      `json:"ishubandspoke" bson:"ishubandspoke" validate:"checkyesorno"`
+	IsComms             string      `json:"iscomms" bson:"iscomms" validate:"checkyesorno"`
 	LocalRange          string      `json:"localrange" bson:"localrange" validate:"omitempty,cidr"`
 	DefaultUDPHolePunch string      `json:"defaultudpholepunch" bson:"defaultudpholepunch" validate:"checkyesorno"`
 	DefaultExtClientDNS string      `json:"defaultextclientdns" bson:"defaultextclientdns"`
@@ -65,6 +66,9 @@ func (network *Network) SetDefaults() {
 	if network.IsHubAndSpoke == "" {
 		network.IsHubAndSpoke = "no"
 	}
+	if network.IsComms == "" {
+		network.IsComms = "no"
+	}
 	if network.DefaultInterface == "" {
 		if len(network.NetID) < 13 {
 			network.DefaultInterface = "nm-" + network.NetID

servercfg/serverconf.go

@@ -3,6 +3,7 @@ package servercfg
 import (
 	"errors"
 	"io"
+	"net"
 	"net/http"
 	"os"
 	"strconv"
@@ -253,6 +254,21 @@ func GetGRPCPort() string {
 	return grpcport
 }
 
+// GetGRPCPort - gets the grpc port
+func GetCommsCIDR() string {
+	netrange := "172.242.0.0/16"
+	if os.Getenv("COMMS_CIDR") != "" {
+		netrange = os.Getenv("COMMS_CIDR")
+	} else if config.Config.Server.CommsCIDR != "" {
+		netrange = config.Config.Server.CommsCIDR
+	}
+	_, _, err := net.ParseCIDR(netrange)
+	if err == nil {
+		return netrange
+	}
+	return "172.242.0.0/16"
+}
+
 // GetMessageQueueEndpoint - gets the message queue endpoint
 func GetMessageQueueEndpoint() string {
 	host, _ := GetPublicIP()

serverctl/serverctl.go

@@ -9,10 +9,38 @@ import (
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
+	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/ncutils"
+	"github.com/gravitl/netmaker/servercfg"
 )
 
-const NETMAKER_BINARY_NAME = "netmaker"
+const (
+	// NETMAKER_BINARY_NAME - name of netmaker binary
+	NETMAKER_BINARY_NAME = "netmaker"
+
+	// COMMS_NETID - name of comms net
+	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)
+	if err != nil {
+		logger.Log(1, "comms net does not exist, creating")
+		var network models.Network
+		network.NetID = COMMS_NETID
+		network.AddressRange = servercfg.GetCommsCIDR()
+		network.IsHubAndSpoke = "yes"
+		network.DefaultUDPHolePunch = "yes"
+		network.IsComms = "yes"
+		return logic.CreateNetwork(network)
+	} else {
+		SyncServerNetwork(COMMS_NETID)
+	}
+	logger.Log(1, "comms network initialized")
+	return nil
+}
 
 // InitServerNetclient - intializes the server netclient
 // 1. Check if config directory exists, if not attempt to make