Merge pull request #830 from gravitl/v0.11.0

V0.11.0 Hotfixes

controllers/node.go

@@ -625,10 +625,6 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 
 func runUpdates(node *models.Node, ifaceDelta bool) {
 	go func() { // don't block http response
-		err := logic.TimerCheckpoint()
-		if err != nil {
-			logger.Log(3, "error occurred on timer,", err.Error())
-		}
 		// publish node update if not server
 		if err := mq.NodeUpdate(node); err != nil {
 			logger.Log(1, "error publishing node update to node", node.Name, node.ID, err.Error())

mq/publishers.go

@@ -8,6 +8,7 @@ import (
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/servercfg"
+	"github.com/gravitl/netmaker/serverctl"
 )
 
 // PublishPeerUpdate --- deterines and publishes a peer update to all the peers of a node
@@ -91,16 +92,22 @@ func NodeUpdate(node *models.Node) error {
 
 // sendPeers - retrieve networks, send peer ports to all peers
 func sendPeers() {
+
 	var force bool
 	peer_force_send++
 	if peer_force_send == 5 {
 		force = true
 		peer_force_send = 0
+		err := logic.TimerCheckpoint() // run telemetry & log dumps if 24 hours has passed..
+		if err != nil {
+			logger.Log(3, "error occurred on timer,", err.Error())
+		}
 	}
 	networks, err := logic.GetNetworks()
 	if err != nil {
 		logger.Log(1, "error retrieving networks for keepalive", err.Error())
 	}
+
 	for _, network := range networks {
 		serverNode, errN := logic.GetNetworkServerLeader(network.NetID)
 		if errN == nil {
@@ -120,6 +127,7 @@ func sendPeers() {
 			}
 		} else {
 			logger.Log(1, "unable to retrieve leader for network ", network.NetID)
+			serverctl.SyncServerNetwork(network.NetID)
 			logger.Log(1, errN.Error())
 			continue
 		}

netclient/functions/join.go

@@ -162,12 +162,6 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string, iscomms bool) error
 	defer conn.Close()
 	wcclient = nodepb.NewNodeServiceClient(conn)
 
-	// get free port based on returned default listen port
-	node.ListenPort, err = ncutils.GetFreePort(node.ListenPort)
-	if err != nil {
-		fmt.Printf("Error retrieving port: %v", err)
-	}
-
 	// safety check. If returned node from server is local, but not currently configured as local, set to local addr
 	if cfg.Node.IsLocal != "yes" && node.IsLocal == "yes" && node.LocalRange != "" {
 		node.LocalAddress, err = ncutils.GetLocalIP(node.LocalRange)
@@ -209,12 +203,18 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string, iscomms bool) error
 	}
 	ncutils.PrintLog("node created on remote server...updating configs", 1)
 
+	// keep track of the old listenport value
+	oldListenPort := node.ListenPort
+
 	nodeData := res.Data
 	if err = json.Unmarshal([]byte(nodeData), &node); err != nil {
 		return err
 	}
 
 	cfg.Node = node
+
+	setListenPort(oldListenPort, &cfg)
+
 	err = config.ModConfig(&node)
 	if err != nil {
 		return err
@@ -281,3 +281,25 @@ func formatName(node models.Node) string {
 	}
 	return node.Name
 }
+
+func setListenPort(oldListenPort int32, cfg *config.ClientConfig) {
+	// keep track of the returned listenport value
+	newListenPort := cfg.Node.ListenPort
+
+	if newListenPort != oldListenPort {
+		var errN error
+		// get free port based on returned default listen port
+		cfg.Node.ListenPort, errN = ncutils.GetFreePort(cfg.Node.ListenPort)
+		if errN != nil {
+			cfg.Node.ListenPort = newListenPort
+			ncutils.PrintLog("Error retrieving port: "+errN.Error(), 1)
+		}
+
+		// if newListenPort has been modified to find an available port, publish to server
+		if cfg.Node.ListenPort != newListenPort {
+			var currentCommsCfg = getCommsCfgByNode(&cfg.Node)
+			log.Println("DELETE ME: publishing update of port: " + string(cfg.Node.ListenPort))
+			PublishNodeUpdate(&currentCommsCfg, cfg)
+		}
+	}
+}

netclient/ncutils/netclientutils.go

@@ -21,7 +21,6 @@ import (
 	"time"
 
 	"github.com/gravitl/netmaker/models"
-	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -286,33 +285,20 @@ func GetNetworkIPMask(networkstring string) (string, string, error) {
 
 // GetFreePort - gets free port of machine
 func GetFreePort(rangestart int32) (int32, error) {
+	addr := net.UDPAddr{}
 	if rangestart == 0 {
 		rangestart = NETCLIENT_DEFAULT_PORT
 	}
-	wgclient, err := wgctrl.New()
-	if err != nil {
-		return 0, err
-	}
-	defer wgclient.Close()
-	devices, err := wgclient.Devices()
-	if err != nil {
-		return 0, err
-	}
-
 	for x := rangestart; x <= 65535; x++ {
-		conflict := false
-		for _, i := range devices {
-			if int32(i.ListenPort) == x {
-				conflict = true
-				break
-			}
-		}
-		if conflict {
+		addr.Port = int(x)
+		conn, err := net.ListenUDP("udp", &addr)
+		if err != nil {
 			continue
 		}
-		return int32(x), nil
+		defer conn.Close()
+		return x, nil
 	}
-	return rangestart, err
+	return rangestart, errors.New("no free ports")
 }
 
 // == OS PATH FUNCTIONS ==

servercfg/serverconf.go

@@ -2,14 +2,18 @@ package servercfg
 
 import (
 	"errors"
+	"fmt"
 	"io"
+	"math/rand"
 	"net"
 	"net/http"
 	"os"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/gravitl/netmaker/config"
+	"github.com/gravitl/netmaker/logger"
 )
 
 var (
@@ -90,10 +94,9 @@ func GetServerConfig() config.ServerConfig {
 	cfg.Debug = GetDebug()
 	cfg.Telemetry = Telemetry()
 	cfg.ManageIPTables = ManageIPTables()
-	cfg.CommsCIDR = GetCommsCIDR()
 	services := strings.Join(GetPortForwardServiceList(), ",")
 	cfg.PortForwardServices = services
-	cfg.CommsID = GetCommsCIDR()
+	cfg.CommsID = GetCommsID()
 
 	return cfg
 }
@@ -258,17 +261,19 @@ func GetMQPort() string {
 
 // GetGRPCPort - gets the grpc port
 func GetCommsCIDR() string {
-	netrange := "172.242.0.0/16"
+	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.242.0.0/16"
+	return "172.16.0.0/16"
 }
 
 // GetCommsID - gets the grpc port
@@ -614,3 +619,34 @@ func GetRce() bool {
 func GetDebug() bool {
 	return os.Getenv("DEBUG") == "on" || config.Config.Server.Debug == true
 }
+
+func genNewCommsCIDR() string {
+	currIfaces, err := net.Interfaces()
+	netrange := fmt.Sprintf("172.%d.0.0/16", genCommsByte())
+	if err == nil { // make sure chosen CIDR doesn't overlap with any local iface CIDRs
+		iter := 0
+		for i := 0; i < len(currIfaces); i++ {
+			if currentAddrs, err := currIfaces[i].Addrs(); err == nil {
+				for j := range currentAddrs {
+					if strings.Contains(currentAddrs[j].String(), netrange[0:7]) {
+						if iter > 20 { // if this hits, then the cidr should be specified
+							logger.FatalLog("could not find a suitable comms network on this server, please manually enter one")
+						}
+						netrange = fmt.Sprintf("172.%d.0.0/16", genCommsByte())
+						i = -1 // reset to loop back through
+						iter++ // track how many times you've iterated and not found one
+						break
+					}
+				}
+			}
+		}
+	}
+	return netrange
+}
+
+func genCommsByte() int {
+	const min = 1 << 4 // 16
+	const max = 1 << 5 // 32
+	rand.Seed(time.Now().UnixNano())
+	return rand.Intn(max-min) + min
+}

serverctl/serverctl.go

@@ -5,6 +5,7 @@ import (
 	"net"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
@@ -29,15 +30,16 @@ 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.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)
 		return logic.CreateNetwork(network)
 	}
+	time.Sleep(time.Second << 1)
 	SyncServerNetwork(COMMS_NETID)
 
 	return nil