initial build successful

Signed-off-by: Matthew R. Kasun <[email protected]>

config/config.go

@@ -71,9 +71,8 @@ type ServerConfig struct {
 	ManageIPTables        string `yaml:"manageiptables"`
 	PortForwardServices   string `yaml:"portforwardservices"`
 	HostNetwork           string `yaml:"hostnetwork"`
-	CommsCIDR             string `yaml:"commscidr"`
 	MQPort                string `yaml:"mqport"`
-	CommsID               string `yaml:"commsid"`
+	MQEndPoint            string `yaml:"mqendpoint"`
 }
 
 // SQLConfig - Generic SQL Config

controllers/network.go

@@ -3,7 +3,6 @@ package controller
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 	"strings"
 
@@ -15,7 +14,6 @@ import (
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/mq"
 	"github.com/gravitl/netmaker/servercfg"
-	"github.com/gravitl/netmaker/serverctl"
 )
 
 // ALL_NETWORK_ACCESS - represents all networks
@@ -84,9 +82,6 @@ func getNetwork(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
 	netname := params["networkname"]
-	if isCommsEdit(w, r, netname) {
-		return
-	}
 
 	network, err := logic.GetNetwork(netname)
 	if err != nil {
@@ -105,9 +100,6 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	var params = mux.Vars(r)
 	netname := params["networkname"]
-	if isCommsEdit(w, r, netname) {
-		return
-	}
 
 	network, err := logic.KeyUpdate(netname)
 	if err != nil {
@@ -295,9 +287,6 @@ func deleteNetwork(w http.ResponseWriter, r *http.Request) {
 
 	var params = mux.Vars(r)
 	network := params["networkname"]
-	if isCommsEdit(w, r, network) {
-		return
-	}
 
 	err := logic.DeleteNetwork(network)
 	if err != nil {
@@ -358,9 +347,6 @@ func createAccessKey(w http.ResponseWriter, r *http.Request) {
 	var accesskey models.AccessKey
 	//start here
 	netname := params["networkname"]
-	if isCommsEdit(w, r, netname) {
-		return
-	}
 	network, err := logic.GetParentNetwork(netname)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -413,21 +399,3 @@ func deleteAccessKey(w http.ResponseWriter, r *http.Request) {
 	logger.Log(1, r.Header.Get("user"), "deleted access key", keyname, "on network,", netname)
 	w.WriteHeader(http.StatusOK)
 }
-
-func isCommsEdit(w http.ResponseWriter, r *http.Request, netname string) bool {
-	if netname == serverctl.COMMS_NETID {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("cannot access comms network"), "internal"))
-		return true
-	}
-	return false
-}
-
-func filterCommsNetwork(networks []models.Network) []models.Network {
-	var filterdNets []models.Network
-	for i := range networks {
-		if networks[i].IsComms != "yes" && networks[i].NetID != servercfg.GetCommsID() {
-			filterdNets = append(filterdNets, networks[i])
-		}
-	}
-	return filterdNets
-}

controllers/network_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/serverctl"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -301,5 +300,4 @@ func createNet() {
 	if err != nil {
 		logic.CreateNetwork(network)
 	}
-	serverctl.InitializeCommsNetwork()
 }

controllers/node.go

@@ -329,10 +329,6 @@ func getNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if logic.IsNodeInComms(&node) {
-		returnErrorResponse(w, r, formatError(err, "internal"))
-		return
-	}
 	logger.Log(2, r.Header.Get("user"), "fetched node", params["nodeid"])
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(node)
@@ -659,13 +655,3 @@ func runServerUpdate(node *models.Node, ifaceDelta bool) error {
 	}
 	return nil
 }
-
-func filterCommsNodes(nodes []models.Node) []models.Node {
-	var filterdNodes []models.Node
-	for i := range nodes {
-		if !logic.IsNodeInComms(&nodes[i]) {
-			filterdNodes = append(filterdNodes, nodes[i])
-		}
-	}
-	return filterdNodes
-}

controllers/user.go

@@ -12,7 +12,6 @@ import (
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/servercfg"
 )
 
 func userHandlers(r *mux.Router) {
@@ -167,11 +166,6 @@ func createUser(w http.ResponseWriter, r *http.Request) {
 	// get node from body of request
 	_ = json.NewDecoder(r.Body).Decode(&user)
 
-	if !user.IsAdmin && isAddingComms(user.Networks) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not add comms network to non admin"), "badrequest"))
-		return
-	}
-
 	user, err := logic.CreateUser(user)
 
 	if err != nil {
@@ -200,11 +194,6 @@ func updateUserNetworks(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	if !userchange.IsAdmin && isAddingComms(userchange.Networks) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not add comms network to non admin"), "badrequest"))
-		return
-	}
-
 	err = logic.UpdateUserNetworks(userchange.Networks, userchange.IsAdmin, &user)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
@@ -229,10 +218,6 @@ func updateUser(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(fmt.Errorf("can not update user info for oauth user %s", username), "forbidden"))
 		return
 	}
-	if !user.IsAdmin && isAddingComms(user.Networks) {
-		returnErrorResponse(w, r, formatError(fmt.Errorf("can not add comms network to non admin"), "badrequest"))
-		return
-	}
 	var userchange models.User
 	// we decode our body request params
 	err = json.NewDecoder(r.Body).Decode(&userchange)
@@ -302,13 +287,3 @@ func deleteUser(w http.ResponseWriter, r *http.Request) {
 	logger.Log(1, username, "was deleted")
 	json.NewEncoder(w).Encode(params["username"] + " deleted.")
 }
-
-func isAddingComms(networks []string) bool {
-	commsID := servercfg.GetCommsID()
-	for i := range networks {
-		if networks[i] == commsID {
-			return true
-		}
-	}
-	return false
-}

go.mod

@@ -34,6 +34,7 @@ require (
 require (
 	github.com/go-ping/ping v0.0.0-20211130115550-779d1e919534
 	github.com/guumaster/hostctl v1.1.2
+	github.com/kr/pretty v0.3.0
 	github.com/posthog/posthog-go v0.0.0-20211028072449-93c17c49e2b0
 )
 
@@ -58,6 +59,7 @@ require (
 	github.com/google/go-cmp v0.5.7 // indirect
 	github.com/gorilla/websocket v1.4.2 // indirect
 	github.com/josharian/native v1.0.0 // indirect
+	github.com/kr/text v0.2.0 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
 	github.com/mdlayher/genetlink v1.2.0 // indirect
 	github.com/mdlayher/netlink v1.6.0 // indirect
@@ -66,6 +68,7 @@ require (
 	github.com/opencontainers/image-spec v1.0.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.8.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/spf13/afero v1.3.2 // indirect
 	github.com/xtgo/uuid v0.0.0-20140804021211-a0b114877d4c // indirect

logic/accesskeys.go

@@ -51,17 +51,12 @@ func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models
 
 	netID := network.NetID
 
-	commsNetID, err := FetchCommsNetID()
-	if err != nil {
-		return models.AccessKey{}, errors.New("could not retrieve comms netid")
-	}
-
 	var accessToken models.AccessToken
 	s := servercfg.GetServerConfig()
 	servervals := models.ServerConfig{
 		GRPCConnString: s.GRPCConnString,
 		GRPCSSL:        s.GRPCSSL,
-		CommsNetwork:   commsNetID,
+		MQEndpoint:     s.MQEndPoint,
 	}
 	accessToken.ServerConfig = servervals
 	accessToken.ClientConfig.Network = netID

logic/nodes.go

@@ -630,11 +630,6 @@ func IsLocalServer(node *models.Node) bool {
 	return node.ID != "" && local.ID == node.ID
 }
 
-// IsNodeInComms returns if node is in comms network or not
-func IsNodeInComms(node *models.Node) bool {
-	return node.Network == servercfg.GetCommsID() && node.IsServer != "yes"
-}
-
 // validateServer - make sure servers dont change port or address
 func validateServer(currentNode, newNode *models.Node) bool {
 	return (newNode.Address == currentNode.Address &&

main.go

@@ -103,9 +103,6 @@ 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" {
@@ -216,7 +213,7 @@ func runGRPC(wg *sync.WaitGroup) {
 // Should we be using a context vice a waitgroup????????????
 func runMessageQueue(wg *sync.WaitGroup) {
 	defer wg.Done()
-	logger.Log(0, "connecting to mq broker at", servercfg.GetMessageQueueEndpoint())
+	logger.Log(0, "connecting to mq broker at", servercfg.GetMessageQueueEndpoint(false))
 	var client = mq.SetupMQTT(false) // Set up the subscription listener
 	ctx, cancel := context.WithCancel(context.Background())
 	go mq.Keepalive(ctx)

models/accessToken.go

@@ -14,5 +14,5 @@ type ClientConfig struct {
 type ServerConfig struct {
 	GRPCConnString string `json:"grpcconn"`
 	GRPCSSL        string `json:"grpcssl"`
-	CommsNetwork   string `json:"commsnetwork"`
+	MQEndpoint     string `json:"mqendpoint"`
 }

models/node.go

@@ -81,6 +81,7 @@ type Node struct {
 	Version      string      `json:"version" bson:"version" yaml:"version"`
 	CommID       string      `json:"commid" bson:"commid" yaml:"comid"`
 	TrafficKeys  TrafficKeys `json:"traffickeys" bson:"traffickeys" yaml:"traffickeys"`
+	MQEndPoint   string      `json:"mqendpont" yaml:"mqendpoint"`
 }
 
 // NodesArray - used for node sorting

mq/mq.go

@@ -21,7 +21,7 @@ var peer_force_send = 0
 // SetupMQTT creates a connection to broker and return client
 func SetupMQTT(publish bool) mqtt.Client {
 	opts := mqtt.NewClientOptions()
-	opts.AddBroker(servercfg.GetMessageQueueEndpoint())
+	opts.AddBroker(servercfg.GetMessageQueueEndpoint(false))
 	id := ncutils.MakeRandomString(23)
 	opts.ClientID = id
 	opts.SetAutoReconnect(true)
@@ -49,11 +49,11 @@ func SetupMQTT(publish bool) mqtt.Client {
 				client.Disconnect(240)
 				logger.Log(0, "node client subscription failed")
 			}
-
-			opts.SetOrderMatters(true)
-			opts.SetResumeSubs(true)
+			logger.Log(3, "message queue subscriptions succeeded")
 		}
 	})
+	opts.SetOrderMatters(true)
+	opts.SetResumeSubs(true)
 	client := mqtt.NewClient(opts)
 	tperiod := time.Now().Add(10 * time.Second)
 	for {
@@ -67,6 +67,7 @@ func SetupMQTT(publish bool) mqtt.Client {
 		}
 		time.Sleep(2 * time.Second)
 	}
+	logger.Log(2, "connected to broker")
 	return client
 }
 

mq/publishers.go

@@ -39,9 +39,7 @@ func PublishPeerUpdate(newNode *models.Node) error {
 		if err = publish(&node, fmt.Sprintf("peers/%s/%s", node.Network, node.ID), data); err != nil {
 			logger.Log(1, "failed to publish peer update for node", node.ID)
 		} else {
-			if node.Network != servercfg.GetCommsID() {
-				logger.Log(1, "sent peer update for node", node.Name, "on network:", node.Network)
-			}
+			logger.Log(1, "sent peer update for node", node.Name, "on network:", node.Network)
 		}
 	}
 	return nil

netclient/command/commands.go

@@ -10,45 +10,11 @@ import (
 	"github.com/gravitl/netmaker/netclient/ncutils"
 )
 
-// JoinComms -- Join the message queue comms network if it doesn't have it
-// tries to ping if already found locally, if fail ping pull for best effort for communication
-func JoinComms(cfg *config.ClientConfig) error {
-	commsCfg := &config.ClientConfig{}
-	commsCfg.Network = cfg.Server.CommsNetwork
-	commsCfg.Node.Network = cfg.Server.CommsNetwork
-	commsCfg.Server.AccessKey = cfg.Server.AccessKey
-	commsCfg.Server.GRPCAddress = cfg.Server.GRPCAddress
-	commsCfg.Server.GRPCSSL = cfg.Server.GRPCSSL
-	commsCfg.Server.CoreDNSAddr = cfg.Server.CoreDNSAddr
-	if commsCfg.ConfigFileExists() {
-		return nil
-	}
-	commsCfg.ReadConfig()
-
-	if len(commsCfg.Node.Name) == 0 {
-		if err := functions.JoinNetwork(commsCfg, "", true); err != nil {
-			return err
-		}
-	} else { // check if comms is currently reachable
-		if err := functions.PingServer(commsCfg); err != nil {
-			if err = Pull(commsCfg); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
 // Join - join command to run from cli
 func Join(cfg *config.ClientConfig, privateKey string) error {
 	var err error
-	//check if comms network exists
-	if err = JoinComms(cfg); err != nil {
-		return err
-	}
-
 	//join network
-	err = functions.JoinNetwork(cfg, privateKey, false)
+	err = functions.JoinNetwork(cfg, privateKey)
 	if err != nil && !cfg.DebugOn {
 		if !strings.Contains(err.Error(), "ALREADY_INSTALLED") {
 			logger.Log(1, "error installing: ", err.Error())

netclient/config/config.go

@@ -29,11 +29,11 @@ type ClientConfig struct {
 
 // ServerConfig - struct for dealing with the server information for a netclient
 type ServerConfig struct {
-	CoreDNSAddr  string `yaml:"corednsaddr"`
-	GRPCAddress  string `yaml:"grpcaddress"`
-	AccessKey    string `yaml:"accesskey"`
-	GRPCSSL      string `yaml:"grpcssl"`
-	CommsNetwork string `yaml:"commsnetwork"`
+	CoreDNSAddr string `yaml:"corednsaddr"`
+	GRPCAddress string `yaml:"grpcaddress"`
+	AccessKey   string `yaml:"accesskey"`
+	GRPCSSL     string `yaml:"grpcssl"`
+	MQEndPoint  string `yaml:"MQEndpoint"`
 }
 
 // Write - writes the config of a client to disk
@@ -188,7 +188,7 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, string, error) {
 		cfg.Server.AccessKey = accesstoken.ClientConfig.Key
 		cfg.Node.LocalRange = accesstoken.ClientConfig.LocalRange
 		cfg.Server.GRPCSSL = accesstoken.ServerConfig.GRPCSSL
-		cfg.Server.CommsNetwork = accesstoken.ServerConfig.CommsNetwork
+		cfg.Server.MQEndPoint = accesstoken.ServerConfig.MQEndpoint
 		if c.String("grpcserver") != "" {
 			cfg.Server.GRPCAddress = c.String("grpcserver")
 		}

netclient/functions/common.go

@@ -155,9 +155,6 @@ func LeaveNetwork(network string, force bool) error {
 	}
 	servercfg := cfg.Server
 	node := cfg.Node
-	if node.NetworkSettings.IsComms == "yes" && !force {
-		return errors.New("COMMS_NET - You are trying to leave the comms network. This will break network updates. Unless you re-join. If you really want to leave, run with --force=yes.")
-	}
 
 	if node.IsServer != "yes" {
 		var wcclient nodepb.NodeServiceClient

netclient/functions/daemon.go

@@ -2,8 +2,12 @@ package functions
 
 import (
 	"context"
+	"crypto/tls"
+	"crypto/x509"
 	"errors"
 	"fmt"
+	"io/ioutil"
+	"log"
 	"os"
 	"os/signal"
 	"strings"
@@ -36,46 +40,42 @@ type cachedMessage struct {
 
 // Daemon runs netclient daemon from command line
 func Daemon() error {
-	// == initial pull of all networks ==
-	networks, _ := ncutils.GetSystemNetworks()
-	for _, network := range networks {
-		//temporary code --- remove in version v0.13.0
-		removeHostDNS(network, ncutils.IsWindows())
-		// end of code to be removed in version v0.13.0
-		var cfg config.ClientConfig
-		cfg.Network = network
-		cfg.ReadConfig()
-		initialPull(cfg.Network)
-	}
-
-	// == get all the comms networks on machine ==
-	commsNetworks, err := getCommsNetworks(networks[:])
-	if err != nil {
-		return errors.New("no comm networks exist")
-	}
-
-	// == subscribe to all nodes on each comms network on machine ==
-	for currCommsNet := range commsNetworks {
-		logger.Log(1, "started comms network daemon, ", currCommsNet)
-		ctx, cancel := context.WithCancel(context.Background())
-		networkcontext.Store(currCommsNet, cancel)
-		go messageQueue(ctx, currCommsNet)
-	}
-
+	logger.Log(0, "starting daemon")
+	// == start mq for each server ==
 	// == add waitgroup and cancel for checkin routine ==
+	//ctx, cancel := context.WithCancel(context.Background())
 	wg := sync.WaitGroup{}
-	ctx, cancel := context.WithCancel(context.Background())
-	wg.Add(1)
-	go Checkin(ctx, &wg, commsNetworks)
+	//networks, _ := ncutils.GetSystemNetworks()
+	//	for _, network := range networks {
+	//		//temporary code --- remove in version v0.13.0
+	//		removeHostDNS(network, ncutils.IsWindows())
+	//		// end of code to be removed in version v0.13.0
+	//		var cfg config.ClientConfig
+	//		cfg.Network = network
+	//		cfg.ReadConfig()
+	//		// == initial pull of all networks ==
+	//		initialPull(cfg.Network)
+	//		logger.Log(1, "started mq for server  ", cfg.NetworkSettings.NetID)
+	//		wg.Add(1)
+	//		go messageQueue(ctx, wg, &cfg)
+	//	}
+	//wg.Add(1)
+	//go Checkin(ctx, &wg)
+	var cfg config.ClientConfig
+	cfg.Network = "netmaker"
+	cfg.ReadConfig()
+	//Hello(&cfg)
+	client := SetupMQTT(&cfg, false)
+	defer client.Disconnect(500)
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGTERM, os.Interrupt, os.Kill)
 	<-quit
-	for currCommsNet := range commsNetworks {
-		if cancel, ok := networkcontext.Load(currCommsNet); ok {
-			cancel.(context.CancelFunc)()
-		}
-	}
-	cancel()
+	//for currCommsNet := range commsNetworks {
+	//	if cancel, ok := networkcontext.Load(currCommsNet); ok {
+	//		cancel.(context.CancelFunc)()
+	//	}
+	//}
+	//cancel()
 	logger.Log(0, "shutting down netclient daemon")
 	wg.Wait()
 	logger.Log(0, "shutdown complete")
@@ -101,15 +101,13 @@ func UpdateKeys(nodeCfg *config.ClientConfig, client mqtt.Client) error {
 	}
 
 	nodeCfg.Node.PublicKey = key.PublicKey().String()
-	var commsCfg = getCommsCfgByNode(&nodeCfg.Node)
-	PublishNodeUpdate(&commsCfg, nodeCfg)
+	PublishNodeUpdate(nodeCfg)
 	return nil
 }
 
 // PingServer -- checks if server is reachable
-// use commsCfg only*
-func PingServer(commsCfg *config.ClientConfig) error {
-	node := getServerAddress(commsCfg)
+func PingServer(nodeCfg *config.ClientConfig) error {
+	node := getServerAddress(nodeCfg)
 	pinger, err := ping.NewPinger(node)
 	if err != nil {
 		return err
@@ -124,6 +122,13 @@ func PingServer(commsCfg *config.ClientConfig) error {
 }
 
 // == Private ==
+func setTempSubs(client mqtt.Client) {
+	if token := client.Subscribe("#", 0, nil); token.Wait() && token.Error() != nil {
+		logger.Log(0, token.Error().Error())
+		return
+	}
+	logger.Log(0, "subscribed to all topics for debugging purposes")
+}
 
 // sets MQ client subscriptions for a specific node config
 // should be called for each node belonging to a given comms network
@@ -140,16 +145,12 @@ func setSubscriptions(client mqtt.Client, nodeCfg *config.ClientConfig) {
 		logger.Log(0, token.Error().Error())
 		return
 	}
-	if nodeCfg.DebugOn {
-		logger.Log(0, fmt.Sprintf("subscribed to node updates for node %s update/%s/%s", nodeCfg.Node.Name, nodeCfg.Node.Network, nodeCfg.Node.ID))
-	}
+	logger.Log(2, fmt.Sprintf("subscribed to node updates for node %s update/%s/%s", nodeCfg.Node.Name, nodeCfg.Node.Network, nodeCfg.Node.ID))
 	if token := client.Subscribe(fmt.Sprintf("peers/%s/%s", nodeCfg.Node.Network, nodeCfg.Node.ID), 0, mqtt.MessageHandler(UpdatePeers)); token.Wait() && token.Error() != nil {
 		logger.Log(0, token.Error().Error())
 		return
 	}
-	if nodeCfg.DebugOn {
-		logger.Log(0, fmt.Sprintf("subscribed to peer updates for node %s peers/%s/%s", nodeCfg.Node.Name, nodeCfg.Node.Network, nodeCfg.Node.ID))
-	}
+	logger.Log(2, fmt.Sprintf("subscribed to peer updates for node %s peers/%s/%s", nodeCfg.Node.Name, nodeCfg.Node.Network, nodeCfg.Node.ID))
 }
 
 // on a delete usually, pass in the nodecfg to unsubscribe client broker communications
@@ -171,25 +172,27 @@ func unsubscribeNode(client mqtt.Client, nodeCfg *config.ClientConfig) {
 }
 
 // sets up Message Queue and subsribes/publishes updates to/from server
-// the client should subscribe to ALL nodes that exist on unique comms network locally
-func messageQueue(ctx context.Context, commsNet string) {
-	var commsCfg config.ClientConfig
-	commsCfg.Network = commsNet
-	commsCfg.ReadConfig()
-	logger.Log(0, "netclient daemon started for network: ", commsNet)
-	client := setupMQTT(&commsCfg, false)
+// the client should subscribe to ALL nodes that exist on server
+func messageQueue(ctx context.Context, wg sync.WaitGroup, cfg *config.ClientConfig) {
+	//var commsCfg config.ClientConfig
+	//commsCfg.Network = commsNet
+	//commsCfg.ReadConfig()
+	logger.Log(0, "netclient daemon started for server: ", cfg.Server.MQEndPoint)
+	client := SetupMQTT(cfg, false)
 	defer client.Disconnect(250)
 	<-ctx.Done()
-	logger.Log(0, "shutting down daemon for comms network ", commsNet)
+	logger.Log(0, "shutting down daemon for server ", cfg.Server.MQEndPoint)
+	wg.Done()
 }
 
-// setupMQTT creates a connection to broker and return client
+// SetupMQTT creates a connection to broker and return client
 // utilizes comms client configs to setup connections
-func setupMQTT(commsCfg *config.ClientConfig, publish bool) mqtt.Client {
+func SetupMQTT(cfg *config.ClientConfig, publish bool) mqtt.Client {
 	opts := mqtt.NewClientOptions()
-	server := getServerAddress(commsCfg)
-	opts.AddBroker(server + ":1883")             // TODO get the appropriate port of the comms mq server
-	opts.ClientID = ncutils.MakeRandomString(23) // helps avoid id duplication on broker
+	//server := getServerAddress(commsCfg)
+	opts.AddBroker(cfg.Server.MQEndPoint) // TODO get the appropriate port of the comms mq server
+	//opts.ClientID = ncutils.MakeRandomString(23) // helps avoid id duplication on broker
+	logger.Log(0, "added broker ", cfg.Server.MQEndPoint)
 	opts.SetDefaultPublishHandler(All)
 	opts.SetAutoReconnect(true)
 	opts.SetConnectRetry(true)
@@ -197,51 +200,61 @@ func setupMQTT(commsCfg *config.ClientConfig, publish bool) mqtt.Client {
 	opts.SetKeepAlive(time.Minute >> 1)
 	opts.SetWriteTimeout(time.Minute)
 	opts.SetOnConnectHandler(func(client mqtt.Client) {
+		logger.Log(0, "Connection Handler")
 		if !publish {
-			networks, err := ncutils.GetSystemNetworks()
-			if err != nil {
-				logger.Log(0, "error retriving networks ", err.Error())
-			}
-			for _, network := range networks {
-				var currNodeCfg config.ClientConfig
-				currNodeCfg.Network = network
-				currNodeCfg.ReadConfig()
-				setSubscriptions(client, &currNodeCfg)
-			}
+			//networks, err := ncutils.GetSystemNetworks()
+			//if err != nil {
+			//	logger.Log(0, "error retriving networks ", err.Error())
+			//}
+			//for _, network := range networks {
+			//	var currNodeCfg config.ClientConfig
+			//	currNodeCfg.Network = network
+			//	currNodeCfg.ReadConfig()
+			//	setSubscriptions(client, &currNodeCfg)
+			//}
+			setTempSubs(client)
 		}
 	})
 	opts.SetOrderMatters(true)
 	opts.SetResumeSubs(true)
 	opts.SetConnectionLostHandler(func(c mqtt.Client, e error) {
-		logger.Log(0, "detected broker connection lost, running pull for ", commsCfg.Node.Network)
-		_, err := Pull(commsCfg.Node.Network, true)
+		logger.Log(0, "detected broker connection lost, running pull for ", cfg.Node.Network)
+		_, err := Pull(cfg.Node.Network, true)
 		if err != nil {
 			logger.Log(0, "could not run pull, server unreachable: ", err.Error())
 			logger.Log(0, "waiting to retry...")
 		}
 		logger.Log(0, "connection re-established with mqtt server")
 	})
-
+	opts.SetTLSConfig(NewTLSConfig(cfg))
+	logger.Log(0, "Calling NewClient")
 	client := mqtt.NewClient(opts)
 	tperiod := time.Now().Add(12 * time.Second)
 	for {
 		//if after 12 seconds, try a gRPC pull on the last try
 		if time.Now().After(tperiod) {
-			logger.Log(0, "running pull for ", commsCfg.Node.Network)
-			_, err := Pull(commsCfg.Node.Network, true)
+			logger.Log(0, "running pull for ", cfg.Node.Network)
+			_, err := Pull(cfg.Node.Network, true)
 			if err != nil {
-				logger.Log(0, "could not run pull, exiting ", commsCfg.Node.Network, " setup: ", err.Error())
+				logger.Log(0, "could not run pull, exiting ", cfg.Node.Network, " setup: ", err.Error())
 				return client
 			}
 			time.Sleep(time.Second)
 		}
-		if token := client.Connect(); token.Wait() && token.Error() != nil {
+		if token := client.Connect(); !token.WaitTimeout(time.Second*2) && token.Error() != nil {
+			//token := client.Connect()
+			//if done := token.WaitTimeout(time.Second * 2); !done {
+			//	logger.Log(0, "mq client connect timeout")
+			//}
+			//err := token.Error()
+			//if err != nil {
+			logger.Log(0, token.Error().Error())
 			logger.Log(0, "unable to connect to broker, retrying ...")
 			if time.Now().After(tperiod) {
-				logger.Log(0, "could not connect to broker, exiting ", commsCfg.Node.Network, " setup: ", token.Error().Error())
+				logger.Log(0, "could not connect to broker, exiting ", cfg.Node.Network, " setup: ", token.Error().Error())
 				if strings.Contains(token.Error().Error(), "connectex") || strings.Contains(token.Error().Error(), "i/o timeout") {
 					logger.Log(0, "connection issue detected.. pulling and restarting daemon")
-					Pull(commsCfg.Node.Network, true)
+					Pull(cfg.Node.Network, true)
 					daemon.Restart()
 				}
 				return client
@@ -251,12 +264,35 @@ func setupMQTT(commsCfg *config.ClientConfig, publish bool) mqtt.Client {
 		}
 		time.Sleep(2 * time.Second)
 	}
+	logger.Log(0, "MQ setup "+cfg.NetworkSettings.NetID)
 	return client
 }
 
+// NewTLSConf sets up tls to connect to broker
+func NewTLSConfig(cfg *config.ClientConfig) *tls.Config {
+	certpool := x509.NewCertPool()
+	ca, err := ioutil.ReadFile("/etc/netclient/" + cfg.NetworkSettings.NetID + "-ca.pem")
+	if err != nil {
+		log.Fatalf("could not read CA file %v\n", err)
+	}
+	certpool.AppendCertsFromPEM(ca)
+	clientKeyPair, err := tls.LoadX509KeyPair("/etc/netclient/"+cfg.NetworkSettings.NetID+"-client.pem", "/etc/netclient/client.key")
+	if err != nil {
+		log.Fatalf("could not read client cert/key %v \n", err)
+	}
+	return &tls.Config{
+		RootCAs: certpool,
+		//ClientAuth:         tls.NoClientCert,
+		ClientAuth:         tls.VerifyClientCertIfGiven,
+		ClientCAs:          nil,
+		InsecureSkipVerify: true,
+		Certificates:       []tls.Certificate{clientKeyPair},
+	}
+}
+
 // publishes a message to server to update peers on this peer's behalf
-func publishSignal(commsCfg, nodeCfg *config.ClientConfig, signal byte) error {
-	if err := publish(commsCfg, nodeCfg, fmt.Sprintf("signal/%s", nodeCfg.Node.ID), []byte{signal}, 1); err != nil {
+func publishSignal(nodeCfg *config.ClientConfig, signal byte) error {
+	if err := publish(nodeCfg, fmt.Sprintf("signal/%s", nodeCfg.Node.ID), []byte{signal}, 1); err != nil {
 		return err
 	}
 	return nil
@@ -324,6 +360,17 @@ func getServerAddress(cfg *config.ClientConfig) string {
 	return server.Address
 }
 
+func getServers(networks []string) (map[string]bool, error) {
+	var cfg config.ClientConfig
+	var response = make(map[string]bool, 1)
+	for _, network := range networks {
+		cfg.Network = network
+		cfg.ReadConfig()
+		response[cfg.Node.MQEndPoint] = true
+	}
+	return response, nil
+}
+
 func getCommsNetworks(networks []string) (map[string]bool, error) {
 	var cfg config.ClientConfig
 	var response = make(map[string]bool, 1)

netclient/functions/join.go

@@ -26,7 +26,7 @@ import (
 )
 
 // JoinNetwork - helps a client join a network
-func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) error {
+func JoinNetwork(cfg *config.ClientConfig, privateKey string) error {
 	if cfg.Node.Network == "" {
 		return errors.New("no network provided")
 	}
@@ -102,7 +102,7 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) erro
 	// Find and set node MacAddress
 	if cfg.Node.MacAddress == "" {
 		macs, err := ncutils.GetMacAddr()
-		if err != nil || iscomms {
+		if err != nil {
 			//if macaddress can't be found set to random string
 			cfg.Node.MacAddress = ncutils.MakeRandomString(18)
 		} else {
@@ -251,15 +251,13 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string, iscomms bool) erro
 	//		}
 	//	}
 
-	if !iscomms {
-		if cfg.Daemon != "off" {
-			err = daemon.InstallDaemon(cfg)
-		}
-		if err != nil {
-			return err
-		} else {
-			daemon.Restart()
-		}
+	if cfg.Daemon != "off" {
+		err = daemon.InstallDaemon(cfg)
+	}
+	if err != nil {
+		return err
+	} else {
+		daemon.Restart()
 	}
 
 	return nil
@@ -297,8 +295,7 @@ func setListenPort(oldListenPort int32, cfg *config.ClientConfig) {
 
 		// if newListenPort has been modified to find an available port, publish to server
 		if cfg.Node.ListenPort != newListenPort {
-			var currentCommsCfg = getCommsCfgByNode(&cfg.Node)
-			PublishNodeUpdate(&currentCommsCfg, cfg)
+			PublishNodeUpdate(cfg)
 		}
 	}
 }

netclient/functions/mqhandlers.go

@@ -33,7 +33,6 @@ func NodeUpdate(client mqtt.Client, msg mqtt.Message) {
 	var network = parseNetworkFromTopic(msg.Topic())
 	nodeCfg.Network = network
 	nodeCfg.ReadConfig()
-	var commsCfg = getCommsCfgByNode(&nodeCfg.Node)
 
 	data, dataErr := decryptMsg(&nodeCfg, msg.Payload())
 	if dataErr != nil {
@@ -131,14 +130,14 @@ func NodeUpdate(client mqtt.Client, msg mqtt.Message) {
 		//			}
 		//		}
 		//	}
-		doneErr := publishSignal(&commsCfg, &nodeCfg, ncutils.DONE)
+		doneErr := publishSignal(&nodeCfg, ncutils.DONE)
 		if doneErr != nil {
 			logger.Log(0, "could not notify server to update peers after interface change")
 		} else {
 			logger.Log(0, "signalled finished interface update to server")
 		}
 	} else if hubChange {
-		doneErr := publishSignal(&commsCfg, &nodeCfg, ncutils.DONE)
+		doneErr := publishSignal(&nodeCfg, ncutils.DONE)
 		if doneErr != nil {
 			logger.Log(0, "could not notify server to update peers after hub change")
 		} else {

netclient/functions/mqpublish.go

@@ -15,7 +15,7 @@ import (
 
 // Checkin  -- go routine that checks for public or local ip changes, publishes changes
 //   if there are no updates, simply "pings" the server as a checkin
-func Checkin(ctx context.Context, wg *sync.WaitGroup, currentComms map[string]bool) {
+func Checkin(ctx context.Context, wg *sync.WaitGroup) {
 	defer wg.Done()
 	for {
 		select {
@@ -30,66 +30,62 @@ func Checkin(ctx context.Context, wg *sync.WaitGroup, currentComms map[string]bo
 			if err != nil {
 				return
 			}
-			for commsNet := range currentComms {
-				var currCommsCfg config.ClientConfig
-				currCommsCfg.Network = commsNet
-				currCommsCfg.ReadConfig()
-				for _, network := range networks {
-					var nodeCfg config.ClientConfig
-					nodeCfg.Network = network
-					nodeCfg.ReadConfig()
-					if nodeCfg.Node.CommID != commsNet {
-						continue // skip if not on current comms network
+			//for server := range servers {
+			//var currCommsCfg config.ClientConfig
+			//currCommsCfg.Network = commsNet
+			//currCommsCfg.ReadConfig()
+			for _, network := range networks {
+				var nodeCfg config.ClientConfig
+				nodeCfg.Network = network
+				nodeCfg.ReadConfig()
+				if nodeCfg.Node.IsStatic != "yes" {
+					extIP, err := ncutils.GetPublicIP()
+					if err != nil {
+						logger.Log(1, "error encountered checking public ip addresses: ", err.Error())
 					}
-					if nodeCfg.Node.IsStatic != "yes" {
-						extIP, err := ncutils.GetPublicIP()
-						if err != nil {
-							logger.Log(1, "error encountered checking public ip addresses: ", err.Error())
+					if nodeCfg.Node.Endpoint != extIP && extIP != "" {
+						logger.Log(1, "endpoint has changed from ", nodeCfg.Node.Endpoint, " to ", extIP)
+						nodeCfg.Node.Endpoint = extIP
+						if err := PublishNodeUpdate(&nodeCfg); err != nil {
+							logger.Log(0, "could not publish endpoint change")
 						}
-						if nodeCfg.Node.Endpoint != extIP && extIP != "" {
-							logger.Log(1, "endpoint has changed from ", nodeCfg.Node.Endpoint, " to ", extIP)
-							nodeCfg.Node.Endpoint = extIP
-							if err := PublishNodeUpdate(&currCommsCfg, &nodeCfg); err != nil {
-								logger.Log(0, "could not publish endpoint change")
-							}
-						}
-						intIP, err := getPrivateAddr()
-						if err != nil {
-							logger.Log(1, "error encountered checking private ip addresses: ", err.Error())
-						}
-						if nodeCfg.Node.LocalAddress != intIP && intIP != "" {
-							logger.Log(1, "local Address has changed from ", nodeCfg.Node.LocalAddress, " to ", intIP)
-							nodeCfg.Node.LocalAddress = intIP
-							if err := PublishNodeUpdate(&currCommsCfg, &nodeCfg); err != nil {
-								logger.Log(0, "could not publish local address change")
-							}
-						}
-					} else if nodeCfg.Node.IsLocal == "yes" && nodeCfg.Node.LocalRange != "" {
-						localIP, err := ncutils.GetLocalIP(nodeCfg.Node.LocalRange)
-						if err != nil {
-							logger.Log(1, "error encountered checking local ip addresses: ", err.Error())
-						}
-						if nodeCfg.Node.Endpoint != localIP && localIP != "" {
-							logger.Log(1, "endpoint has changed from "+nodeCfg.Node.Endpoint+" to ", localIP)
-							nodeCfg.Node.Endpoint = localIP
-							if err := PublishNodeUpdate(&currCommsCfg, &nodeCfg); err != nil {
-								logger.Log(0, "could not publish localip change")
-							}
+					}
+					intIP, err := getPrivateAddr()
+					if err != nil {
+						logger.Log(1, "error encountered checking private ip addresses: ", err.Error())
+					}
+					if nodeCfg.Node.LocalAddress != intIP && intIP != "" {
+						logger.Log(1, "local Address has changed from ", nodeCfg.Node.LocalAddress, " to ", intIP)
+						nodeCfg.Node.LocalAddress = intIP
+						if err := PublishNodeUpdate(&nodeCfg); err != nil {
+							logger.Log(0, "could not publish local address change")
 						}
 					}
-					if err := PingServer(&currCommsCfg); err != nil {
-						logger.Log(0, "could not ping server on comms net, ", currCommsCfg.Network, "\n", err.Error())
-					} else {
-						Hello(&currCommsCfg, &nodeCfg)
+				} else if nodeCfg.Node.IsLocal == "yes" && nodeCfg.Node.LocalRange != "" {
+					localIP, err := ncutils.GetLocalIP(nodeCfg.Node.LocalRange)
+					if err != nil {
+						logger.Log(1, "error encountered checking local ip addresses: ", err.Error())
+					}
+					if nodeCfg.Node.Endpoint != localIP && localIP != "" {
+						logger.Log(1, "endpoint has changed from "+nodeCfg.Node.Endpoint+" to ", localIP)
+						nodeCfg.Node.Endpoint = localIP
+						if err := PublishNodeUpdate(&nodeCfg); err != nil {
+							logger.Log(0, "could not publish localip change")
+						}
 					}
 				}
+				if err := PingServer(&nodeCfg); err != nil {
+					logger.Log(0, "could not ping server  ", nodeCfg.Server.MQEndPoint, "\n", err.Error())
+				} else {
+					Hello(&nodeCfg)
+				}
 			}
 		}
 	}
 }
 
 // PublishNodeUpdates -- saves node and pushes changes to broker
-func PublishNodeUpdate(commsCfg, nodeCfg *config.ClientConfig) error {
+func PublishNodeUpdate(nodeCfg *config.ClientConfig) error {
 	if err := config.Write(nodeCfg, nodeCfg.Network); err != nil {
 		return err
 	}
@@ -97,7 +93,7 @@ func PublishNodeUpdate(commsCfg, nodeCfg *config.ClientConfig) error {
 	if err != nil {
 		return err
 	}
-	if err = publish(commsCfg, nodeCfg, fmt.Sprintf("update/%s", nodeCfg.Node.ID), data, 1); err != nil {
+	if err = publish(nodeCfg, fmt.Sprintf("update/%s", nodeCfg.Node.ID), data, 1); err != nil {
 		return err
 	}
 	logger.Log(0, "sent a node update to server for node", nodeCfg.Node.Name, ", ", nodeCfg.Node.ID)
@@ -105,38 +101,43 @@ func PublishNodeUpdate(commsCfg, nodeCfg *config.ClientConfig) error {
 }
 
 // Hello -- ping the broker to let server know node it's alive and well
-func Hello(commsCfg, nodeCfg *config.ClientConfig) {
-	if err := publish(commsCfg, nodeCfg, fmt.Sprintf("ping/%s", nodeCfg.Node.ID), []byte(ncutils.Version), 0); err != nil {
+func Hello(nodeCfg *config.ClientConfig) {
+	logger.Log(0, "In Hello")
+	if err := publish(nodeCfg, fmt.Sprintf("ping/%s", nodeCfg.Node.ID), []byte(ncutils.Version), 0); err != nil {
 		logger.Log(0, fmt.Sprintf("error publishing ping, %v", err))
-		logger.Log(0, "running pull on "+commsCfg.Node.Network+" to reconnect")
-		_, err := Pull(commsCfg.Node.Network, true)
+		logger.Log(0, "running pull on "+nodeCfg.Node.Network+" to reconnect")
+		_, err := Pull(nodeCfg.Node.Network, true)
 		if err != nil {
-			logger.Log(0, "could not run pull on "+commsCfg.Node.Network+", error: "+err.Error())
+			logger.Log(0, "could not run pull on "+nodeCfg.Node.Network+", error: "+err.Error())
 		}
 	}
+	logger.Log(2, "checked with server "+nodeCfg.NetworkSettings.NetID)
 }
 
 // requires the commscfg in which to send traffic over and nodecfg of node that is publish the message
 // node cfg is so that the traffic keys of that node may be fetched for encryption
-func publish(commsCfg, nodeCfg *config.ClientConfig, dest string, msg []byte, qos byte) error {
+func publish(nodeCfg *config.ClientConfig, dest string, msg []byte, qos byte) error {
 	// setup the keys
-	trafficPrivKey, err := auth.RetrieveTrafficKey(nodeCfg.Node.Network)
+	//trafficPrivKey, err := auth.RetrieveTrafficKey(nodeCfg.Node.Network)
+	_, err := auth.RetrieveTrafficKey(nodeCfg.Node.Network)
 	if err != nil {
 		return err
 	}
 
-	serverPubKey, err := ncutils.ConvertBytesToKey(nodeCfg.Node.TrafficKeys.Server)
+	//serverPubKey, err := ncutils.ConvertBytesToKey(nodeCfg.Node.TrafficKeys.Server)
+	_, err = ncutils.ConvertBytesToKey(nodeCfg.Node.TrafficKeys.Server)
 	if err != nil {
 		return err
 	}
-
-	client := setupMQTT(commsCfg, true)
+	logger.Log(0, "calling setup MQ ", nodeCfg.NetworkSettings.NetID)
+	client := SetupMQTT(nodeCfg, true)
 	defer client.Disconnect(250)
-	encrypted, err := ncutils.Chunk(msg, serverPubKey, trafficPrivKey)
-	if err != nil {
-		return err
-	}
-
+	//encrypted, err := ncutils.Chunk(msg, serverPubKey, trafficPrivKey)
+	//if err != nil {
+	//return err
+	//}
+	encrypted := "This is a test"
+	logger.Log(0, "calling Publish")
 	if token := client.Publish(dest, qos, false, encrypted); token.Wait() && token.Error() != nil {
 		return token.Error()
 	}

servercfg/serverconf.go

@@ -96,7 +96,7 @@ func GetServerConfig() config.ServerConfig {
 	cfg.ManageIPTables = ManageIPTables()
 	services := strings.Join(GetPortForwardServiceList(), ",")
 	cfg.PortForwardServices = services
-	cfg.CommsID = GetCommsID()
+	cfg.MQEndPoint = GetMessageQueueEndpoint(true)
 
 	return cfg
 }
@@ -259,43 +259,19 @@ func GetMQPort() string {
 	return mqport
 }
 
-// GetGRPCPort - gets the grpc port
-func GetCommsCIDR() string {
-	netrange := "172.16.0.0/16"
-	if os.Getenv("COMMS_CIDR") != "" {
-		netrange = os.Getenv("COMMS_CIDR")
-	} else if config.Config.Server.CommsCIDR != "" {
-		netrange = config.Config.Server.CommsCIDR
-	} else { // make a random one, which should only affect initialize first time, unless db is removed
-		netrange = genNewCommsCIDR()
-	}
-	_, _, err := net.ParseCIDR(netrange)
-	if err == nil {
-		return netrange
-	}
-	return "172.16.0.0/16"
-}
-
-// GetCommsID - gets the grpc port
-func GetCommsID() string {
-	return commsID
-}
-
-// SetCommsID - sets the commsID
-func SetCommsID(newCommsID string) {
-	commsID = newCommsID
-}
-
 // GetMessageQueueEndpoint - gets the message queue endpoint
-func GetMessageQueueEndpoint() string {
-	host, _ := GetPublicIP()
-	if os.Getenv("MQ_HOST") != "" {
-		host = os.Getenv("MQ_HOST")
-	} else if config.Config.Server.MQHOST != "" {
-		host = config.Config.Server.MQHOST
+func GetMessageQueueEndpoint(ssl bool) string {
+	if ssl {
+		host, _ := GetPublicIP()
+		if os.Getenv("MQ_HOST") != "" {
+			host = os.Getenv("MQ_HOST")
+		} else if config.Config.Server.MQHOST != "" {
+			host = config.Config.Server.MQHOST
+		}
+		return host + ":8883"
 	}
 	//Do we want MQ port configurable???
-	return host + ":1883"
+	return "127.0.0.1:1883"
 }
 
 // GetMasterKey - gets the configured master key of server

serverctl/serverctl.go

@@ -12,7 +12,6 @@ import (
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/logic/acls"
 	"github.com/gravitl/netmaker/logic/acls/nodeacls"
-	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/servercfg"
 )
@@ -25,34 +24,6 @@ const (
 	NETMAKER_BINARY_NAME = "netmaker"
 )
 
-// InitializeCommsNetwork - Check if comms network exists (for MQ, DNS, SSH traffic), if not, create
-func InitializeCommsNetwork() error {
-
-	setCommsID()
-
-	commsNetwork, err := logic.GetNetwork(COMMS_NETID)
-	if err != nil {
-		var network models.Network
-		network.NetID = COMMS_NETID
-		network.AddressRange = servercfg.GetCommsCIDR()
-		network.IsPointToSite = "yes"
-		network.DefaultUDPHolePunch = "yes"
-		network.IsComms = "yes"
-		logger.Log(1, "comms net does not exist, creating with ID,", network.NetID, "and CIDR,", network.AddressRange)
-		_, err = logic.CreateNetwork(network)
-		return err
-	} else if commsNetwork.DefaultACL == "" {
-		commsNetwork.DefaultACL = "yes"
-		if err = logic.SaveNetwork(&commsNetwork); err != nil {
-			logger.Log(1, "comms net default acl is set incorrectly, please manually adjust to \"yes\",", COMMS_NETID)
-		}
-	}
-	// gracefully check for comms interface
-	gracefulCommsWait()
-
-	return nil
-}
-
 func gracefulCommsWait() {
 	output, _ := ncutils.RunCmd("wg", false)
 	starttime := time.Now()
@@ -66,22 +37,6 @@ func gracefulCommsWait() {
 	logger.Log(1, "comms network", COMMS_NETID, "ready")
 }
 
-// SetJWTSecret - sets the jwt secret on server startup
-func setCommsID() {
-	currentid, idErr := logic.FetchCommsNetID()
-	if idErr != nil {
-		commsid := logic.RandomString(8)
-		if err := logic.StoreCommsNetID(commsid); err != nil {
-			logger.FatalLog("something went wrong when configuring comms id")
-		}
-		COMMS_NETID = commsid
-		servercfg.SetCommsID(COMMS_NETID)
-		return
-	}
-	COMMS_NETID = currentid
-	servercfg.SetCommsID(COMMS_NETID)
-}
-
 // InitServerNetclient - intializes the server netclient
 // 1. Check if config directory exists, if not attempt to make
 // 2. Check current networks and run pull to get interface up to date in case of restart