rough draft of server transplanting

logic/network.go

@@ -101,10 +101,7 @@ func isInterfacePresent(iface string, address string) (string, bool) {
 			continue
 		}
 		for _, addr := range currAddrs {
-			Log("looking at addresses "+addr.String()+" compared to "+address, 0)
+			if strings.Contains(addr.String(), address) && currIface.Name != iface {
-			if addr.String() == address && currIface.Name != iface {
-				Log("found it", 0)
-				// return old iface and false
 				return currIface.Name, false
 			}
 		}

logic/server.go

@@ -2,7 +2,6 @@ package logic
 
 import (
 	"errors"
-	"log"
 	"net"
 	"os"
 	"runtime"
@@ -11,32 +10,43 @@ import (
 	"time"
 
 	"github.com/gravitl/netmaker/models"
-	"github.com/gravitl/netmaker/netclient/config"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
 // == Join, Checkin, and Leave for Server ==
-func ServerJoin(cfg config.ClientConfig, privateKey string) error {
-	var err error
 
-	if cfg.Network == "" {
+// ServerJoin - responsible for joining a server to a network
+func ServerJoin(network string, serverID string, privateKey string) error {
+
+	if network == "" {
 		return errors.New("no network provided")
 	}
 
-	if cfg.Node.LocalRange != "" && cfg.Node.LocalAddress == "" {
+	var err error
-		Log("local vpn, getting local address from range: "+cfg.Node.LocalRange, 1)
+	var node *models.Node // fill this object with server node specifics
-		cfg.Node.LocalAddress = GetLocalIP(cfg.Node)
+	node = &models.Node{
+		IsServer:   "yes",
+		DNSOn:      "no",
+		IsStatic:   "yes",
+		Name:       models.NODE_SERVER_NAME,
+		MacAddress: serverID,
+	}
+	node.SetDefaults()
+
+	if node.LocalRange != "" && node.LocalAddress == "" {
+		Log("local vpn, getting local address from range: "+node.LocalRange, 1)
+		node.LocalAddress = GetLocalIP(*node)
 	}
 
-	if cfg.Node.Endpoint == "" {
+	if node.Endpoint == "" {
-		if cfg.Node.IsLocal == "yes" && cfg.Node.LocalAddress != "" {
+		if node.IsLocal == "yes" && node.LocalAddress != "" {
-			cfg.Node.Endpoint = cfg.Node.LocalAddress
+			node.Endpoint = node.LocalAddress
 		} else {
-			cfg.Node.Endpoint, err = ncutils.GetPublicIP()
+			node.Endpoint, err = ncutils.GetPublicIP()
 		}
-		if err != nil || cfg.Node.Endpoint == "" {
+		if err != nil || node.Endpoint == "" {
-			Log("Error setting cfg.Node.Endpoint.", 0)
+			Log("Error setting server node Endpoint.", 0)
 			return err
 		}
 	}
@@ -49,44 +59,32 @@ func ServerJoin(cfg config.ClientConfig, privateKey string) error {
 			return err
 		}
 		privateKey = wgPrivatekey.String()
-		cfg.Node.PublicKey = wgPrivatekey.PublicKey().String()
+		node.PublicKey = wgPrivatekey.PublicKey().String()
 	}
+	// should never set mac address for server anymore
 
-	if cfg.Node.MacAddress == "" {
-		macs, err := ncutils.GetMacAddr()
-		if err != nil {
-			return err
-		} else if len(macs) == 0 {
-			Log("could not retrieve mac address for server", 1)
-			return errors.New("failed to get server mac")
-		} else {
-			cfg.Node.MacAddress = macs[0]
-		}
-	}
-
-	var node models.Node // fill this node with appropriate calls
 	var postnode *models.Node
 	postnode = &models.Node{
-		Password:            cfg.Node.Password,
+		Password:            node.Password,
-		MacAddress:          cfg.Node.MacAddress,
+		MacAddress:          node.MacAddress,
-		AccessKey:           cfg.Server.AccessKey,
+		AccessKey:           node.AccessKey,
-		Network:             cfg.Network,
+		Network:             network,
-		ListenPort:          cfg.Node.ListenPort,
+		ListenPort:          node.ListenPort,
-		PostUp:              cfg.Node.PostUp,
+		PostUp:              node.PostUp,
-		PostDown:            cfg.Node.PostDown,
+		PostDown:            node.PostDown,
-		PersistentKeepalive: cfg.Node.PersistentKeepalive,
+		PersistentKeepalive: node.PersistentKeepalive,
-		LocalAddress:        cfg.Node.LocalAddress,
+		LocalAddress:        node.LocalAddress,
-		Interface:           cfg.Node.Interface,
+		Interface:           node.Interface,
-		PublicKey:           cfg.Node.PublicKey,
+		PublicKey:           node.PublicKey,
-		DNSOn:               cfg.Node.DNSOn,
+		DNSOn:               node.DNSOn,
-		Name:                cfg.Node.Name,
+		Name:                node.Name,
-		Endpoint:            cfg.Node.Endpoint,
+		Endpoint:            node.Endpoint,
-		SaveConfig:          cfg.Node.SaveConfig,
+		SaveConfig:          node.SaveConfig,
-		UDPHolePunch:        cfg.Node.UDPHolePunch,
+		UDPHolePunch:        node.UDPHolePunch,
 	}
 
 	Log("adding a server instance on network "+postnode.Network, 2)
-	node, err = CreateNode(*postnode, cfg.Network)
+	*node, err = CreateNode(*postnode, network)
 	if err != nil {
 		return err
 	}
@@ -102,7 +100,7 @@ func ServerJoin(cfg config.ClientConfig, privateKey string) error {
 	}
 
 	// 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 != "" {
+	if node.IsLocal == "yes" && node.LocalRange != "" {
 		node.LocalAddress, err = ncutils.GetLocalIP(node.LocalRange)
 		if err != nil {
 			return err
@@ -113,18 +111,20 @@ func ServerJoin(cfg config.ClientConfig, privateKey string) error {
 	node.SetID()
 	if err = StorePrivKey(node.ID, privateKey); err != nil {
 		return err
+	} else {
+		Log("stored private key "+privateKey, 0)
 	}
 	if err = ServerPush(node.MacAddress, node.Network); err != nil {
 		return err
 	}
 
-	peers, hasGateway, gateways, err := GetServerPeers(node.MacAddress, cfg.Network, node.IsDualStack == "yes", node.IsIngressGateway == "yes")
+	peers, hasGateway, gateways, err := GetServerPeers(node.MacAddress, network, node.IsDualStack == "yes", node.IsIngressGateway == "yes")
 	if err != nil && !ncutils.IsEmptyRecord(err) {
 		Log("failed to retrieve peers", 1)
 		return err
 	}
 
-	err = initWireguard(&node, privateKey, peers, hasGateway, gateways)
+	err = initWireguard(node, privateKey, peers, hasGateway, gateways)
 	if err != nil {
 		return err
 	}
@@ -132,19 +132,44 @@ func ServerJoin(cfg config.ClientConfig, privateKey string) error {
 	return nil
 }
 
-// ServerPull - pulls current config/peers for server
+// ServerCheckin - runs pulls and pushes for server
-func ServerPull(mac string, network string) error {
+func ServerCheckin(mac string, network string) error {
-
 	var serverNode models.Node
+	var newNode *models.Node
 	var err error
 	serverNode, err = GetNode(mac, network)
 	if err != nil {
 		return err
 	}
 
+	newNode, err = ServerPull(mac, network)
+	if isDeleteError(err) {
+		return ServerLeave(mac, network)
+	} else if err != nil {
+		return err
+	}
+
+	actionCompleted := checkNodeActions(newNode, network, &serverNode)
+	if actionCompleted == models.NODE_DELETE {
+		return errors.New("node has been removed")
+	}
+
+	return ServerPush(newNode.MacAddress, newNode.Network)
+}
+
+// ServerPull - pulls current config/peers for server
+func ServerPull(mac string, network string) (*models.Node, error) {
+
+	var serverNode models.Node
+	var err error
+	serverNode, err = GetNode(mac, network)
+	if err != nil {
+		return &serverNode, err
+	}
+
 	if serverNode.IPForwarding == "yes" {
 		if err = setIPForwardingLinux(); err != nil {
-			return err
+			return &serverNode, err
 		}
 	}
 	serverNode.OS = runtime.GOOS
@@ -159,26 +184,27 @@ func ServerPull(mac string, network string) error {
 			if err = deleteInterface(oldIfaceName, serverNode.PostDown); err != nil {
 				Log("could not delete old interface "+oldIfaceName, 1)
 			}
+			Log("removed old interface "+oldIfaceName, 1)
 		}
 		serverNode.PullChanges = "no"
 		if err = setWGConfig(serverNode, network, false); err != nil {
-			return err
+			return &serverNode, err
 		}
 		// handle server side update
 		if err = serverNode.Update(&serverNode); err != nil {
-			return err
+			return &serverNode, err
 		}
 	} else {
 		if err = setWGConfig(serverNode, network, true); err != nil {
 			if errors.Is(err, os.ErrNotExist) {
 				return ServerPull(serverNode.MacAddress, serverNode.Network)
 			} else {
-				return err
+				return &serverNode, err
 			}
 		}
 	}
 
-	return nil
+	return &serverNode, nil
 }
 
 // ServerPush - pushes config changes for server checkins/join
@@ -230,7 +256,7 @@ func GetServerPeers(macaddress string, network string, dualstack bool, isIngress
 	keepalivedur, err := time.ParseDuration(strconv.FormatInt(int64(keepalive), 10) + "s")
 	keepaliveserver, err := time.ParseDuration(strconv.FormatInt(int64(5), 10) + "s")
 	if err != nil {
-		Log("Issue with format of keepalive value. Please update netconfig: "+err.Error(), 1)
+		Log("Issue with format of keepalive value. Please view server config. "+err.Error(), 1)
 		return nil, hasGateway, gateways, err
 	}
 
@@ -281,16 +307,16 @@ func GetServerPeers(macaddress string, network string, dualstack bool, isIngress
 			for _, iprange := range ranges { // go through each cidr for egress gateway
 				_, ipnet, err := net.ParseCIDR(iprange) // confirming it's valid cidr
 				if err != nil {
-					ncutils.PrintLog("could not parse gateway IP range. Not adding "+iprange, 1)
+					Log("could not parse gateway IP range. Not adding "+iprange, 1)
 					continue // if can't parse CIDR
 				}
 				nodeEndpointArr := strings.Split(node.Endpoint, ":") // getting the public ip of node
 				if ipnet.Contains(net.ParseIP(nodeEndpointArr[0])) { // ensuring egress gateway range does not contain public ip of node
-					ncutils.PrintLog("egress IP range of "+iprange+" overlaps with "+node.Endpoint+", omitting", 2)
+					Log("egress IP range of "+iprange+" overlaps with "+node.Endpoint+", omitting", 2)
 					continue // skip adding egress range if overlaps with node's ip
 				}
 				if ipnet.Contains(net.ParseIP(nodecfg.LocalAddress)) { // ensuring egress gateway range does not contain public ip of node
-					ncutils.PrintLog("egress IP range of "+iprange+" overlaps with "+nodecfg.LocalAddress+", omitting", 2)
+					Log("egress IP range of "+iprange+" overlaps with "+nodecfg.LocalAddress+", omitting", 2)
 					continue // skip adding egress range if overlaps with node's local ip
 				}
 				gateways = append(gateways, iprange)
@@ -358,7 +384,6 @@ func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgt
 	var err error
 	// fill above fields from either client or server
 
-	// fill extPeers with server side logic
 	nodecfg, err = GetNode(macaddress, network)
 	if err != nil {
 		return nil, err
@@ -382,7 +407,6 @@ func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgt
 	for _, extPeer := range extPeers {
 		pubkey, err := wgtypes.ParseKey(extPeer.PublicKey)
 		if err != nil {
-			log.Println("error parsing key")
 			return peers, err
 		}
 
@@ -414,3 +438,28 @@ func GetServerExtPeers(macaddress string, network string, dualstack bool) ([]wgt
 	}
 	return peers, err
 }
+
+// == Private ==
+
+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) &&
+		node.IsStatic != "yes" {
+		err := setWGKeyConfig(*node)
+		if err != nil {
+			Log("unable to process reset keys request: "+err.Error(), 1)
+			return ""
+		}
+	}
+	if node.Action == models.NODE_DELETE || localNode.Action == models.NODE_DELETE {
+		err := ServerLeave(node.MacAddress, networkName)
+		if err != nil {
+			Log("error deleting locally: "+err.Error(), 1)
+		}
+		return models.NODE_DELETE
+	}
+	return ""
+}

logic/serverconf.go

@@ -1,16 +1,49 @@
 package logic
 
-import "github.com/gravitl/netmaker/database"
+import (
+	"encoding/json"
+	"log"
+
+	"github.com/gravitl/netmaker/database"
+)
+
+type serverData struct {
+	PrivateKey string `json:"privatekey,omitempty" bson:"privatekey,omitempty"`
+}
 
 // StorePrivKey - stores server client WireGuard privatekey if needed
 func StorePrivKey(serverID string, privateKey string) error {
-	return database.Insert(serverID, privateKey, database.SERVERCONF_TABLE_NAME)
+	var newData *serverData
+	newData = &serverData{}
+	var err error
+	var data []byte
+	newData.PrivateKey = privateKey
+	data, err = json.Marshal(newData)
+	if err != nil {
+		return err
+	}
+	return database.Insert(serverID, string(data), database.SERVERCONF_TABLE_NAME)
 }
 
+// FetchPrivKey - fetches private key
 func FetchPrivKey(serverID string) (string, error) {
-	return database.FetchRecord(database.SERVERCONF_TABLE_NAME, serverID)
+	var dbData string
+	var err error
+	var fetchedData serverData
+	fetchedData = serverData{}
+	dbData, err = database.FetchRecord(database.SERVERCONF_TABLE_NAME, serverID)
+	if err != nil {
+		return "", err
+	}
+	err = json.Unmarshal([]byte(dbData), &fetchedData)
+	if err != nil {
+		return "", err
+	}
+	log.Println(fetchedData)
+	return fetchedData.PrivateKey, nil
 }
 
+// RemovePrivKey - removes a private key
 func RemovePrivKey(serverID string) error {
 	return database.DeleteRecord(database.SERVERCONF_TABLE_NAME, serverID)
 }

logic/util.go

@@ -64,7 +64,7 @@ func DeleteNode(key string, exterminate bool) error {
 		}
 	} else {
 		if err := database.DeleteRecord(database.DELETED_NODES_TABLE_NAME, key); err != nil {
-			functions.PrintUserLog("", err.Error(), 2)
+			Log(err.Error(), 2)
 		}
 	}
 	if err := database.DeleteRecord(database.NODES_TABLE_NAME, key); err != nil {
@@ -189,19 +189,19 @@ func GetNodePeers(networkName string, excludeRelayed bool) ([]models.Node, error
 		if database.IsEmptyRecord(err) {
 			return peers, nil
 		}
-		functions.PrintUserLog("", err.Error(), 2)
+		Log(err.Error(), 2)
 		return nil, err
 	}
 	udppeers, errN := database.GetPeers(networkName)
 	if errN != nil {
-		functions.PrintUserLog("", errN.Error(), 2)
+		Log(errN.Error(), 2)
 	}
 	for _, value := range collection {
 		var node models.Node
 		var peer models.Node
 		err := json.Unmarshal([]byte(value), &node)
 		if err != nil {
-			functions.PrintUserLog("", err.Error(), 2)
+			Log(err.Error(), 2)
 			continue
 		}
 		if node.IsEgressGateway == "yes" { // handle egress stuff

logic/wireguard.go

@@ -37,6 +37,16 @@ func GetSystemPeers(node *models.Node) (map[string]string, error) {
 	return peers, nil
 }
 
+// RemoveConf - removes a configuration for a given WireGuard interface
+func RemoveConf(iface string, printlog bool) error {
+	var err error
+	confPath := ncutils.GetNetclientPathSpecific() + iface + ".conf"
+	err = removeWGQuickConf(confPath, printlog)
+	return err
+}
+
+// == Private Methods ==
+
 func setWGConfig(node models.Node, network string, peerupdate bool) error {
 
 	node.SetID()
@@ -55,6 +65,7 @@ func setWGConfig(node models.Node, network string, peerupdate bool) error {
 	} else {
 		err = initWireguard(&node, privkey, peers, hasGateway, gateways)
 	}
+	Log("finished setting wg config on server "+node.Name, 1)
 	return err
 }
 
@@ -82,6 +93,7 @@ func initWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
 	}
 
 	if ncutils.IsKernel() {
+		Log("setting kernel device "+ifacename, 2)
 		setKernelDevice(ifacename, node.Address)
 	}
 
@@ -102,10 +114,10 @@ func initWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
 			newConf, _ = ncutils.CreateUserSpaceConf(node.Address, key.String(), "", node.MTU, node.PersistentKeepalive, peers)
 		}
 		confPath := ncutils.GetNetclientPathSpecific() + ifacename + ".conf"
-		ncutils.PrintLog("writing wg conf file to: "+confPath, 1)
+		Log("writing wg conf file to: "+confPath, 1)
 		err = ioutil.WriteFile(confPath, []byte(newConf), 0644)
 		if err != nil {
-			ncutils.PrintLog("error writing wg conf file to "+confPath+": "+err.Error(), 1)
+			Log("error writing wg conf file to "+confPath+": "+err.Error(), 1)
 			return err
 		}
 		// spin up userspace + apply the conf file
@@ -181,16 +193,6 @@ func initWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
 	return err
 }
 
-// RemoveConf - removes a configuration for a given WireGuard interface
-func RemoveConf(iface string, printlog bool) error {
-	var err error
-	confPath := ncutils.GetNetclientPathSpecific() + iface + ".conf"
-	err = removeWGQuickConf(confPath, printlog)
-	return err
-}
-
-// == Private Methods ==
-
 func setKernelDevice(ifacename string, address string) error {
 	ipExec, err := exec.LookPath("ip")
 	if err != nil {
@@ -199,7 +201,7 @@ func setKernelDevice(ifacename string, address string) error {
 
 	_, _ = ncutils.RunCmd("ip link delete dev "+ifacename, false)
 	_, _ = ncutils.RunCmd(ipExec+" link add dev "+ifacename+" type wireguard", true)
-	_, _ = ncutils.RunCmd(ipExec+" address add dev "+ifacename+" "+address+"/24", true)
+	_, _ = ncutils.RunCmd(ipExec+" address add dev "+ifacename+" "+address+"/24", true) // this is a bug waiting to happen
 
 	return nil
 }
@@ -291,3 +293,26 @@ func setServerPeers(iface string, keepalive int32, peers []wgtypes.PeerConfig) e
 
 	return nil
 }
+
+func setWGKeyConfig(node models.Node) error {
+
+	node.SetID()
+	privatekey, err := wgtypes.GeneratePrivateKey()
+	if err != nil {
+		return err
+	}
+	privkeystring := privatekey.String()
+	publickey := privatekey.PublicKey()
+
+	node.PublicKey = publickey.String()
+
+	err = StorePrivKey(node.ID, privkeystring)
+	if err != nil {
+		return err
+	}
+	if node.Action == models.NODE_UPDATE_KEY {
+		node.Action = models.NODE_NOOP
+	}
+
+	return setWGConfig(node, node.Network, false)
+}

netclient/main.go

@@ -24,7 +24,7 @@ func main() {
 	app := cli.NewApp()
 	app.Name = "Netclient CLI"
 	app.Usage = "Netmaker's netclient agent and CLI. Used to perform interactions with Netmaker server and set local WireGuard config."
-	app.Version = "v0.8.3"
+	app.Version = "v0.8.4"
 
 	cliFlags := []cli.Flag{
 		&cli.StringFlag{

servercfg/serverconf.go

@@ -3,10 +3,11 @@ package servercfg
 import (
 	"errors"
 	"io/ioutil"
-	"net/http"
 	"net"
+	"net/http"
 	"os"
 	"strconv"
+
 	"github.com/gravitl/netmaker/config"
 )
 
@@ -75,7 +76,7 @@ func GetAPIConnString() string {
 	return conn
 }
 func GetVersion() string {
-	version := "0.8.3"
+	version := "0.8.4"
 	if config.Config.Server.Version != "" {
 		version = config.Config.Server.Version
 	}
@@ -399,4 +400,4 @@ func getMacAddr() string {
 		}
 	}
 	return as[0]
-}
+}

serverctl/serverctl.go

@@ -6,12 +6,11 @@ import (
 	"io"
 	"log"
 	"os"
+	"strings"
 
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logic"
 	"github.com/gravitl/netmaker/models"
-	nccommand "github.com/gravitl/netmaker/netclient/command"
-	"github.com/gravitl/netmaker/netclient/config"
 	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/servercfg"
 )
@@ -65,7 +64,7 @@ func copy(src, dst string) (int64, error) {
 	nBytes, err := io.Copy(destination, source)
 	err = os.Chmod(dst, 0755)
 	if err != nil {
-		log.Println(err)
+		logic.Log(err.Error(), 1)
 	}
 	return nBytes, err
 }
@@ -83,7 +82,7 @@ func InitServerNetclient() error {
 	if os.IsNotExist(err) {
 		os.MkdirAll(netclientDir+"/config", 744)
 	} else if err != nil {
-		log.Println("[netmaker] could not find or create", netclientDir)
+		logic.Log("[netmaker] could not find or create "+netclientDir, 1)
 		return err
 	}
 	return nil
@@ -101,16 +100,12 @@ func HandleContainedClient() error {
 		}
 		log.SetFlags(log.Flags() &^ (log.Llongfile | log.Lshortfile))
 		err := SyncNetworks(servernets)
-		if err != nil && servercfg.GetVerbose() >= 1 {
+		logic.Log("error syncing networks: "+err.Error(), 1)
-			log.Printf("[netmaker] error syncing networks %s \n", err)
+		for _, serverNet := range servernets {
-		}
+			err = logic.ServerCheckin(servercfg.GetNodeID(), serverNet.NetID)
-		err = nccommand.CheckIn(config.ClientConfig{Network: "all"})
+			logic.Log("error occurred during server checkin: "+err.Error(), 1)
-		if err != nil && servercfg.GetVerbose() >= 1 {
-			log.Printf("[netmaker] error occurred %s \n", err)
-		}
-		if servercfg.GetVerbose() >= 3 {
-			log.Println("[netmaker]", "completed a checkin call")
 		}
+		logic.Log("completed a checkin call", 3)
 	}
 	return nil
 }
@@ -137,7 +132,9 @@ func SyncNetworks(servernets []models.Network) error {
 					err = errors.New("network add failed for " + servernet.NetID)
 				}
 				if servercfg.GetVerbose() >= 1 {
-					log.Printf("[netmaker] error adding network %s during sync %s \n", servernet.NetID, err)
+					if !strings.Contains(err.Error(), "macaddress_unique") { // ignore macaddress unique error throws
+						log.Printf("[netmaker] error adding network %s during sync %s \n", servernet.NetID, err)
+					}
 				}
 			}
 		}
@@ -156,7 +153,9 @@ func SyncNetworks(servernets []models.Network) error {
 				if err == nil {
 					err = errors.New("network delete failed for " + localnet)
 				}
-				log.Printf("[netmaker] error removing network %s during sync %s \n", localnet, err)
+				if servercfg.GetVerbose() >= 1 {
+					log.Printf("[netmaker] error removing network %s during sync %s \n", localnet, err)
+				}
 			}
 		}
 	}
@@ -165,17 +164,7 @@ func SyncNetworks(servernets []models.Network) error {
 
 // AddNetwork - add a network to server in client mode
 func AddNetwork(network string) (bool, error) {
-	err := logic.ServerJoin(config.ClientConfig{
+	err := logic.ServerJoin(network, servercfg.GetNodeID(), "")
-		Network: network,
+	logic.Log("server added to network "+network, 2)
-		Daemon:  "off",
-		Node: models.Node{
-			Network:    network,
-			IsServer:   "yes",
-			DNSOn:      "no",
-			Name:       models.NODE_SERVER_NAME,
-			MacAddress: servercfg.GetNodeID(),
-		},
-	}, "")
-	log.Println("[netmaker] Server added to network " + network)
 	return true, err
 }