added comments, optimized memory

Dockerfile

@@ -5,7 +5,7 @@ RUN apk add build-base
 WORKDIR /app
 COPY . .
 ENV GO111MODULE=auto
-RUN GOOS=linux CGO_ENABLED=1 go build -tags debug -ldflags="-s -X 'main.version=$version'" -o netmaker main.go
+RUN GOOS=linux CGO_ENABLED=1 go build -ldflags="-s -X 'main.version=$version'" -o netmaker main.go
 FROM alpine:3.13.6
 # add a c lib
 RUN apk add gcompat iptables

database/database.go

@@ -89,6 +89,7 @@ func getCurrentDB() map[string]interface{} {
 	}
 }
 
+// InitializeDatabase - initializes database
 func InitializeDatabase() error {
 	logger.Log(0, "connecting to", servercfg.GetDB())
 	tperiod := time.Now().Add(10 * time.Second)

database/postgres.go

@@ -49,6 +49,7 @@ func pgCreateTable(tableName string) error {
 	if err != nil {
 		return err
 	}
+	defer statement.Close()
 	_, err = statement.Exec()
 	if err != nil {
 		return err
@@ -63,6 +64,7 @@ func pgInsert(key string, value string, tableName string) error {
 		if err != nil {
 			return err
 		}
+		defer statement.Close()
 		_, err = statement.Exec(key, value, value)
 		if err != nil {
 			return err
@@ -91,6 +93,7 @@ func pgDeleteRecord(tableName string, key string) error {
 	if err != nil {
 		return err
 	}
+	defer statement.Close()
 	if _, err = statement.Exec(key); err != nil {
 		return err
 	}
@@ -103,6 +106,7 @@ func pgDeleteAllRecords(tableName string) error {
 	if err != nil {
 		return err
 	}
+	defer statement.Close()
 	if _, err = statement.Exec(); err != nil {
 		return err
 	}

database/sqlite.go

@@ -12,7 +12,7 @@ import (
 // == sqlite ==
 const dbFilename = "netmaker.db"
 
-// SqliteDB is the db object fro sqlite database connections
+// SqliteDB is the db object for sqlite database connections
 var SqliteDB *sql.DB
 
 // SQLITE_FUNCTIONS - contains a map of the functions for sqlite
@@ -50,6 +50,7 @@ func sqliteCreateTable(tableName string) error {
 	if err != nil {
 		return err
 	}
+	defer statement.Close()
 	_, err = statement.Exec()
 	if err != nil {
 		return err
@@ -64,6 +65,7 @@ func sqliteInsert(key string, value string, tableName string) error {
 		if err != nil {
 			return err
 		}
+		defer statement.Close()
 		_, err = statement.Exec(key, value)
 		if err != nil {
 			return err
@@ -90,6 +92,7 @@ func sqliteDeleteRecord(tableName string, key string) error {
 	if err != nil {
 		return err
 	}
+	defer statement.Close()
 	if _, err = statement.Exec(); err != nil {
 		return err
 	}
@@ -102,6 +105,7 @@ func sqliteDeleteAllRecords(tableName string) error {
 	if err != nil {
 		return err
 	}
+	defer statement.Close()
 	if _, err = statement.Exec(); err != nil {
 		return err
 	}

logic/networks.go

@@ -685,10 +685,14 @@ func isInterfacePresent(iface string, address string) (string, bool) {
 		for _, addr := range currAddrs {
 			if strings.Contains(addr.String(), address) && currIface.Name != iface {
 				logger.Log(2, "found iface", addr.String(), currIface.Name)
+				interfaces = nil
+				currAddrs = nil
 				return currIface.Name, false
 			}
 		}
+		currAddrs = nil
 	}
+	interfaces = nil
 	logger.Log(2, "failed to find iface", iface)
 	return "", true
 }

logic/nodes.go

@@ -86,9 +86,9 @@ func UncordonNode(network, macaddress string) (models.Node, error) {
 }
 
 // GetPeers - gets the peers of a given node
-func GetPeers(node models.Node) ([]models.Node, error) {
-	if node.IsServer == "yes" && IsLeader(&node) {
-		SetNetworkServerPeers(&node)
+func GetPeers(node *models.Node) ([]models.Node, error) {
+	if IsLeader(node) {
+		SetNetworkServerPeers(node)
 	}
 	excludeIsRelayed := node.IsRelay != "yes"
 	var relayedNode string
@@ -137,11 +137,13 @@ func UpdateNode(currentNode *models.Node, newNode *models.Node) error {
 	return fmt.Errorf("failed to update node " + newNode.MacAddress + ", cannot change macaddress.")
 }
 
+// IsNodeIDUnique - checks if node id is unique
 func IsNodeIDUnique(node *models.Node) (bool, error) {
 	_, err := database.FetchRecord(database.NODES_TABLE_NAME, node.ID)
 	return database.IsEmptyRecord(err), err
 }
 
+// ValidateNode - validates node values
 func ValidateNode(node *models.Node, isUpdate bool) error {
 	v := validator.New()
 	_ = v.RegisterValidation("macaddress_unique", func(fl validator.FieldLevel) bool {
@@ -212,7 +214,7 @@ func CheckIsServer(node *models.Node) bool {
 // GetNetworkByNode - gets the network model from a node
 func GetNetworkByNode(node *models.Node) (models.Network, error) {
 
-	var network models.Network
+	var network = models.Network{}
 	networkData, err := database.FetchRecord(database.NETWORKS_TABLE_NAME, node.Network)
 	if err != nil {
 		return network, err

logic/server.go

@@ -21,6 +21,8 @@ import (
 
 // KUBERNETES_LISTEN_PORT - starting port for Kubernetes in order to use NodePort range
 const KUBERNETES_LISTEN_PORT = 31821
+
+// KUBERNETES_SERVER_MTU - ideal mtu for kubernetes deployments right now
 const KUBERNETES_SERVER_MTU = 1024
 
 // ServerJoin - responsible for joining a server to a network
@@ -111,13 +113,13 @@ func ServerJoin(network string, serverID string, privateKey string) error {
 		return err
 	}
 
-	peers, hasGateway, gateways, err := GetServerPeers(node.MacAddress, network, node.IsDualStack == "yes", node.IsIngressGateway == "yes")
+	peers, hasGateway, gateways, err := GetServerPeers(node)
 	if err != nil && !ncutils.IsEmptyRecord(err) {
 		logger.Log(1, "failed to retrieve peers")
 		return err
 	}
 
-	err = initWireguard(node, privateKey, peers, hasGateway, gateways)
+	err = initWireguard(node, privateKey, peers[:], hasGateway, gateways[:])
 	if err != nil {
 		return err
 	}
@@ -127,46 +129,43 @@ func ServerJoin(network string, serverID string, privateKey string) error {
 
 // ServerCheckin - runs pulls and pushes for server
 func ServerCheckin(mac string, network string) error {
-	var serverNode models.Node
-	var newNode *models.Node
-	var err error
-	serverNode, err = GetNode(mac, network)
+	var serverNode *models.Node
+	var currentNode, err = GetNode(mac, network)
 	if err != nil {
 		return err
 	}
+	serverNode = &currentNode
 
-	newNode, err = ServerPull(&serverNode, false)
+	err = ServerPull(serverNode, false)
 	if isDeleteError(err) {
 		return ServerLeave(mac, network)
 	} else if err != nil {
 		return err
 	}
 
-	actionCompleted := checkNodeActions(newNode, network, &serverNode)
+	actionCompleted := checkNodeActions(serverNode)
 	if actionCompleted == models.NODE_DELETE {
 		return errors.New("node has been removed")
 	}
 
-	return ServerPush(newNode)
+	return ServerPush(serverNode)
 }
 
 // ServerPull - pulls current config/peers for server
-func ServerPull(serverNode *models.Node, onErr bool) (*models.Node, error) {
+func ServerPull(serverNode *models.Node, onErr bool) error {
 
 	var err error
 	if serverNode.IPForwarding == "yes" {
 		if err = setIPForwardingLinux(); err != nil {
-			return serverNode, err
+			return err
 		}
 	}
 	serverNode.OS = runtime.GOOS
 
 	if serverNode.PullChanges == "yes" || onErr {
 		// check for interface change
-		var isIfacePresent bool
-		var oldIfaceName string
 		// checks if address is in use by another interface
-		oldIfaceName, isIfacePresent = isInterfacePresent(serverNode.Interface, serverNode.Address)
+		var oldIfaceName, isIfacePresent = isInterfacePresent(serverNode.Interface, serverNode.Address)
 		if !isIfacePresent {
 			if err = deleteInterface(oldIfaceName, serverNode.PostDown); err != nil {
 				logger.Log(1, "could not delete old interface", oldIfaceName)
@@ -174,24 +173,24 @@ func ServerPull(serverNode *models.Node, onErr bool) (*models.Node, error) {
 			logger.Log(1, "removed old interface", oldIfaceName)
 		}
 		serverNode.PullChanges = "no"
-		if err = setWGConfig(serverNode, serverNode.Network, false); err != nil {
-			return serverNode, err
+		if err = setWGConfig(serverNode, false); err != nil {
+			return err
 		}
 		// handle server side update
 		if err = UpdateNode(serverNode, serverNode); err != nil {
-			return serverNode, err
+			return err
 		}
 	} else {
-		if err = setWGConfig(serverNode, serverNode.Network, true); err != nil {
+		if err = setWGConfig(serverNode, true); err != nil {
 			if errors.Is(err, os.ErrNotExist) {
 				return ServerPull(serverNode, true)
 			} else {
-				return serverNode, err
+				return err
 			}
 		}
 	}
 
-	return serverNode, nil
+	return nil
 }
 
 // ServerPush - pushes config changes for server checkins/join
@@ -204,9 +203,7 @@ func ServerPush(serverNode *models.Node) error {
 // ServerLeave - removes a server node
 func ServerLeave(mac string, network string) error {
 
-	var serverNode models.Node
-	var err error
-	serverNode, err = GetNode(mac, network)
+	var serverNode, err = GetNode(mac, network)
 	if err != nil {
 		return err
 	}
@@ -220,28 +217,25 @@ func ServerLeave(mac string, network string) error {
  */
 
 // GetServerPeers - gets peers of server
-func GetServerPeers(macaddress string, network string, dualstack bool, isIngressGateway bool) ([]wgtypes.PeerConfig, bool, []string, error) {
+func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []string, error) {
 	hasGateway := false
-	var err error
 	var gateways []string
 	var peers []wgtypes.PeerConfig
-	var nodecfg models.Node
 	var nodes []models.Node // fill above fields from server or client
 
-	nodecfg, err = GetNode(macaddress, network)
+	var nodecfg, err = GetNode(serverNode.MacAddress, serverNode.Network)
 	if err != nil {
 		return nil, hasGateway, gateways, err
 	}
-	nodes, err = GetPeers(nodecfg)
+	nodes, err = GetPeers(&nodecfg)
 	if err != nil {
 		return nil, hasGateway, gateways, err
 	}
 
 	keepalive := nodecfg.PersistentKeepalive
 	keepalivedur, err := time.ParseDuration(strconv.FormatInt(int64(keepalive), 10) + "s")
-	keepaliveserver, err := time.ParseDuration(strconv.FormatInt(int64(5), 10) + "s")
 	if err != nil {
-		logger.Log(1, "Issue with format of keepalive value, Please view server config:", err.Error())
+		logger.Log(1, "Issue with format of keepalive duration value, Please view server config:", err.Error())
 		return nil, hasGateway, gateways, err
 	}
 
@@ -268,8 +262,9 @@ func GetServerPeers(macaddress string, network string, dualstack bool, isIngress
 			IP:   net.ParseIP(node.Address),
 			Mask: net.CIDRMask(32, 32),
 		}
-		var allowedips []net.IPNet
-		allowedips = append(allowedips, peeraddr)
+		var allowedips = []net.IPNet{
+			peeraddr,
+		}
 		// handle manually set peers
 		for _, allowedIp := range node.AllowedIPs {
 			if _, ipnet, err := net.ParseCIDR(allowedIp); err == nil {
@@ -288,7 +283,7 @@ func GetServerPeers(macaddress string, network string, dualstack bool, isIngress
 		// handle egress gateway peers
 		if node.IsEgressGateway == "yes" {
 			hasGateway = true
-			ranges := node.EgressGatewayRanges
+			ranges := node.EgressGatewayRanges[:]
 			for _, iprange := range ranges { // go through each cidr for egress gateway
 				_, ipnet, err := net.ParseCIDR(iprange) // confirming it's valid cidr
 				if err != nil {
@@ -311,73 +306,47 @@ func GetServerPeers(macaddress string, network string, dualstack bool, isIngress
 					allowedips = append(allowedips, *ipnet)
 				}
 			}
+			ranges = nil
 		}
-		if node.Address6 != "" && dualstack {
+		if node.Address6 != "" && serverNode.IsDualStack == "yes" {
 			var addr6 = net.IPNet{
 				IP:   net.ParseIP(node.Address6),
 				Mask: net.CIDRMask(128, 128),
 			}
 			allowedips = append(allowedips, addr6)
 		}
-		if nodecfg.IsServer == "yes" && !(node.IsServer == "yes") {
-			peer = wgtypes.PeerConfig{
-				PublicKey:                   pubkey,
-				PersistentKeepaliveInterval: &keepaliveserver,
-				ReplaceAllowedIPs:           true,
-				AllowedIPs:                  allowedips,
-			}
-		} else if keepalive != 0 {
-			peer = wgtypes.PeerConfig{
-				PublicKey:                   pubkey,
-				PersistentKeepaliveInterval: &keepalivedur,
-				Endpoint: &net.UDPAddr{
-					IP:   net.ParseIP(node.Endpoint),
-					Port: int(node.ListenPort),
-				},
-				ReplaceAllowedIPs: true,
-				AllowedIPs:        allowedips,
-			}
-		} else {
-			peer = wgtypes.PeerConfig{
-				PublicKey: pubkey,
-				Endpoint: &net.UDPAddr{
-					IP:   net.ParseIP(node.Endpoint),
-					Port: int(node.ListenPort),
-				},
-				ReplaceAllowedIPs: true,
-				AllowedIPs:        allowedips,
-			}
+		peer = wgtypes.PeerConfig{
+			PublicKey:                   pubkey,
+			PersistentKeepaliveInterval: &(keepalivedur),
+			ReplaceAllowedIPs:           true,
+			AllowedIPs:                  allowedips,
 		}
 		peers = append(peers, peer)
 	}
-	if isIngressGateway {
-		extPeers, err := GetServerExtPeers(macaddress, network, dualstack)
+	if serverNode.IsIngressGateway == "yes" {
+		extPeers, err := GetServerExtPeers(serverNode)
 		if err == nil {
 			peers = append(peers, extPeers...)
 		} else {
 			logger.Log(1, "ERROR RETRIEVING EXTERNAL PEERS ON SERVER:", err.Error())
 		}
+		extPeers = nil
 	}
-	return peers[:], hasGateway, gateways[:], err
+	return peers, hasGateway, gateways, err
 }
 
 // GetServerExtPeers - gets the extpeers for a client
-func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgtypes.PeerConfig, error) {
+func GetServerExtPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, error) {
 	var peers []wgtypes.PeerConfig
-	var nodecfg models.Node
 	var extPeers []models.Node
 	var err error
-	// fill above fields from either client or server
-
-	nodecfg, err = GetNode(macaddress, network)
-	if err != nil {
-		return nil, err
-	}
 	var tempPeers []models.ExtPeersResponse
-	tempPeers, err = GetExtPeersList(nodecfg.MacAddress, nodecfg.Network)
+
+	tempPeers, err = GetExtPeersList(serverNode.MacAddress, serverNode.Network)
 	if err != nil {
 		return nil, err
 	}
+
 	for i := 0; i < len(tempPeers); i++ {
 		extPeers = append(extPeers, models.Node{
 			Address:             tempPeers[i].Address,
@@ -395,7 +364,7 @@ func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgt
 			return peers, err
 		}
 
-		if nodecfg.PublicKey == extPeer.PublicKey {
+		if serverNode.PublicKey == extPeer.PublicKey {
 			continue
 		}
 
@@ -404,10 +373,11 @@ func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgt
 			IP:   net.ParseIP(extPeer.Address),
 			Mask: net.CIDRMask(32, 32),
 		}
-		var allowedips []net.IPNet
-		allowedips = append(allowedips, peeraddr)
+		var allowedips = []net.IPNet{
+			peeraddr,
+		}
 
-		if extPeer.Address6 != "" && dualstack {
+		if extPeer.Address6 != "" && serverNode.IsDualStack == "yes" {
 			var addr6 = net.IPNet{
 				IP:   net.ParseIP(extPeer.Address6),
 				Mask: net.CIDRMask(128, 128),
@@ -420,8 +390,11 @@ func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgt
 			AllowedIPs:        allowedips,
 		}
 		peers = append(peers, peer)
+		allowedips = nil
 	}
-	return peers[:], err
+	tempPeers = nil
+	extPeers = nil
+	return peers, err
 }
 
 // == Private ==
@@ -430,8 +403,8 @@ func isDeleteError(err error) bool {
 	return err != nil && strings.Contains(err.Error(), models.NODE_DELETE)
 }
 
-func checkNodeActions(node *models.Node, networkName string, localNode *models.Node) string {
-	if (node.Action == models.NODE_UPDATE_KEY || localNode.Action == models.NODE_UPDATE_KEY) &&
+func checkNodeActions(node *models.Node) string {
+	if (node.Action == models.NODE_UPDATE_KEY) &&
 		node.IsStatic != "yes" {
 		err := setWGKeyConfig(node)
 		if err != nil {
@@ -439,8 +412,8 @@ func checkNodeActions(node *models.Node, networkName string, localNode *models.N
 			return ""
 		}
 	}
-	if node.Action == models.NODE_DELETE || localNode.Action == models.NODE_DELETE {
-		err := ServerLeave(node.MacAddress, networkName)
+	if node.Action == models.NODE_DELETE {
+		err := ServerLeave(node.MacAddress, node.Network)
 		if err != nil {
 			logger.Log(1, "error deleting locally:", err.Error())
 		}

logic/serverconf.go

@@ -12,12 +12,11 @@ type serverData struct {
 
 // StorePrivKey - stores server client WireGuard privatekey if needed
 func StorePrivKey(serverID string, privateKey string) error {
-	var newData *serverData
-	newData = &serverData{}
+	var newData = serverData{}
 	var err error
 	var data []byte
 	newData.PrivateKey = privateKey
-	data, err = json.Marshal(newData)
+	data, err = json.Marshal(&newData)
 	if err != nil {
 		return err
 	}
@@ -28,8 +27,7 @@ func StorePrivKey(serverID string, privateKey string) error {
 func FetchPrivKey(serverID string) (string, error) {
 	var dbData string
 	var err error
-	var fetchedData serverData
-	fetchedData = serverData{}
+	var fetchedData = serverData{}
 	dbData, err = database.FetchRecord(database.SERVERCONF_TABLE_NAME, serverID)
 	if err != nil {
 		return "", err

logic/util.go

@@ -70,7 +70,7 @@ func DeleteNode(node *models.Node, exterminate bool) error {
 		return err
 	}
 	if servercfg.IsDNSMode() {
-		err = SetDNS()
+		SetDNS()
 	}
 	return removeLocalServer(node)
 }
@@ -171,7 +171,7 @@ func GetNode(macaddress string, network string) (models.Node, error) {
 	data, err := database.FetchRecord(database.NODES_TABLE_NAME, key)
 	if err != nil {
 		if data == "" {
-			data, err = database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
+			data, _ = database.FetchRecord(database.DELETED_NODES_TABLE_NAME, key)
 			err = json.Unmarshal([]byte(data), &node)
 		}
 		return node, err
@@ -200,9 +200,9 @@ func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error
 		logger.Log(2, errN.Error())
 	}
 	for _, value := range collection {
-		var node models.Node
+		var node *models.Node
 		var peer models.Node
-		err := json.Unmarshal([]byte(value), &node)
+		err := json.Unmarshal([]byte(value), node)
 		if err != nil {
 			logger.Log(2, err.Error())
 			continue
@@ -244,32 +244,31 @@ func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error
 // GetPeersList - gets the peers of a given network
 func GetPeersList(networkName string, excludeRelayed bool, relayedNodeAddr string) ([]models.Node, error) {
 	var peers []models.Node
-	var relayNode 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 != "" {
-			relayNode = setPeerInfo(relayNode)
+			var peerNode = setPeerInfo(&relayNode) // WHAT DO
 			network, err := GetNetwork(networkName)
 			if err == nil {
-				relayNode.AllowedIPs = append(relayNode.AllowedIPs, network.AddressRange)
+				peerNode.AllowedIPs = append(peerNode.AllowedIPs, network.AddressRange)
 			} else {
-				relayNode.AllowedIPs = append(relayNode.AllowedIPs, relayNode.RelayAddrs...)
+				peerNode.AllowedIPs = append(peerNode.AllowedIPs, peerNode.RelayAddrs...)
 			}
 			nodepeers, err := GetNodePeers(networkName, false)
-			if err == nil && relayNode.UDPHolePunch == "yes" {
+			if err == nil && peerNode.UDPHolePunch == "yes" {
 				for _, nodepeer := range nodepeers {
-					if nodepeer.Address == relayNode.Address {
-						relayNode.Endpoint = nodepeer.Endpoint
-						relayNode.ListenPort = nodepeer.ListenPort
+					if nodepeer.Address == peerNode.Address {
+						peerNode.Endpoint = nodepeer.Endpoint
+						peerNode.ListenPort = nodepeer.ListenPort
 					}
 				}
 			}
 
-			peers = append(peers, relayNode)
+			peers = append(peers, peerNode)
 		}
 	}
 	return peers, err
@@ -277,7 +276,7 @@ func GetPeersList(networkName string, excludeRelayed bool, relayedNodeAddr strin
 
 // RandomString - returns a random string in a charset
 func RandomString(length int) string {
-	const charset = "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 
 	var seededRand *rand.Rand = rand.New(rand.NewSource(time.Now().UnixNano()))
 
@@ -290,7 +289,8 @@ func RandomString(length int) string {
 
 // == Private Methods ==
 
-func setPeerInfo(node models.Node) models.Node {
+// WHAT DO
+func setPeerInfo(node *models.Node) models.Node {
 	var peer models.Node
 	peer.RelayAddrs = node.RelayAddrs
 	peer.IsRelay = node.IsRelay

logic/wireguard.go

@@ -25,6 +25,7 @@ func GetSystemPeers(node *models.Node) (map[string]string, error) {
 	if err != nil {
 		return peers, err
 	}
+	defer client.Close()
 	device, err := client.Device(node.Interface)
 	if err != nil {
 		return nil, err
@@ -45,7 +46,7 @@ func RemoveConf(iface string, printlog bool) error {
 	return err
 }
 
-// Private Functions
+// == Private Functions ==
 
 func initWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig, hasGateway bool, gateways []string) error {
 
@@ -210,6 +211,7 @@ func setServerPeers(iface string, keepalive int32, peers []wgtypes.PeerConfig) e
 		logger.Log(0, "failed to start wgctrl")
 		return err
 	}
+	defer client.Close()
 
 	device, err := client.Device(iface)
 	if err != nil {
@@ -280,10 +282,10 @@ func setServerPeers(iface string, keepalive int32, peers []wgtypes.PeerConfig) e
 	return nil
 }
 
-func setWGConfig(node *models.Node, network string, peerupdate bool) error {
+func setWGConfig(node *models.Node, peerupdate bool) error {
 
 	node.SetID()
-	peers, hasGateway, gateways, err := GetServerPeers(node.MacAddress, node.Network, node.IsDualStack == "yes", node.IsIngressGateway == "yes")
+	peers, hasGateway, gateways, err := GetServerPeers(node)
 	if err != nil {
 		return err
 	}
@@ -292,11 +294,10 @@ func setWGConfig(node *models.Node, network string, peerupdate bool) error {
 		return err
 	}
 	if peerupdate {
-		var iface string = node.Interface
-		err = setServerPeers(iface, node.PersistentKeepalive, peers)
+		err = setServerPeers(node.Interface, node.PersistentKeepalive, peers[:])
 		logger.Log(2, "updated peers on server", node.Name)
 	} else {
-		err = initWireguard(node, privkey, peers, hasGateway, gateways)
+		err = initWireguard(node, privkey, peers[:], hasGateway, gateways[:])
 		logger.Log(3, "finished setting wg config on server", node.Name)
 	}
 	return err
@@ -311,7 +312,6 @@ func setWGKeyConfig(node *models.Node) error {
 	}
 	privkeystring := privatekey.String()
 	publickey := privatekey.PublicKey()
-
 	node.PublicKey = publickey.String()
 
 	err = StorePrivKey(node.ID, privkeystring)
@@ -322,7 +322,7 @@ func setWGKeyConfig(node *models.Node) error {
 		node.Action = models.NODE_NOOP
 	}
 
-	return setWGConfig(node, node.Network, false)
+	return setWGConfig(node, false)
 }
 
 func removeLocalServer(node *models.Node) error {

main.go

@@ -1,6 +1,3 @@
-//TODO: Harden. Add failover for every method and agent calls
-//TODO: Figure out why mongodb keeps failing (log rotation?)
-
 package main
 
 import (
@@ -117,11 +114,10 @@ func startControllers() {
 	if servercfg.IsClientMode() == "on" {
 		var checkintime = time.Duration(servercfg.GetServerCheckinInterval()) * time.Second
 		for { // best effort currently
-			var netSyncGroup sync.WaitGroup
-			netSyncGroup.Add(1)
-			go runClient(&netSyncGroup)
-			netSyncGroup.Wait()
-			logger.Log(0, "ran a checkin")
+			var serverGroup sync.WaitGroup
+			serverGroup.Add(1)
+			go runClient(&serverGroup)
+			serverGroup.Wait()
 			time.Sleep(checkintime)
 		}
 	}
@@ -169,7 +165,7 @@ func runGRPC(wg *sync.WaitGroup) {
 
 	// Right way to stop the server using a SHUTDOWN HOOK
 	// Create a channel to receive OS signals
-	c := make(chan os.Signal)
+	c := make(chan os.Signal, 1)
 
 	// Relay os.Interrupt to our channel (os.Interrupt = CTRL+C)
 	// Ignore other incoming signals

netclient/functions/common.go

@@ -33,6 +33,7 @@ func ListPorts() error {
 	if err != nil {
 		return err
 	}
+	defer wgclient.Close()
 	devices, err := wgclient.Devices()
 	if err != nil {
 		return err

netclient/ncutils/netclientutils.go

@@ -261,6 +261,7 @@ func GetFreePort(rangestart int32) (int32, error) {
 	if err != nil {
 		return 0, err
 	}
+	defer wgclient.Close()
 	devices, err := wgclient.Devices()
 	if err != nil {
 		return 0, err

netclient/ncutils/peerhelper.go

@@ -1,17 +1,17 @@
 package ncutils
 
 import (
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
+	"net"
 	"strconv"
 	"strings"
-	"net"
 	"time"
-	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
 func GetPeers(iface string) ([]wgtypes.Peer, error) {
 
 	var peers []wgtypes.Peer
-	output, err := RunCmd("wg show "+iface+" dump",true)
+	output, err := RunCmd("wg show "+iface+" dump", true)
 	if err != nil {
 		return peers, err
 	}
@@ -22,7 +22,7 @@ func GetPeers(iface string) ([]wgtypes.Peer, error) {
 		var allowedIPs []net.IPNet
 		fields := strings.Fields(line)
 		if len(fields) < 4 {
-			Log("error parsing peer: "+line)
+			Log("error parsing peer: " + line)
 			continue
 		}
 		pubkeystring := fields[0]
@@ -36,13 +36,13 @@ func GetPeers(iface string) ([]wgtypes.Peer, error) {
 
 		pubkey, err := wgtypes.ParseKey(pubkeystring)
 		if err != nil {
-			Log("error parsing peer key "+pubkeystring)
+			Log("error parsing peer key " + pubkeystring)
 			continue
 		}
 		ipstrings := strings.Split(allowedipstring, ",")
 		for _, ipstring := range ipstrings {
 			var netip net.IP
-			if netip = net.ParseIP(strings.Split(ipstring,"/")[0]); netip != nil {
+			if netip = net.ParseIP(strings.Split(ipstring, "/")[0]); netip != nil {
 				allowedIPs = append(
 					allowedIPs,
 					net.IPNet{
@@ -53,40 +53,39 @@ func GetPeers(iface string) ([]wgtypes.Peer, error) {
 			}
 		}
 		if len(allowedIPs) == 0 {
-			Log("error parsing peer "+pubkeystring+", no allowedips found")
+			Log("error parsing peer " + pubkeystring + ", no allowedips found")
 			continue
 		}
 		var endpointarr []string
 		var endpointip net.IP
-		if endpointarr = strings.Split(endpointstring,":"); len(endpointarr) != 2 {
-			Log("error parsing peer "+pubkeystring+", could not parse endpoint: "+endpointstring)
+		if endpointarr = strings.Split(endpointstring, ":"); len(endpointarr) != 2 {
+			Log("error parsing peer " + pubkeystring + ", could not parse endpoint: " + endpointstring)
 			continue
 		}
 		if endpointip = net.ParseIP(endpointarr[0]); endpointip == nil {
-			Log("error parsing peer "+pubkeystring+", could not parse endpoint: "+endpointarr[0])
+			Log("error parsing peer " + pubkeystring + ", could not parse endpoint: " + endpointarr[0])
 			continue
 		}
 		var port int
 		if port, err = strconv.Atoi(endpointarr[1]); err != nil {
-			Log("error parsing peer "+pubkeystring+", could not parse port: "+err.Error())
+			Log("error parsing peer " + pubkeystring + ", could not parse port: " + err.Error())
 			continue
 		}
-		var endpoint = net.UDPAddr {
-			IP: endpointip,
+		var endpoint = net.UDPAddr{
+			IP:   endpointip,
 			Port: port,
 		}
 		var dur time.Duration
 		if pkeepalivestring != "" {
-			if dur, err = time.ParseDuration(pkeepalivestring+"s"); err != nil {
-				Log("error parsing peer "+pubkeystring+", could not parse keepalive: "+err.Error())
+			if dur, err = time.ParseDuration(pkeepalivestring + "s"); err != nil {
+				Log("error parsing peer " + pubkeystring + ", could not parse keepalive: " + err.Error())
 			}
 		}
 
-
 		peers = append(peers, wgtypes.Peer{
-			PublicKey:         pubkey,
-			Endpoint:          &endpoint,
-			AllowedIPs:        allowedIPs,
+			PublicKey:                   pubkey,
+			Endpoint:                    &endpoint,
+			AllowedIPs:                  allowedIPs,
 			PersistentKeepaliveInterval: dur,
 		})
 	}

netclient/wireguard/common.go

@@ -36,6 +36,7 @@ func SetPeers(iface string, keepalive int32, peers []wgtypes.PeerConfig) error {
 			ncutils.PrintLog("failed to start wgctrl", 0)
 			return err
 		}
+		defer client.Close()
 		device, err := client.Device(iface)
 		if err != nil {
 			ncutils.PrintLog("failed to parse interface", 0)
@@ -114,7 +115,7 @@ func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
 	if err != nil {
 		return err
 	}
-
+	defer wgclient.Close()
 	modcfg, err := config.ReadConfig(node.Network)
 	if err != nil {
 		return err
@@ -125,7 +126,6 @@ func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
 	if err != nil {
 		log.Fatalf("failed to open client: %v", err)
 	}
-	defer wgclient.Close()
 
 	var ifacename string
 	if nodecfg.Interface != "" {

servercfg/serverconf.go

@@ -108,7 +108,7 @@ func GetAPIConnString() string {
 
 // GetVersion - version of netmaker
 func GetVersion() string {
-	version := "0.9.1"
+	version := "0.9.2"
 	if config.Config.Server.Version != "" {
 		version = config.Config.Server.Version
 	}

serverctl/serverctl.go

@@ -77,9 +77,10 @@ func HandleContainedClient() error {
 				logger.Log(3, "completed peers check of network", serverNet.NetID)
 			}
 		}
-		err := SyncNetworks(servernets[:])
-		if err != nil {
-			logger.Log(1, "error syncing networks:", err.Error())
+		syncErr := SyncNetworks(servernets[:])
+		if syncErr != nil {
+			logger.Log(1, "error syncing networks:", syncErr.Error())
+			syncErr = nil
 		}
 		// logger.Log("completed a checkin call", 3)
 	}