zishuo/netmaker
1
0
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-04 16:33:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

make proxy optional

Browse Source
This commit is contained in:
Abhishek Kondur
2022-11-20 09:35:29 +05:30
parent c54080e150
commit f95306ddbd
19 changed files with 294 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
compose/docker-compose.yml
View File

@@ -41,6 +41,7 @@ services:
PORT_FORWARD_SERVICES: "dns" PORT_FORWARD_SERVICES: "dns"
MQ_ADMIN_PASSWORD: "REPLACE_MQ_ADMIN_PASSWORD" MQ_ADMIN_PASSWORD: "REPLACE_MQ_ADMIN_PASSWORD"
STUN_PORT: "3478" STUN_PORT: "3478"
PROXY: "on"
ports: ports:
- "51821-51830:51821-51830/udp" - "51821-51830:51821-51830/udp"
expose: expose:

1
config/config.go
View File

@@ -77,6 +77,7 @@ type ServerConfig struct {
NetmakerAccountID string `yaml:"netmaker_account_id"` NetmakerAccountID string `yaml:"netmaker_account_id"`
IsEE string `yaml:"is_ee"` IsEE string `yaml:"is_ee"`
StunPort string `yaml:"stun_port"` StunPort string `yaml:"stun_port"`
Proxy string `yaml:"proxy"`
} }
// SQLConfig - Generic SQL Config // SQLConfig - Generic SQL Config

8
controllers/node.go
View File

@@ -481,6 +481,14 @@ func getNode(w http.ResponseWriter, r *http.Request) {
ServerConfig: servercfg.GetServerInfo(), ServerConfig: servercfg.GetServerInfo(),
PeerIDs: peerUpdate.PeerIDs, PeerIDs: peerUpdate.PeerIDs,
} }
if node.Proxy {
proxyPayload, err := logic.GetPeersForProxy(&node, false)
if err == nil {
response.ProxyUpdate = proxyPayload
} else {
logger.Log(0, "failed to get proxy update: ", err.Error())
}
}
if servercfg.Is_EE && nodeRequest { if servercfg.Is_EE && nodeRequest {
if err = logic.EnterpriseResetAllPeersFailovers(node.ID, node.Network); err != nil { if err = logic.EnterpriseResetAllPeersFailovers(node.ID, node.Network); err != nil {

146
logic/peers.go
View File

@@ -13,6 +13,7 @@ import (
"github.com/gravitl/netmaker/logger" "github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/logic/acls/nodeacls" "github.com/gravitl/netmaker/logic/acls/nodeacls"
"github.com/gravitl/netmaker/models" "github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/nm-proxy/manager" "github.com/gravitl/netmaker/nm-proxy/manager"
"github.com/gravitl/netmaker/servercfg" "github.com/gravitl/netmaker/servercfg"
"golang.org/x/exp/slices" "golang.org/x/exp/slices"
@@ -82,7 +83,11 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ManagerPayload
logger.Log(1, "failed to parse node pub key: ", peer.ID) logger.Log(1, "failed to parse node pub key: ", peer.ID)
continue continue
} }
endpoint, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", peer.Endpoint, peer.LocalListenPort)) listenPort := peer.LocalListenPort
if listenPort == 0 {
listenPort = peer.ListenPort
}
endpoint, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", peer.Endpoint, listenPort))
if err != nil { if err != nil {
logger.Log(1, "failed to resolve udp addr for node: ", peer.ID, peer.Endpoint, err.Error()) logger.Log(1, "failed to resolve udp addr for node: ", peer.ID, peer.Endpoint, err.Error())
continue continue
@@ -93,6 +98,10 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ManagerPayload
// set_keepalive // set_keepalive
keepalive, _ = time.ParseDuration(strconv.FormatInt(int64(node.PersistentKeepalive), 10) + "s") keepalive, _ = time.ParseDuration(strconv.FormatInt(int64(node.PersistentKeepalive), 10) + "s")
} }
proxyStatus := peer.Proxy
if peer.Server == "yes" {
proxyStatus = servercfg.IsProxyEnabled()
}
peers = append(peers, wgtypes.PeerConfig{ peers = append(peers, wgtypes.PeerConfig{
PublicKey: pubkey, PublicKey: pubkey,
Endpoint: endpoint, Endpoint: endpoint,
@@ -102,7 +111,9 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ManagerPayload
}) })
peerConfMap[peer.PublicKey] = manager.PeerConf{ peerConfMap[peer.PublicKey] = manager.PeerConf{
Address: peer.PrimaryAddress(), Address: peer.PrimaryAddress(),
Proxy: proxyStatus,
} }
if !onlyPeers && peer.IsRelayed == "yes" { if !onlyPeers && peer.IsRelayed == "yes" {
relayNode := FindRelay(&peer) relayNode := FindRelay(&peer)
if relayNode != nil { if relayNode != nil {
@@ -113,6 +124,7 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (manager.ManagerPayload
IsRelayed: true, IsRelayed: true,
RelayedTo: relayTo, RelayedTo: relayTo,
Address: peer.PrimaryAddress(), Address: peer.PrimaryAddress(),
Proxy: proxyStatus,
} }
} }
@@ -171,9 +183,9 @@ func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
return models.PeerUpdate{}, err return models.PeerUpdate{}, err
} }
// if node.IsRelayed == "yes" { if node.IsRelayed == "yes" {
// return GetPeerUpdateForRelayedNode(node, udppeers) return GetPeerUpdateForRelayedNode(node, udppeers)
// } }
// #1 Set Keepalive values: set_keepalive // #1 Set Keepalive values: set_keepalive
// #2 Set local address: set_local - could be a LOT BETTER and fix some bugs with additional logic // #2 Set local address: set_local - could be a LOT BETTER and fix some bugs with additional logic
@@ -195,15 +207,15 @@ func GetPeerUpdate(node *models.Node) (models.PeerUpdate, error) {
// if the node is not a server, set the endpoint // if the node is not a server, set the endpoint
var setEndpoint = !(node.IsServer == "yes") var setEndpoint = !(node.IsServer == "yes")
// if peer.IsRelayed == "yes" { if peer.IsRelayed == "yes" {
// if !(node.IsRelay == "yes" && ncutils.StringSliceContains(node.RelayAddrs, peer.PrimaryAddress())) { if !(node.IsRelay == "yes" && ncutils.StringSliceContains(node.RelayAddrs, peer.PrimaryAddress())) {
// //skip -- will be added to relay //skip -- will be added to relay
// continue continue
// } else if node.IsRelay == "yes" && ncutils.StringSliceContains(node.RelayAddrs, peer.PrimaryAddress()) { } else if node.IsRelay == "yes" && ncutils.StringSliceContains(node.RelayAddrs, peer.PrimaryAddress()) {
// // dont set peer endpoint if it's relayed by node // dont set peer endpoint if it's relayed by node
// setEndpoint = false setEndpoint = false
// } }
// } }
if !nodeacls.AreNodesAllowed(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID), nodeacls.NodeID(peer.ID)) { if !nodeacls.AreNodesAllowed(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID), nodeacls.NodeID(peer.ID)) {
//skip if not permitted by acl //skip if not permitted by acl
continue continue
@@ -478,60 +490,60 @@ func GetAllowedIPs(node, peer *models.Node, metrics *models.Metrics) []net.IPNet
} }
} }
// handle relay gateway peers // handle relay gateway peers
// if peer.IsRelay == "yes" { if peer.IsRelay == "yes" {
// for _, ip := range peer.RelayAddrs { for _, ip := range peer.RelayAddrs {
// //find node ID of relayed peer //find node ID of relayed peer
// relayedPeer, err := findNode(ip) relayedPeer, err := findNode(ip)
// if err != nil { if err != nil {
// logger.Log(0, "failed to find node for ip ", ip, err.Error()) logger.Log(0, "failed to find node for ip ", ip, err.Error())
// continue continue
// } }
// if relayedPeer == nil { if relayedPeer == nil {
// continue continue
// } }
// if relayedPeer.ID == node.ID { if relayedPeer.ID == node.ID {
// //skip self //skip self
// continue continue
// } }
// //check if acl permits comms //check if acl permits comms
// if !nodeacls.AreNodesAllowed(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID), nodeacls.NodeID(relayedPeer.ID)) { if !nodeacls.AreNodesAllowed(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID), nodeacls.NodeID(relayedPeer.ID)) {
// continue continue
// } }
// if iplib.Version(net.ParseIP(ip)) == 4 { if iplib.Version(net.ParseIP(ip)) == 4 {
// relayAddr := net.IPNet{ relayAddr := net.IPNet{
// IP: net.ParseIP(ip), IP: net.ParseIP(ip),
// Mask: net.CIDRMask(32, 32), Mask: net.CIDRMask(32, 32),
// } }
// allowedips = append(allowedips, relayAddr) allowedips = append(allowedips, relayAddr)
// } }
// if iplib.Version(net.ParseIP(ip)) == 6 { if iplib.Version(net.ParseIP(ip)) == 6 {
// relayAddr := net.IPNet{ relayAddr := net.IPNet{
// IP: net.ParseIP(ip), IP: net.ParseIP(ip),
// Mask: net.CIDRMask(128, 128), Mask: net.CIDRMask(128, 128),
// } }
// allowedips = append(allowedips, relayAddr) allowedips = append(allowedips, relayAddr)
// } }
// relayedNode, err := findNode(ip) relayedNode, err := findNode(ip)
// if err != nil { if err != nil {
// logger.Log(1, "unable to find node for relayed address", ip, err.Error()) logger.Log(1, "unable to find node for relayed address", ip, err.Error())
// continue continue
// } }
// if relayedNode.IsEgressGateway == "yes" { if relayedNode.IsEgressGateway == "yes" {
// extAllowedIPs := getEgressIPs(node, relayedNode) extAllowedIPs := getEgressIPs(node, relayedNode)
// allowedips = append(allowedips, extAllowedIPs...) allowedips = append(allowedips, extAllowedIPs...)
// } }
// if relayedNode.IsIngressGateway == "yes" { if relayedNode.IsIngressGateway == "yes" {
// extPeers, _, err := getExtPeers(relayedNode) extPeers, _, err := getExtPeers(relayedNode)
// if err == nil { if err == nil {
// for _, extPeer := range extPeers { for _, extPeer := range extPeers {
// allowedips = append(allowedips, extPeer.AllowedIPs...) allowedips = append(allowedips, extPeer.AllowedIPs...)
// } }
// } else { } else {
// logger.Log(0, "failed to retrieve extclients from relayed ingress", err.Error()) logger.Log(0, "failed to retrieve extclients from relayed ingress", err.Error())
// } }
// } }
// } }
// } }
return allowedips return allowedips
} }

19
logic/server.go
View File

@@ -175,16 +175,19 @@ func ServerJoin(networkSettings *models.Network) (models.Node, error) {
if err != nil { if err != nil {
return returnNode, err return returnNode, err
} }
proxyPayload, err := GetPeersForProxy(node, false) if servercfg.IsProxyEnabled() {
if err != nil && !ncutils.IsEmptyRecord(err) { proxyPayload, err := GetPeersForProxy(node, false)
logger.Log(1, "failed to retrieve peers") if err != nil && !ncutils.IsEmptyRecord(err) {
return returnNode, err logger.Log(1, "failed to retrieve peers")
return returnNode, err
}
ProxyMgmChan <- &manager.ManagerAction{
Action: manager.AddInterface,
Payload: proxyPayload,
}
} }
ProxyMgmChan <- &manager.ManagerAction{
Action: manager.AddInterface,
Payload: proxyPayload,
}
return *node, nil return *node, nil
} }

20
logic/wireguard.go
View File

@@ -10,6 +10,7 @@ import (
"github.com/gravitl/netmaker/netclient/ncutils" "github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/netclient/wireguard" "github.com/gravitl/netmaker/netclient/wireguard"
"github.com/gravitl/netmaker/nm-proxy/manager" "github.com/gravitl/netmaker/nm-proxy/manager"
"github.com/gravitl/netmaker/servercfg"
"golang.zx2c4.com/wireguard/wgctrl" "golang.zx2c4.com/wireguard/wgctrl"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes" "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
) )
@@ -160,17 +161,20 @@ func setWGConfig(node *models.Node, peerupdate bool) error {
logger.Log(3, "finished setting wg config on server", node.Name) logger.Log(3, "finished setting wg config on server", node.Name)
} }
logger.Log(0, "--------> ADD/Update INTERFACE TO PROXY.....") if servercfg.IsProxyEnabled() {
proxyPayload, err := GetPeersForProxy(node, false) logger.Log(0, "--------> ADD/Update INTERFACE TO PROXY.....")
if err != nil { proxyPayload, err := GetPeersForProxy(node, false)
logger.Log(0, "failed to get peers for proxy: ", err.Error()) if err != nil {
} else { logger.Log(0, "failed to get peers for proxy: ", err.Error())
} else {
ProxyMgmChan <- &manager.ManagerAction{ ProxyMgmChan <- &manager.ManagerAction{
Action: manager.AddInterface, Action: manager.AddInterface,
Payload: proxyPayload, Payload: proxyPayload,
}
} }
} }
return nil return nil
} }

33
main.go
View File

@@ -172,24 +172,29 @@ func startControllers() {
if !servercfg.IsAgentBackend() && !servercfg.IsRestBackend() && !servercfg.IsMessageQueueBackend() { if !servercfg.IsAgentBackend() && !servercfg.IsRestBackend() && !servercfg.IsMessageQueueBackend() {
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'.") 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'.")
} }
// starts the stun server // starts the stun server
waitnetwork.Add(1) waitnetwork.Add(1)
go stunserver.Start(&waitnetwork) go stunserver.Start(&waitnetwork)
waitnetwork.Add(1) if servercfg.IsProxyEnabled() {
go func() {
defer waitnetwork.Done()
ctx, cancel := context.WithCancel(context.Background())
waitnetwork.Add(1) waitnetwork.Add(1)
go nmproxy.Start(ctx, logic.ProxyMgmChan, servercfg.GetAPIHost()) go func() {
err := serverctl.SyncServerNetworkWithProxy() defer waitnetwork.Done()
if err != nil { ctx, cancel := context.WithCancel(context.Background())
logger.Log(0, "failed to sync proxy with server interfaces: ", err.Error()) waitnetwork.Add(1)
}
quit := make(chan os.Signal, 1) go nmproxy.Start(ctx, logic.ProxyMgmChan, servercfg.GetAPIHost())
signal.Notify(quit, syscall.SIGTERM, os.Interrupt) err := serverctl.SyncServerNetworkWithProxy()
<-quit if err != nil {
cancel() logger.Log(0, "failed to sync proxy with server interfaces: ", err.Error())
}() }
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGTERM, os.Interrupt)
<-quit
cancel()
}()
}
waitnetwork.Wait() waitnetwork.Wait()
} }

1
models/node.go
View File

@@ -106,6 +106,7 @@ type Node struct {
DefaultACL string `json:"defaultacl,omitempty" bson:"defaultacl,omitempty" yaml:"defaultacl,omitempty" validate:"checkyesornoorunset"` DefaultACL string `json:"defaultacl,omitempty" bson:"defaultacl,omitempty" yaml:"defaultacl,omitempty" validate:"checkyesornoorunset"`
OwnerID string `json:"ownerid,omitempty" bson:"ownerid,omitempty" yaml:"ownerid,omitempty"` OwnerID string `json:"ownerid,omitempty" bson:"ownerid,omitempty" yaml:"ownerid,omitempty"`
Failover string `json:"failover" bson:"failover" yaml:"failover" validate:"checkyesorno"` Failover string `json:"failover" bson:"failover" yaml:"failover" validate:"checkyesorno"`
Proxy bool `json:"proxy" bson:"proxy" yaml:"proxy"`
} }
// NodesArray - used for node sorting // NodesArray - used for node sorting

10
models/structs.go
View File

@@ -5,6 +5,7 @@ import (
"time" "time"
jwt "github.com/golang-jwt/jwt/v4" jwt "github.com/golang-jwt/jwt/v4"
"github.com/gravitl/netmaker/nm-proxy/manager"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes" "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
) )
@@ -202,10 +203,11 @@ type TrafficKeys struct {
// NodeGet - struct for a single node get response // NodeGet - struct for a single node get response
type NodeGet struct { type NodeGet struct {
Node Node `json:"node" bson:"node" yaml:"node"` Node Node `json:"node" bson:"node" yaml:"node"`
Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"` Peers []wgtypes.PeerConfig `json:"peers" bson:"peers" yaml:"peers"`
ServerConfig ServerConfig `json:"serverconfig" bson:"serverconfig" yaml:"serverconfig"` ServerConfig ServerConfig `json:"serverconfig" bson:"serverconfig" yaml:"serverconfig"`
PeerIDs PeerMap `json:"peerids,omitempty" bson:"peerids,omitempty" yaml:"peerids,omitempty"` PeerIDs PeerMap `json:"peerids,omitempty" bson:"peerids,omitempty" yaml:"peerids,omitempty"`
ProxyUpdate manager.ManagerPayload `json:"proxy_update,omitempty" bson:"proxy_update,omitempty" yaml:"proxy_update,omitempty"`
} }
// ServerConfig - struct for dealing with the server information for a netclient // ServerConfig - struct for dealing with the server information for a netclient

61
mq/publishers.go
View File

@@ -31,10 +31,13 @@ func PublishPeerUpdate(newNode *models.Node, publishToSelf bool) error {
// logger.Log(1, "failed to publish proxy update to node", node.Name, "on network", node.Network, ":", err.Error()) // logger.Log(1, "failed to publish proxy update to node", node.Name, "on network", node.Network, ":", err.Error())
// } // }
if node.IsServer == "yes" { if node.IsServer == "yes" {
err := PublishProxyUpdate(manager.AddInterface, &node) if servercfg.IsProxyEnabled() {
if err != nil { err := PublishProxyUpdate(manager.AddInterface, &node)
logger.Log(0, "failed to send proxy update for server: ", err.Error()) if err != nil {
logger.Log(0, "failed to send proxy update for server: ", err.Error())
}
} }
continue continue
} }
if !publishToSelf && newNode.ID == node.ID { if !publishToSelf && newNode.ID == node.ID {
@@ -67,18 +70,22 @@ func PublishProxyUpdate(action manager.ProxyAction, node *models.Node) error {
// PublishSinglePeerUpdate --- determines and publishes a peer update to one node // PublishSinglePeerUpdate --- determines and publishes a peer update to one node
func PublishSinglePeerUpdate(node *models.Node) error { func PublishSinglePeerUpdate(node *models.Node) error {
peerUpdate, err := logic.GetPeerUpdate(node) peerUpdate, err := logic.GetPeerUpdate(node)
if err != nil { if err != nil {
return err return err
} }
proxyUpdate, err := logic.GetPeersForProxy(node, false) if node.Proxy {
if err != nil { proxyUpdate, err := logic.GetPeersForProxy(node, false)
return err if err != nil {
} return err
peerUpdate.ProxyUpdate = manager.ManagerAction{ }
Action: manager.AddInterface, peerUpdate.ProxyUpdate = manager.ManagerAction{
Payload: proxyUpdate, Action: manager.AddInterface,
Payload: proxyUpdate,
}
} }
data, err := json.Marshal(&peerUpdate) data, err := json.Marshal(&peerUpdate)
if err != nil { if err != nil {
return err return err
@@ -117,6 +124,7 @@ func PublishExtPeerUpdate(node *models.Node) error {
// NodeUpdate -- publishes a node update // NodeUpdate -- publishes a node update
func NodeUpdate(node *models.Node) error { func NodeUpdate(node *models.Node) error {
var err error
if !servercfg.IsMessageQueueBackend() || node.IsServer == "yes" { if !servercfg.IsMessageQueueBackend() || node.IsServer == "yes" {
return nil return nil
@@ -127,19 +135,23 @@ func NodeUpdate(node *models.Node) error {
node.NetworkSettings.AccessKeys = []models.AccessKey{} // not to be sent (don't need to spread access keys around the network; we need to know how to reach other nodes, not become them) node.NetworkSettings.AccessKeys = []models.AccessKey{} // not to be sent (don't need to spread access keys around the network; we need to know how to reach other nodes, not become them)
} }
data, err := json.Marshal(node) if node.Proxy {
if err != nil { err = PublishProxyUpdate(manager.AddInterface, node)
logger.Log(2, "error marshalling node update ", err.Error()) if err != nil {
return err logger.Log(1, "failed to publish proxy update to node", node.Name, "on network", node.Network, ":", err.Error())
} }
if err = publish(node, fmt.Sprintf("update/%s/%s", node.Network, node.ID), data); err != nil { } else {
logger.Log(2, "error publishing node update to peer ", node.ID, err.Error()) data, err := json.Marshal(node)
return err if err != nil {
} logger.Log(2, "error marshalling node update ", err.Error())
err = PublishProxyUpdate(manager.AddInterface, node) return err
if err != nil { }
logger.Log(1, "failed to publish proxy update to node", node.Name, "on network", node.Network, ":", err.Error()) if err = publish(node, fmt.Sprintf("update/%s/%s", node.Network, node.ID), data); err != nil {
logger.Log(2, "error publishing node update to peer ", node.ID, err.Error())
return err
}
} }
return nil return nil
} }
@@ -224,7 +236,10 @@ func sendPeers() {
if errN != nil { if errN != nil {
logger.Log(1, errN.Error()) logger.Log(1, errN.Error())
} }
serverctl.SyncServerNetworkWithProxy() if servercfg.IsProxyEnabled() {
serverctl.SyncServerNetworkWithProxy()
}
} }
} }
} }

7
netclient/cli_options/flags.go
View File

@@ -12,6 +12,13 @@ func GetFlags(hostname string) []cli.Flag {
Value: "all", Value: "all",
Usage: "Network to perform specified action against.", Usage: "Network to perform specified action against.",
}, },
&cli.StringFlag{
Name: "proxy",
// Aliases: []string{"np"},
EnvVars: []string{"NETMAKER_PROXY"},
Value: "off",
Usage: "To enable/disable proxy.",
},
&cli.StringFlag{ &cli.StringFlag{
Name: "password", Name: "password",
Aliases: []string{"p"}, Aliases: []string{"p"},

4
netclient/config/config.go
View File

@@ -227,6 +227,10 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, string, error) {
if c.String("key") != "" { if c.String("key") != "" {
cfg.AccessKey = c.String("key") cfg.AccessKey = c.String("key")
} }
if c.String("proxy") != "" {
cfg.Node.Proxy = c.String("proxy") == "on"
}
log.Println("_______________> PROXY: ", cfg.Node.Proxy)
if c.String("network") != "all" { if c.String("network") != "all" {
cfg.Network = c.String("network") cfg.Network = c.String("network")
cfg.Node.Network = c.String("network") cfg.Node.Network = c.String("network")

28
netclient/functions/daemon.go
View File

@@ -33,7 +33,6 @@ import (
var ProxyMgmChan = make(chan *manager.ManagerAction, 100) var ProxyMgmChan = make(chan *manager.ManagerAction, 100)
var messageCache = new(sync.Map) var messageCache = new(sync.Map)
var ProxyStatus = "OFF"
var serverSet map[string]bool var serverSet map[string]bool
var mqclient mqtt.Client var mqclient mqtt.Client
@@ -125,25 +124,16 @@ func startGoRoutines(wg *sync.WaitGroup) context.CancelFunc {
go Checkin(ctx, wg) go Checkin(ctx, wg)
if len(networks) != 0 { if len(networks) != 0 {
go func() { cfg := config.ClientConfig{}
cfg := config.ClientConfig{} cfg.Network = networks[0]
cfg.Network = networks[0] cfg.ReadConfig()
cfg.ReadConfig() apiHost, _, err := net.SplitHostPort(cfg.Server.API)
apiHost, _, err := net.SplitHostPort(cfg.Server.API) if err == nil {
if err == nil { wg.Add(1)
if ProxyStatus != "ON" { go nmproxy.Start(ctx, ProxyMgmChan, apiHost)
ProxyStatus = "ON" logger.Log(0, "Proxy Shutting down....")
pCtx, pCancel := context.WithCancel(context.Background())
go nmproxy.Start(pCtx, ProxyMgmChan, apiHost)
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGTERM, os.Interrupt)
<-quit
pCancel()
logger.Log(0, "Proxy Shutting down....")
}
} }
}()
} }

18
netclient/functions/mqhandlers.go
View File

@@ -52,8 +52,6 @@ func ProxyUpdate(client mqtt.Client, msg mqtt.Message) {
// NodeUpdate -- mqtt message handler for /update/<NodeID> topic // NodeUpdate -- mqtt message handler for /update/<NodeID> topic
func NodeUpdate(client mqtt.Client, msg mqtt.Message) { func NodeUpdate(client mqtt.Client, msg mqtt.Message) {
logger.Log(0, "----------> RECIEVED NODE UPDDATEEEEE")
return
var newNode models.Node var newNode models.Node
var nodeCfg config.ClientConfig var nodeCfg config.ClientConfig
var network = parseNetworkFromTopic(msg.Topic()) var network = parseNetworkFromTopic(msg.Topic())
@@ -69,6 +67,15 @@ func NodeUpdate(client mqtt.Client, msg mqtt.Message) {
logger.Log(0, "error unmarshalling node update data"+err.Error()) logger.Log(0, "error unmarshalling node update data"+err.Error())
return return
} }
if newNode.Proxy {
if newNode.Proxy != nodeCfg.Node.Proxy {
if err := config.Write(&nodeCfg, nodeCfg.Network); err != nil {
logger.Log(0, nodeCfg.Node.Network, "error updating node configuration: ", err.Error())
}
}
logger.Log(0, "Node is attached with proxy,ignore this node update...")
return
}
// see if cache hit, if so skip // see if cache hit, if so skip
var currentMessage = read(newNode.Network, lastNodeUpdate) var currentMessage = read(newNode.Network, lastNodeUpdate)
@@ -228,6 +235,11 @@ func UpdatePeers(client mqtt.Client, msg mqtt.Message) {
cfg.Server.Version = peerUpdate.ServerVersion cfg.Server.Version = peerUpdate.ServerVersion
config.Write(&cfg, cfg.Network) config.Write(&cfg, cfg.Network)
} }
if cfg.Node.Proxy {
ProxyMgmChan <- &peerUpdate.ProxyUpdate
return
}
file := ncutils.GetNetclientPathSpecific() + cfg.Node.Interface + ".conf" file := ncutils.GetNetclientPathSpecific() + cfg.Node.Interface + ".conf"
internetGateway, err := wireguard.UpdateWgPeers(file, peerUpdate.Peers) internetGateway, err := wireguard.UpdateWgPeers(file, peerUpdate.Peers)
if err != nil { if err != nil {
@@ -269,7 +281,7 @@ func UpdatePeers(client mqtt.Client, msg mqtt.Message) {
// logger.Log(0, "error syncing wg after peer update: "+err.Error()) // logger.Log(0, "error syncing wg after peer update: "+err.Error())
// return // return
// } // }
ProxyMgmChan <- &peerUpdate.ProxyUpdate
logger.Log(0, "network:", cfg.Node.Network, "received peer update for node "+cfg.Node.Name+" "+cfg.Node.Network) logger.Log(0, "network:", cfg.Node.Network, "received peer update for node "+cfg.Node.Name+" "+cfg.Node.Network)
if cfg.Node.DNSOn == "yes" { if cfg.Node.DNSOn == "yes" {
if err := setHostDNS(peerUpdate.DNS, cfg.Node.Interface, ncutils.IsWindows()); err != nil { if err := setHostDNS(peerUpdate.DNS, cfg.Node.Interface, ncutils.IsWindows()); err != nil {

47
netclient/functions/pull.go
View File

@@ -15,6 +15,7 @@ import (
"github.com/gravitl/netmaker/netclient/local" "github.com/gravitl/netmaker/netclient/local"
"github.com/gravitl/netmaker/netclient/ncutils" "github.com/gravitl/netmaker/netclient/ncutils"
"github.com/gravitl/netmaker/netclient/wireguard" "github.com/gravitl/netmaker/netclient/wireguard"
"github.com/gravitl/netmaker/nm-proxy/manager"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes" "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
//homedir "github.com/mitchellh/go-homedir" //homedir "github.com/mitchellh/go-homedir"
) )
@@ -62,32 +63,44 @@ func Pull(network string, iface bool) (*models.Node, error) {
logger.Log(0, "unable to update server config: "+err.Error()) logger.Log(0, "unable to update server config: "+err.Error())
} }
} }
if nodeGET.Node.ListenPort != cfg.Node.LocalListenPort { if nodeGET.Node.Proxy {
if err := wireguard.RemoveConf(resNode.Interface, false); err != nil { ProxyMgmChan <- &manager.ManagerAction{
logger.Log(0, "error remove interface", resNode.Interface, err.Error()) Action: manager.AddInterface,
Payload: nodeGET.ProxyUpdate,
} }
err = ncutils.ModPort(&resNode)
if err != nil {
return nil, err
}
informPortChange(&resNode)
} }
if !nodeGET.Node.Proxy {
if nodeGET.Node.ListenPort != cfg.Node.LocalListenPort {
if err := wireguard.RemoveConf(resNode.Interface, false); err != nil {
logger.Log(0, "error remove interface", resNode.Interface, err.Error())
}
err = ncutils.ModPort(&resNode)
if err != nil {
return nil, err
}
informPortChange(&resNode)
}
}
if err = config.ModNodeConfig(&resNode); err != nil { if err = config.ModNodeConfig(&resNode); err != nil {
return nil, err return nil, err
} }
if iface { if !nodeGET.Node.Proxy {
if err = wireguard.SetWGConfig(network, false, nodeGET.Peers[:]); err != nil { if iface {
return nil, err if err = wireguard.SetWGConfig(network, false, nodeGET.Peers[:]); err != nil {
}
} else {
if err = wireguard.SetWGConfig(network, true, nodeGET.Peers[:]); err != nil {
if errors.Is(err, os.ErrNotExist) && !ncutils.IsFreeBSD() {
return Pull(network, true)
} else {
return nil, err return nil, err
} }
} else {
if err = wireguard.SetWGConfig(network, true, nodeGET.Peers[:]); err != nil {
if errors.Is(err, os.ErrNotExist) && !ncutils.IsFreeBSD() {
return Pull(network, true)
} else {
return nil, err
}
}
} }
} }
var bkupErr = config.SaveBackup(network) var bkupErr = config.SaveBackup(network)
if bkupErr != nil { if bkupErr != nil {
logger.Log(0, "unable to update backup file for", network) logger.Log(0, "unable to update backup file for", network)

1
nm-proxy/common/common.go
View File

@@ -56,6 +56,7 @@ type Config struct {
// Proxy - WireguardProxy proxies // Proxy - WireguardProxy proxies
type Proxy struct { type Proxy struct {
Status bool
Ctx context.Context Ctx context.Context
Cancel context.CancelFunc Cancel context.CancelFunc

42
nm-proxy/manager/manager.go
View File

@@ -54,6 +54,7 @@ type PeerConf struct {
IngressGatewayEndPoint *net.UDPAddr `json:"ingress_gateway_endpoint"` IngressGatewayEndPoint *net.UDPAddr `json:"ingress_gateway_endpoint"`
IsRelayed bool `json:"is_relayed"` IsRelayed bool `json:"is_relayed"`
RelayedTo *net.UDPAddr `json:"relayed_to"` RelayedTo *net.UDPAddr `json:"relayed_to"`
Proxy bool `json:"proxy"`
} }
const ( const (
@@ -169,6 +170,15 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
var wgProxyConf common.WgIfaceConf var wgProxyConf common.WgIfaceConf
var ok bool var ok bool
if wgProxyConf, ok = common.WgIFaceMap[m.Payload.InterfaceName]; !ok { if wgProxyConf, ok = common.WgIFaceMap[m.Payload.InterfaceName]; !ok {
for i := len(m.Payload.Peers) - 1; i >= 0; i-- {
if !m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].Proxy {
log.Println("-----------> skipping peer, proxy is off: ", m.Payload.Peers[i].PublicKey)
if err := wgIface.Update(m.Payload.Peers[i], false); err != nil {
log.Println("falied to update peer: ", err)
}
m.Payload.Peers = append(m.Payload.Peers[:i], m.Payload.Peers[i+1:]...)
}
}
return wgIface, nil return wgIface, nil
} }
if m.Payload.IsRelay { if m.Payload.IsRelay {
@@ -192,14 +202,31 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
// check device conf different from proxy // check device conf different from proxy
//wgProxyConf.Iface = wgIface.Device //wgProxyConf.Iface = wgIface.Device
for i := len(m.Payload.Peers) - 1; i >= 0; i-- { for i := len(m.Payload.Peers) - 1; i >= 0; i-- {
if currentPeer, ok := wgProxyConf.PeerMap[m.Payload.Peers[i].PublicKey.String()]; ok { if currentPeer, ok := wgProxyConf.PeerMap[m.Payload.Peers[i].PublicKey.String()]; ok {
// check if proxy is off for the peer
if !m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].Proxy {
// cleanup proxy connections for the peer
currentPeer.Proxy.Cancel()
time.Sleep(time.Second * 3)
delete(wgProxyConf.PeerMap, currentPeer.Config.Key)
// update the peer with actual endpoint
if err := wgIface.Update(m.Payload.Peers[i], false); err != nil {
log.Println("falied to update peer: ", err)
}
m.Payload.Peers = append(m.Payload.Peers[:i], m.Payload.Peers[i+1:]...)
continue
}
// check if peer is not connected to proxy // check if peer is not connected to proxy
devPeer, err := wg.GetPeer(m.Payload.InterfaceName, currentPeer.Config.Key) devPeer, err := wg.GetPeer(m.Payload.InterfaceName, currentPeer.Config.Key)
if err == nil { if err == nil {
log.Printf("---------> COMAPRING ENDP{INT}: DEV: %s, Proxy: %s", devPeer.Endpoint.String(), currentPeer.Proxy.LocalConn.LocalAddr().String()) log.Printf("---------> COMAPRING ENDPOINT: DEV: %s, Proxy: %s", devPeer.Endpoint.String(), currentPeer.Proxy.LocalConn.LocalAddr().String())
if devPeer.Endpoint.String() != currentPeer.Proxy.LocalConn.LocalAddr().String() { if devPeer.Endpoint.String() != currentPeer.Proxy.LocalConn.LocalAddr().String() {
log.Println("---------> endpoint is not set to proxy: ", currentPeer.Config.Key) log.Println("---------> endpoint is not set to proxy: ", currentPeer.Config.Key)
currentPeer.Proxy.Cancel() currentPeer.Proxy.Cancel()
time.Sleep(time.Second * 3)
delete(wgProxyConf.PeerMap, currentPeer.Config.Key) delete(wgProxyConf.PeerMap, currentPeer.Config.Key)
continue continue
} }
@@ -208,6 +235,7 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
if currentPeer.Config.IsRelayed != m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].IsRelayed { if currentPeer.Config.IsRelayed != m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].IsRelayed {
log.Println("---------> peer relay status has been changed: ", currentPeer.Config.Key) log.Println("---------> peer relay status has been changed: ", currentPeer.Config.Key)
currentPeer.Proxy.Cancel() currentPeer.Proxy.Cancel()
time.Sleep(time.Second * 3)
delete(wgProxyConf.PeerMap, currentPeer.Config.Key) delete(wgProxyConf.PeerMap, currentPeer.Config.Key)
continue continue
} }
@@ -217,6 +245,7 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
currentPeer.Config.RelayedEndpoint.String() != m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].RelayedTo.String() { currentPeer.Config.RelayedEndpoint.String() != m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].RelayedTo.String() {
log.Println("---------> peer relay endpoint has been changed: ", currentPeer.Config.Key) log.Println("---------> peer relay endpoint has been changed: ", currentPeer.Config.Key)
currentPeer.Proxy.Cancel() currentPeer.Proxy.Cancel()
time.Sleep(time.Second * 3)
delete(wgProxyConf.PeerMap, currentPeer.Config.Key) delete(wgProxyConf.PeerMap, currentPeer.Config.Key)
continue continue
} }
@@ -224,6 +253,7 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
if currentPeer.Proxy.RemoteConn.IP.String() != m.Payload.Peers[i].Endpoint.IP.String() { if currentPeer.Proxy.RemoteConn.IP.String() != m.Payload.Peers[i].Endpoint.IP.String() {
log.Println("----------> Resetting proxy for Peer: ", currentPeer.Config.Key, m.Payload.InterfaceName) log.Println("----------> Resetting proxy for Peer: ", currentPeer.Config.Key, m.Payload.InterfaceName)
currentPeer.Proxy.Cancel() currentPeer.Proxy.Cancel()
time.Sleep(time.Second * 3)
delete(wgProxyConf.PeerMap, currentPeer.Config.Key) delete(wgProxyConf.PeerMap, currentPeer.Config.Key)
} else { } else {
@@ -234,7 +264,7 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
if err == nil { if err == nil {
updatePeerConf.Endpoint = localUdpAddr updatePeerConf.Endpoint = localUdpAddr
} }
if err := wgIface.Update(updatePeerConf); err != nil { if err := wgIface.Update(updatePeerConf, true); err != nil {
log.Println("failed to update peer: ", currentPeer.Config.Key, err) log.Println("failed to update peer: ", currentPeer.Config.Key, err)
} }
currentPeer.Proxy.Config.PeerConf = &m.Payload.Peers[i] currentPeer.Proxy.Config.PeerConf = &m.Payload.Peers[i]
@@ -251,11 +281,18 @@ func (m *ManagerAction) processPayload() (*wg.WGIface, error) {
m.Payload.Peers = append(m.Payload.Peers[:i], m.Payload.Peers[i+1:]...) m.Payload.Peers = append(m.Payload.Peers[:i], m.Payload.Peers[i+1:]...)
} }
} else if !m.Payload.PeerMap[m.Payload.Peers[i].PublicKey.String()].Proxy {
log.Println("-----------> skipping peer, proxy is off: ", m.Payload.Peers[i].PublicKey)
if err := wgIface.Update(m.Payload.Peers[i], false); err != nil {
log.Println("falied to update peer: ", err)
}
m.Payload.Peers = append(m.Payload.Peers[:i], m.Payload.Peers[i+1:]...)
} }
} }
for _, currPeerI := range wgProxyConf.PeerMap { for _, currPeerI := range wgProxyConf.PeerMap {
if _, ok := m.Payload.PeerMap[currPeerI.Config.Key]; !ok { if _, ok := m.Payload.PeerMap[currPeerI.Config.Key]; !ok {
currPeerI.Proxy.Cancel() currPeerI.Proxy.Cancel()
time.Sleep(time.Second * 3)
// delete peer from interface // delete peer from interface
log.Println("CurrPeer Not Found, Deleting Peer from Interface: ", currPeerI.Config.Key) log.Println("CurrPeer Not Found, Deleting Peer from Interface: ", currPeerI.Config.Key)
if err := wgIface.RemovePeer(currPeerI.Config.Key); err != nil { if err := wgIface.RemovePeer(currPeerI.Config.Key); err != nil {
@@ -306,6 +343,7 @@ func (m *ManagerAction) AddInterfaceToProxy() error {
Endpoint: wgListenAddr, Endpoint: wgListenAddr,
} }
for _, peerI := range m.Payload.Peers { for _, peerI := range m.Payload.Peers {
peerConf := m.Payload.PeerMap[peerI.PublicKey.String()] peerConf := m.Payload.PeerMap[peerI.PublicKey.String()]
if peerI.Endpoint == nil && !(peerConf.IsAttachedExtClient || peerConf.IsExtClient) { if peerI.Endpoint == nil && !(peerConf.IsAttachedExtClient || peerConf.IsExtClient) {
log.Println("Endpoint nil for peer: ", peerI.PublicKey.String()) log.Println("Endpoint nil for peer: ", peerI.PublicKey.String())

4
nm-proxy/wg/wg.go
View File

@@ -263,13 +263,13 @@ func (w *WGIface) RemovePeer(peerKey string) error {
} }
// UpdatePeer // UpdatePeer
func (w *WGIface) Update(peerConf wgtypes.PeerConfig) error { func (w *WGIface) Update(peerConf wgtypes.PeerConfig, updateOnly bool) error {
w.mu.Lock() w.mu.Lock()
defer w.mu.Unlock() defer w.mu.Unlock()
var err error var err error
log.Printf("---------> NEWWWWWW Updating peer %+v from interface %s ", peerConf, w.Name) log.Printf("---------> NEWWWWWW Updating peer %+v from interface %s ", peerConf, w.Name)
peerConf.UpdateOnly = true peerConf.UpdateOnly = updateOnly
peerConf.ReplaceAllowedIPs = true peerConf.ReplaceAllowedIPs = true
config := wgtypes.Config{ config := wgtypes.Config{
Peers: []wgtypes.PeerConfig{peerConf}, Peers: []wgtypes.PeerConfig{peerConf},

10
servercfg/serverconf.go
View File

@@ -672,3 +672,13 @@ func GetStunPort() string {
} }
return port return port
} }
func IsProxyEnabled() bool {
var enabled = true //default
if os.Getenv("PROXY") != "" {
enabled = os.Getenv("PROXY") == "on"
} else if config.Config.Server.Proxy != "" {
enabled = config.Config.Server.Proxy == "on"
}
return enabled
}