gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-09-08 14:15:25 +08:00
Code Issues Projects Releases Packages Wiki Activity

manual rebase to develop

Browse source
This commit is contained in:
Matthew R Kasun 2022-01-25 07:31:50 -05:00
parent 77b765c8fd
commit bc54bbf167
18 changed files with 208 additions and 399 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -15,6 +15,6 @@ netclient/netclient32
netclient/netclient.exe
config/dnsconfig/
data/
.idea/
.vscode/
.idea/

2
compose/docker-compose.contained.yml
View file

@ -3,7 +3,7 @@ version: "3.4"
services:
netmaker:
container_name: netmaker
image: gravitl/netmaker:v0.9.3
image: gravitl/netmaker:v0.10.0
volumes:
- dnsconfig:/root/config/dnsconfig
- /usr/bin/wg:/usr/bin/wg

3
controllers/auth_grpc.go
View file

@ -82,7 +82,6 @@ func grpcAuthorize(ctx context.Context) error {
if err != nil {
return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: "+network)
}
emptynode := models.Node{}
node, err := logic.GetNodeByIDorMacAddress(nodeID, mac, network)
if database.IsEmptyRecord(err) {
// == DELETE replace logic after 2 major version updates ==
@ -94,7 +93,7 @@ func grpcAuthorize(ctx context.Context) error {
}
return status.Errorf(codes.Unauthenticated, "Empty record")
}
if err != nil || node.MacAddress == emptynode.MacAddress {
if err != nil || node.ID == "" {
return status.Errorf(codes.Unauthenticated, "Node does not exist.")
}

27
controllers/node.go
View file

@ -405,6 +405,11 @@ func createNode(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
if err = runServerPeerUpdate(node.Network, true); err != nil {
logger.Log(1, "internal error when creating node:", node.ID)
}
logger.Log(1, r.Header.Get("user"), "created new node", node.Name, "on network", node.Network)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
@ -415,11 +420,15 @@ func createNode(w http.ResponseWriter, r *http.Request) {
func uncordonNode(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
w.Header().Set("Content-Type", "application/json")
node, err := logic.UncordonNode(params["nodeid"])
var nodeid = params["nodeid"]
node, err := logic.UncordonNode(nodeid)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
if err = runServerPeerUpdate(node.Network, false); err != nil {
logger.Log(1, "internal error when approving node:", nodeid)
}
go func() {
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
@ -450,6 +459,9 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
if err = runServerPeerUpdate(gateway.NetID, true); err != nil {
logger.Log(1, "internal error when setting peers after creating egress on node:", gateway.NodeID)
}
go func() {
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
@ -474,6 +486,9 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
if err = runServerPeerUpdate(netid, true); err != nil {
logger.Log(1, "internal error when setting peers after removing egress on node:", nodeid)
}
go func() {
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
@ -576,6 +591,8 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
newNode.PostUp = node.PostUp
}
var shouldPeersUpdate = logic.ShouldPeersUpdate(&node, &newNode)
err = logic.UpdateNode(&node, &newNode)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
@ -591,6 +608,8 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
if servercfg.IsDNSMode() {
err = logic.SetDNS()
}
err = runServerPeerUpdate(node.Network, shouldPeersUpdate)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@ -627,6 +646,12 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
err = runServerPeerUpdate(node.Network, true)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
node.Action = models.NODE_DELETE
go func() {
if err := mq.NodeUpdate(&node); err != nil {

33
controllers/node_grpc.go
View file

@ -86,10 +86,17 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.Object)
if err != nil {
return nil, err
}
// notify other nodes on network of new peer
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(0, "failed to inform peers of new node "+err.Error())
err = runServerPeerUpdate(node.Network, true)
if err != nil {
logger.Log(1, "internal error when setting peers after node,", node.ID, "was created (gRPC)")
}
logger.Log(0, "new node,", node.Name, ", added on network,"+node.Network)
// notify other nodes on network of new peer
go func() {
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(0, "failed to inform peers of new node "+err.Error())
}
}()
return response, nil
}
@ -111,6 +118,7 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
newnode.PostDown = node.PostDown
newnode.PostUp = node.PostUp
}
var shouldPeersUpdate = logic.ShouldPeersUpdate(&node, &newnode)
err = logic.UpdateNode(&node, &newnode)
if err != nil {
@ -124,6 +132,10 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
if errN != nil {
return nil, err
}
err = runServerPeerUpdate(newnode.Network, shouldPeersUpdate)
if err != nil {
logger.Log(1, "could not update peers on gRPC after node,", newnode.ID, "updated (gRPC), \nerror:", err.Error())
}
return &nodepb.Object{
Data: string(nodeData),
Type: nodepb.NODE_TYPE,
@ -142,10 +154,16 @@ func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object)
if err != nil {
return nil, err
}
// notify other nodes on network of deleted peer
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(0, "failed to inform peers of deleted node "+err.Error())
err = runServerPeerUpdate(node.Network, true)
if err != nil {
logger.Log(1, "internal error when setting peers after deleting node:", node.ID, "over gRPC")
}
// notify other nodes on network of deleted peer
go func() {
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(0, "failed to inform peers of deleted node "+err.Error())
}
}()
return &nodepb.Object{
Data: "success",
@ -161,9 +179,6 @@ func (s *NodeServiceServer) GetPeers(ctx context.Context, req *nodepb.Object) (*
return nil, err
}
//if node.IsServer == "yes" && logic.IsLeader(&node) {
// logic.setNetworkServerPeers(&node)
//}
excludeIsRelayed := node.IsRelay != "yes"
var relayedNode string
if node.IsRelayed == "yes" {

34
controllers/relay.go
View file

@ -27,13 +27,18 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
}
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(1, "error publishing peer update "+err.Error())
return
if err = runServerPeerUpdate(relay.NetID, true); err != nil {
logger.Log(1, "internal error when creating relay on node:", relay.NodeID)
}
go func() {
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
}
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(1, "error publishing peer update "+err.Error())
return
}
}()
logger.Log(1, r.Header.Get("user"), "created relay on node", relay.NodeID, "on network", relay.NetID)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
@ -49,13 +54,18 @@ func deleteRelay(w http.ResponseWriter, r *http.Request) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
}
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(1, "error publishing peer update "+err.Error())
return
if err = runServerPeerUpdate(netid, true); err != nil {
logger.Log(1, "internal error when deleting relay on node:", nodeid)
}
go func() {
if err := mq.NodeUpdate(&node); err != nil {
logger.Log(1, "error publishing node update"+err.Error())
}
if err := mq.UpdatePeers(&node); err != nil {
logger.Log(1, "error publishing peer update "+err.Error())
return
}
}()
logger.Log(1, r.Header.Get("user"), "deleted relay server", nodeid, "on network", netid)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)

33
controllers/server_util.go Normal file
View file

@ -0,0 +1,33 @@
package controller
import (
"github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/servercfg"
"github.com/gravitl/netmaker/serverctl"
)
func runServerPeerUpdate(network string, shouldPeerUpdate bool) error {
if servercfg.Telemetry() == "on" {
err := serverctl.TelemetryCheckpoint()
if err != nil {
logger.Log(1, "failed to send telemetry:", err.Error())
}
}
if servercfg.IsClientMode() != "on" {
return nil
}
var currentServerNodeID, err = logic.GetNetworkServerNodeID(network)
if err != nil {
return err
}
var currentServerNode, currErr = logic.GetNodeByID(currentServerNodeID)
if currErr != nil {
return currErr
}
if err = logic.ServerUpdate(&currentServerNode, shouldPeerUpdate); err != nil {
logger.Log(1, "server node:", currentServerNode.ID, "failed update")
return err
}
return nil
}

149
logic/server.go
View file

@ -119,7 +119,7 @@ func ServerJoin(networkSettings *models.Network) error {
if err = StorePrivKey(node.ID, privateKey); err != nil {
return err
}
if err = ServerPush(node); err != nil {
if err = serverPush(node); err != nil {
return err
}
@ -137,18 +137,12 @@ func ServerJoin(networkSettings *models.Network) error {
return nil
}
// ServerCheckin - runs pulls and pushes for server
func ServerCheckin(serverID string, mac string, network string) error {
var serverNode = &models.Node{}
var currentNode, err = GetNodeByIDorMacAddress(serverID, mac, network)
if err != nil {
return err
}
serverNode = &currentNode
err = ServerPull(serverNode, false)
// ServerUpdate - updates the server
// replaces legacy Checkin code
func ServerUpdate(serverNode *models.Node, shouldPeerUpdate bool) error {
var err = serverPull(serverNode, shouldPeerUpdate)
if isDeleteError(err) {
return ServerLeave(currentNode.ID)
return DeleteNodeByID(serverNode, true)
} else if err != nil {
return err
}
@ -158,66 +152,7 @@ func ServerCheckin(serverID string, mac string, network string) error {
return errors.New("node has been removed")
}
return ServerPush(serverNode)
}
// ServerPull - pulls current config/peers for server
func ServerPull(serverNode *models.Node, onErr bool) error {
var err error
if serverNode.IPForwarding == "yes" {
if err = setIPForwardingLinux(); err != nil {
return err
}
}
serverNode.OS = runtime.GOOS
if serverNode.PullChanges == "yes" || onErr {
// check for interface change
// checks if address is in use by another interface
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)
}
logger.Log(1, "removed old interface", oldIfaceName)
}
serverNode.PullChanges = "no"
if err = setWGConfig(serverNode, false); err != nil {
return err
}
// handle server side update
if err = UpdateNode(serverNode, serverNode); err != nil {
return err
}
} else {
if err = setWGConfig(serverNode, true); err != nil {
if errors.Is(err, os.ErrNotExist) {
return ServerPull(serverNode, true)
} else {
return err
}
}
}
return nil
}
// ServerPush - pushes config changes for server checkins/join
func ServerPush(serverNode *models.Node) error {
serverNode.OS = runtime.GOOS
serverNode.SetLastCheckIn()
return UpdateNode(serverNode, serverNode)
}
// ServerLeave - removes a server node
func ServerLeave(serverID string) error {
var serverNode, err = GetNodeByID(serverID)
if err != nil {
return err
}
return DeleteNodeByID(&serverNode, true)
return serverPush(serverNode)
}
/**
@ -231,17 +166,14 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
var gateways []string
var peers []wgtypes.PeerConfig
var nodes []models.Node // fill above fields from server or client
var err error
var nodecfg, err = GetNodeByIDorMacAddress(serverNode.ID, serverNode.MacAddress, serverNode.Network)
if err != nil {
return nil, hasGateway, gateways, err
}
nodes, err = GetPeers(&nodecfg)
nodes, err = GetPeers(serverNode)
if err != nil {
return nil, hasGateway, gateways, err
}
keepalive := nodecfg.PersistentKeepalive
keepalive := serverNode.PersistentKeepalive
keepalivedur, err := time.ParseDuration(strconv.FormatInt(int64(keepalive), 10) + "s")
if err != nil {
logger.Log(1, "Issue with format of keepalive duration value, Please view server config:", err.Error())
@ -255,11 +187,11 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
return peers, hasGateway, gateways, err
}
if nodecfg.PublicKey == node.PublicKey {
if serverNode.PublicKey == node.PublicKey {
continue
}
if nodecfg.Endpoint == node.Endpoint {
if nodecfg.LocalAddress != node.LocalAddress && node.LocalAddress != "" {
if serverNode.Endpoint == node.Endpoint {
if serverNode.LocalAddress != node.LocalAddress && node.LocalAddress != "" {
node.Endpoint = node.LocalAddress
} else {
continue
@ -304,8 +236,8 @@ func GetServerPeers(serverNode *models.Node) ([]wgtypes.PeerConfig, bool, []stri
logger.Log(2, "egress IP range of", iprange, "overlaps with", node.Endpoint, ", omitting")
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
logger.Log(2, "egress IP range of", iprange, "overlaps with", nodecfg.LocalAddress, ", omitting")
if ipnet.Contains(net.ParseIP(serverNode.LocalAddress)) { // ensuring egress gateway range does not contain public ip of node
logger.Log(2, "egress IP range of", iprange, "overlaps with", serverNode.LocalAddress, ", omitting")
continue // skip adding egress range if overlaps with node's local ip
}
gateways = append(gateways, iprange)
@ -422,7 +354,7 @@ func checkNodeActions(node *models.Node) string {
}
}
if node.Action == models.NODE_DELETE {
err := ServerLeave(node.ID)
err := DeleteNodeByID(node, true)
if err != nil {
logger.Log(1, "error deleting locally:", err.Error())
}
@ -431,6 +363,49 @@ func checkNodeActions(node *models.Node) string {
return ""
}
// == Private ==
func serverPull(serverNode *models.Node, onErr bool) error {
var err error
if serverNode.IPForwarding == "yes" {
if err = setIPForwardingLinux(); err != nil {
return err
}
}
serverNode.OS = runtime.GOOS
if serverNode.PullChanges == "yes" || onErr {
// check for interface change
// checks if address is in use by another interface
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)
}
logger.Log(1, "removed old interface", oldIfaceName)
}
serverNode.PullChanges = "no"
if err = setWGConfig(serverNode, false); err != nil {
return err
}
// handle server side update
if err = UpdateNode(serverNode, serverNode); err != nil {
return err
}
} else {
if err = setWGConfig(serverNode, true); err != nil {
if errors.Is(err, os.ErrNotExist) {
return serverPull(serverNode, true)
} else {
return err
}
}
}
return nil
}
func getServerLocalIP(networkSettings *models.Network) (string, error) {
var networkCIDR = networkSettings.LocalRange
@ -452,3 +427,9 @@ func getServerLocalIP(networkSettings *models.Network) (string, error) {
}
return "", errors.New("could not find a local ip for server")
}
func serverPush(serverNode *models.Node) error {
serverNode.OS = runtime.GOOS
serverNode.SetLastCheckIn()
return UpdateNode(serverNode, serverNode)
}

9
logic/wireguard.go
View file

@ -85,15 +85,6 @@ func initWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
}
if !ncutils.IsKernel() {
//var newConf string
//newConf, _ = ncutils.CreateWireGuardConf(node, key.String(), strconv.FormatInt(int64(node.ListenPort), 10), peers)
//confPath := ncutils.GetNetclientPathSpecific() + ifacename + ".conf"
//logger.Log(1, "writing wg conf file to:", confPath)
//err = os.WriteFile(confPath, []byte(newConf), 0644)
//if err != nil {
//logger.Log(1, "error writing wg conf file to", confPath, ":", err.Error())
//return err
//}
if err := wireguard.WriteWgConfig(node, key.String(), peers); err != nil {
logger.Log(1, "error writing wg conf file: ", err.Error())
return err

17
main.go
View file

@ -10,7 +10,6 @@ import (
"strconv"
"sync"
"syscall"
"time"
mqtt "github.com/eclipse/paho.mqtt.golang"
"github.com/gravitl/netmaker/auth"
@ -123,25 +122,9 @@ func startControllers() {
logger.Log(0, "No Server Mode selected, so nothing is being served! Set Agent mode (AGENT_BACKEND) or Rest mode (REST_BACKEND) or MessageQueue (MESSAGEQUEUE_BACKEND) to 'true'.")
}
if servercfg.IsClientMode() == "on" {
var checkintime = time.Duration(servercfg.GetServerCheckinInterval()) * time.Second
for { // best effort currently
var serverGroup sync.WaitGroup
serverGroup.Add(1)
go runClient(&serverGroup)
serverGroup.Wait()
time.Sleep(checkintime)
}
}
waitnetwork.Wait()
}
func runClient(wg *sync.WaitGroup) {
defer wg.Done()
go serverctl.HandleContainedClient()
}
func runGRPC(wg *sync.WaitGroup) {
defer wg.Done()

5
netclient/daemon/macos.go
View file

@ -11,6 +11,7 @@ import (
const MAC_SERVICE_NAME = "com.gravitl.netclient"
// SetupMacDaemon - Creates a daemon service from the netclient under LaunchAgents for MacOS
func SetupMacDaemon(interval string) error {
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
@ -39,6 +40,7 @@ func SetupMacDaemon(interval string) error {
return err
}
// CleanupMac - Removes the netclient checkin daemon from LaunchDaemons
func CleanupMac() {
_, err := ncutils.RunCmd("launchctl unload /Library/LaunchDaemons/"+MAC_SERVICE_NAME+".plist", true)
if ncutils.FileExists("/Library/LaunchDaemons/" + MAC_SERVICE_NAME + ".plist") {
@ -52,6 +54,7 @@ func CleanupMac() {
os.Remove("/sbin/netclient")
}
// CreateMacService - Creates the mac service file for LaunchDaemons
func CreateMacService(servicename string, interval string) error {
_, err := os.Stat("/Library/LaunchDaemons")
if os.IsNotExist(err) {
@ -69,6 +72,7 @@ func CreateMacService(servicename string, interval string) error {
return err
}
// MacDaemonString - the file contents for the mac netclient daemon service (launchdaemon)
func MacDaemonString(interval string) string {
return fmt.Sprintf(`<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\" >
@ -95,6 +99,7 @@ func MacDaemonString(interval string) string {
`, interval)
}
// MacTemplateData - struct to represent the mac service
type MacTemplateData struct {
Label string
Interval string

30
netclient/ncutils/netclientutils_darwin.go
View file

@ -29,32 +29,4 @@ func GetEmbedded() error {
return nil
}
// CreateWireGuardConf - creates a WireGuard conf string
//func CreateWireGuardConf(node *models.Node, privatekey string, listenPort string, peers []wgtypes.PeerConfig) (string, error) {
// peersString, err := parsePeers(node.PersistentKeepalive, peers)
// var listenPortString string
// if node.MTU <= 0 {
// node.MTU = 1280
// }
// if listenPort != "" {
// listenPortString += "ListenPort = " + listenPort
// }
// if err != nil {
// return "", err
// }
// config := fmt.Sprintf(`[Interface]
//Address = %s
//PrivateKey = %s
//MTU = %s
//%s
//
//%s
//
//`,
// node.Address+"/32",
// privatekey,
// strconv.Itoa(int(node.MTU)),
// listenPortString,
// peersString)
// return config, nil
//}

30
netclient/ncutils/netclientutils_freebsd.go
View file

@ -38,32 +38,4 @@ func RunCmd(command string, printerr bool) (string, error) {
return string(out), err
}
// CreateWireGuardConf - creates a WireGuard conf string
//func CreateWireGuardConf(node *models.Node, privatekey string, listenPort string, peers []wgtypes.PeerConfig) (string, error) {
// peersString, err := parsePeers(node.PersistentKeepalive, peers)
// var listenPortString string
// if node.MTU <= 0 {
// node.MTU = 1280
// }
// if listenPort != "" {
// listenPortString += "ListenPort = " + listenPort
// }
// if err != nil {
// return "", err
// }
// config := fmt.Sprintf(`[Interface]
//Address = %s
//PrivateKey = %s
//MTU = %s
//%s
//
//%s
//
//`,
// node.Address+"/32",
// privatekey,
// strconv.Itoa(int(node.MTU)),
// listenPortString,
// peersString)
// return config, nil
//}

42
netclient/ncutils/netclientutils_linux.go
View file

@ -29,44 +29,4 @@ func GetEmbedded() error {
return nil
}
// CreateWireGuardConf - creates a user space WireGuard conf
//func CreateWireGuardConf(node *models.Node, privatekey string, listenPort string, peers []wgtypes.PeerConfig) (string, error) {
// peersString, err := parsePeers(node.PersistentKeepalive, peers)
// var listenPortString, postDownString, postUpString string
// if node.MTU <= 0 {
// node.MTU = 1280
// }
// if node.PostDown != "" {
// postDownString = fmt.Sprintf("PostDown = %s", node.PostDown)
// }
// if node.PostUp != "" {
// postUpString = fmt.Sprintf("PostUp = %s", node.PostUp)
// }
//
// if listenPort != "" {
// listenPortString = fmt.Sprintf("ListenPort = %s", listenPort)
// }
//
// if err != nil {
// return "", err
// }
// config := fmt.Sprintf(`[Interface]
//Address = %s
//PrivateKey = %s
//MTU = %s
//%s
//%s
//%s
//
//%s
//
//`,
// node.Address+"/32",
// privatekey,
// strconv.Itoa(int(node.MTU)),
// postDownString,
// postUpString,
// listenPortString,
// peersString)
// return config, nil
//}

30
netclient/ncutils/netclientutils_windows.go
View file

@ -44,36 +44,6 @@ func RunCmdFormatted(command string, printerr bool) (string, error) {
return string(out), err
}
// CreateWireGuardConf - creates a WireGuard conf string
//func CreateWireGuardConf(node *models.Node, privatekey string, listenPort string, peers []wgtypes.PeerConfig) (string, error) {
// peersString, err := parsePeers(node.PersistentKeepalive, peers)
// var listenPortString string
// if node.MTU <= 0 {
// node.MTU = 1280
// }
// if listenPort != "" {
// listenPortString += "ListenPort = " + listenPort
// }
// if err != nil {
// return "", err
// }
// config := fmt.Sprintf(`[Interface]
//Address = %s
//PrivateKey = %s
//MTU = %s
//%s
//
//%s
//
//`,
// node.Address+"/32",
// privatekey,
// strconv.Itoa(int(node.MTU)),
// listenPortString,
// peersString)
// return config, nil
//}
//
// GetEmbedded - Gets the Windows daemon creator
func GetEmbedded() error {
data, err := winswContent.ReadFile("windowsdaemon/winsw.exe")

23
netclient/wireguard/common.go
View file

@ -151,29 +151,8 @@ func InitWireguard(node *models.Node, privkey string, peers []wgtypes.PeerConfig
return err
}
//var newConf string
//if node.UDPHolePunch != "yes" {
// newConf, _ = ncutils.CreateWireGuardConf(node, key.String(), strconv.FormatInt(int64(node.ListenPort), 10), peers)
//} else {
// newConf, _ = ncutils.CreateWireGuardConf(node, key.String(), "", peers)
//}
//confPath := ncutils.GetNetclientPathSpecific() + ifacename + ".conf"
//ncutils.PrintLog("writing wg conf file to: "+confPath, 1)
//err = os.WriteFile(confPath, []byte(newConf), 0644)
//if err != nil {
// ncutils.PrintLog("error writing wg conf file to "+confPath+": "+err.Error(), 1)
// return err
//}
//if ncutils.IsWindows() {
confPath := ncutils.GetNetclientPathSpecific() + ifacename + ".conf"
// err = os.WriteFile(wgConfPath, []byte(newConf), 0644)
// if err != nil {
// ncutils.PrintLog("error writing wg conf file to "+wgConfPath+": "+err.Error(), 1)
// return err
// }
// confPath = wgConfPath
//}
// spin up userspace / windows interface + apply the conf file
confPath := ncutils.GetNetclientPathSpecific() + ifacename + ".conf"
var deviceiface string
if ncutils.IsMac() {
deviceiface, err = local.GetMacIface(node.Address)

19
servercfg/serverconf.go
View file

@ -339,20 +339,11 @@ func IsMessageQueueBackend() bool {
// IsClientMode - checks if it should run in client mode
func IsClientMode() string {
isclient := "on"
if os.Getenv("CLIENT_MODE") != "" {
if os.Getenv("CLIENT_MODE") == "off" {
isclient = "off"
}
if os.Getenv("CLIENT_MODE") == "contained" {
isclient = "contained"
}
} else if config.Config.Server.ClientMode != "" {
if config.Config.Server.ClientMode == "off" {
isclient = "off"
}
if config.Config.Server.ClientMode == "contained" {
isclient = "contained"
}
if os.Getenv("CLIENT_MODE") == "off" {
isclient = "off"
}
if config.Config.Server.ClientMode == "off" {
isclient = "off"
}
return isclient
}

119
serverctl/serverctl.go
View file

@ -1,51 +1,17 @@
package serverctl
import (
"encoding/json"
"errors"
"net"
"os"
"strings"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/servercfg"
)
// GetServerWGConf - gets the server WG configuration
func GetServerWGConf() (models.IntClient, error) {
var server models.IntClient
collection, err := database.FetchRecords(database.INT_CLIENTS_TABLE_NAME)
if err != nil {
return models.IntClient{}, errors.New("could not find comms server")
}
for _, value := range collection {
json.Unmarshal([]byte(value), &server)
if server.Network == "comms" && server.IsServer == "yes" {
return server, nil
}
}
return models.IntClient{}, errors.New("could not find comms server")
}
// FileExists - checks if local file exists
func FileExists(f string) bool {
info, err := os.Stat(f)
if os.IsNotExist(err) {
return false
}
return !info.IsDir()
}
// RemoveNetwork - removes a network locally on server
func RemoveNetwork(network string) (bool, error) {
err := logic.ServerLeave(network)
return true, err
}
// InitServerNetclient - intializes the server netclient
func InitServerNetclient() error {
netclientDir := ncutils.GetNetclientPath()
@ -59,78 +25,42 @@ func InitServerNetclient() error {
return nil
}
// HandleContainedClient - function for checkins on server
func HandleContainedClient() error {
servernets, err := logic.GetNetworks()
if err != nil && !database.IsEmptyRecord(err) {
// SyncServerNetwork - ensures a wg interface and node exists for server
func SyncServerNetwork(serverNode *models.Node) error {
serverNetworkSettings, err := logic.GetNetwork(serverNode.Network)
if err != nil {
return err
}
if len(servernets) > 0 {
if err != nil {
return err
}
for _, serverNet := range servernets {
var serverID, err = logic.GetNetworkServerNodeID(serverNet.NetID)
if err != nil {
logger.Log(1, "error occurred during server checkin:", err.Error())
continue
}
err = logic.ServerCheckin(serverID, servercfg.GetNodeID(), serverNet.NetID)
if err != nil {
logger.Log(1, "error occurred during server checkin:", err.Error())
} else {
logger.Log(3, "completed peers check of network", serverNet.NetID)
}
}
syncErr := SyncNetworks(servernets[:])
if syncErr != nil {
logger.Log(1, "error syncing networks:", syncErr.Error())
syncErr = nil
}
// logger.Log("completed a checkin call", 3)
}
return nil
}
// SyncNetworks - syncs the networks for servers
func SyncNetworks(servernets []models.Network) error {
localnets, err := net.Interfaces()
if err != nil {
return err
}
// check networks to join
for _, servernet := range servernets {
exists := false
for _, localnet := range localnets {
if servernet.DefaultInterface == localnet.Name {
exists = true
}
exists := false
for _, localnet := range localnets {
if serverNetworkSettings.DefaultInterface == localnet.Name {
exists = true
}
if !exists {
success, err := AddNetwork(&servernet)
if err != nil || !success {
if err == nil {
err = errors.New("network add failed for " + servernet.NetID)
}
if !strings.Contains(err.Error(), "macaddress_unique") { // ignore macaddress unique error throws
logger.Log(1, "error adding network", servernet.NetID, "during sync:", err.Error())
}
}
if !exists {
err := logic.ServerJoin(&serverNetworkSettings)
if err != nil {
if err == nil {
err = errors.New("network add failed for " + serverNetworkSettings.NetID)
}
if !strings.Contains(err.Error(), "macaddress_unique") { // ignore macaddress unique error throws
logger.Log(1, "error adding network", serverNetworkSettings.NetID, "during sync:", err.Error())
}
}
}
// check networks to leave
for _, localnet := range localnets {
if strings.Contains(localnet.Name, "nm-") {
var exists = ""
for _, servernet := range servernets {
if servernet.DefaultInterface == localnet.Name {
exists = servernet.NetID
}
if serverNetworkSettings.DefaultInterface == localnet.Name {
exists = serverNetworkSettings.NetID
}
if exists == "" {
success, err := RemoveNetwork(exists)
if err != nil || !success {
err := logic.DeleteNodeByID(serverNode, true)
if err != nil {
if err == nil {
err = errors.New("network delete failed for " + exists)
}
@ -139,12 +69,5 @@ func SyncNetworks(servernets []models.Network) error {
}
}
}
return nil
}
// AddNetwork - add a network to server in client mode
func AddNetwork(networkSettings *models.Network) (bool, error) {
var err = logic.ServerJoin(networkSettings)
return true, err
}