proxy updates refactor changes

controllers/node.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 
 	"github.com/gorilla/mux"
-	proxy_models "github.com/gravitl/netclient/nmproxy/models"
 	"github.com/gravitl/netmaker/database"
 	"github.com/gravitl/netmaker/logger"
 	"github.com/gravitl/netmaker/logic"
@@ -1061,12 +1060,6 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
 		logic.ReturnErrorResponse(w, r, logic.FormatError(fmt.Errorf("failed to delete node"), "internal"))
 		return
 	}
-	if host.ProxyEnabled {
-		mq.ProxyUpdate(&proxy_models.ProxyManagerPayload{
-			Action:  proxy_models.DeleteNetwork,
-			Network: node.Network,
-		}, &node)
-	}
 	if fromNode {
 		// update networks for host mq client
 		currNets := logic.GetHostNetworks(host.ID.String())

go.mod

@@ -43,7 +43,7 @@ require (
 )
 
 require (
-	github.com/gravitl/netclient v0.0.0-20221228022055-5bdb0bc7861d
+	github.com/gravitl/netclient v0.0.0-20230108123913-3f903b97d39c
 	github.com/guumaster/tablewriter v0.0.10
 	github.com/matryer/is v1.4.0
 	github.com/olekukonko/tablewriter v0.0.5
@@ -51,9 +51,64 @@ require (
 )
 
 require (
+	github.com/Microsoft/go-winio v0.5.2 // indirect
+	github.com/bep/debounce v1.2.1 // indirect
+	github.com/cloverstd/tcping v0.1.1 // indirect
+	github.com/devilcove/httpclient v0.6.0 // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
+	github.com/docker/docker v20.10.17+incompatible // indirect
+	github.com/docker/go-connections v0.4.0 // indirect
+	github.com/docker/go-units v0.4.0 // indirect
+	github.com/fsnotify/fsnotify v1.5.4 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/google/gopacket v1.1.19 // indirect
+	github.com/guumaster/hostctl v1.1.3 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/imdario/mergo v0.3.12 // indirect
 	github.com/inconshreveable/mousetrap v1.0.1 // indirect
-	github.com/rivo/uniseg v0.1.0 // indirect
+	github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/labstack/echo/v4 v4.9.0 // indirect
+	github.com/labstack/gommon v0.3.1 // indirect
+	github.com/leaanthony/go-ansi-parser v1.0.1 // indirect
+	github.com/leaanthony/gosod v1.0.3 // indirect
+	github.com/leaanthony/slicer v1.5.0 // indirect
+	github.com/magiconair/properties v1.8.6 // indirect
+	github.com/mattn/go-colorable v0.1.12 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.0.2 // indirect
+	github.com/pelletier/go-toml v1.9.5 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
+	github.com/pkg/browser v0.0.0-20210706143420-7d21f8c997e2 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	github.com/rogpeppe/go-internal v1.9.0 // indirect
+	github.com/samber/lo v1.27.1 // indirect
+	github.com/spf13/afero v1.9.2 // indirect
+	github.com/spf13/cast v1.5.0 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/spf13/viper v1.13.0 // indirect
+	github.com/subosito/gotenv v1.4.1 // indirect
+	github.com/tkrajina/go-reflector v0.5.5 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.1 // indirect
+	github.com/vishvananda/netlink v1.1.0 // indirect
+	github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df // indirect
+	github.com/wailsapp/mimetype v1.4.1 // indirect
+	github.com/wailsapp/wails/v2 v2.2.0 // indirect
+	golang.design/x/clipboard v0.6.3 // indirect
+	golang.org/x/exp/shiny v0.0.0-20221208044002-44028be4359e // indirect
+	golang.org/x/image v0.0.0-20220601225756-64ec528b34cd // indirect
+	golang.org/x/mobile v0.0.0-20211207041440-4e6c2922fdee // indirect
+	golang.org/x/term v0.2.0 // indirect
+	golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 // indirect
+	golang.zx2c4.com/wireguard/windows v0.5.3 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 require (
@@ -67,7 +122,7 @@ require (
 	github.com/hashicorp/go-version v1.6.0
 	github.com/josharian/native v1.0.0 // indirect
 	github.com/leodido/go-urn v1.2.1 // indirect
-	github.com/mattn/go-runewidth v0.0.10 // indirect
+	github.com/mattn/go-runewidth v0.0.13 // indirect
 	github.com/mdlayher/genetlink v1.2.0 // indirect
 	github.com/mdlayher/netlink v1.6.0 // indirect
 	github.com/mdlayher/socket v0.1.1 // indirect

logic/peers.go

@@ -193,6 +193,146 @@ func GetPeersForProxy(node *models.Node, onlyPeers bool) (proxy_models.ProxyMana
 	return proxyPayload, nil
 }
 
+func GetProxyUpdateForHost(host *models.Host) (proxy_models.ProxyManagerPayload, error) {
+	proxyPayload := proxy_models.ProxyManagerPayload{}
+	peerConfMap := make(map[string]proxy_models.PeerConf)
+
+	// ** TODO - RELAY NEEDS TO BE FIXED
+	// if !onlyPeers {
+	// 	if node.IsRelayed {
+	// 		relayNode := FindRelay(node)
+	// 		relayHost, err := GetHost(relayNode.HostID.String())
+	// 		if err != nil {
+	// 			return proxyPayload, err
+	// 		}
+	// 		if relayNode != nil {
+	// 			host, err := GetHost(relayNode.HostID.String())
+	// 			if err != nil {
+	// 				logger.Log(0, "error retrieving host for relay node", relayNode.HostID.String(), err.Error())
+	// 			}
+	// 			relayEndpoint, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", relayHost.EndpointIP, host.LocalListenPort))
+	// 			if err != nil {
+	// 				logger.Log(1, "failed to resolve relay node endpoint: ", err.Error())
+	// 			}
+	// 			proxyPayload.IsRelayed = true
+	// 			proxyPayload.RelayedTo = relayEndpoint
+	// 		} else {
+	// 			logger.Log(0, "couldn't find relay node for:  ", node.ID.String())
+	// 		}
+
+	// 	}
+	// 	if node.IsRelay {
+	// 		host, err := GetHost(node.HostID.String())
+	// 		if err != nil {
+	// 			logger.Log(0, "error retrieving host for relay node", node.ID.String(), err.Error())
+	// 		}
+	// 		relayedNodes, err := GetRelayedNodes(node)
+	// 		if err != nil {
+	// 			logger.Log(1, "failed to relayed nodes: ", node.ID.String(), err.Error())
+	// 			proxyPayload.IsRelay = false
+	// 		} else {
+	// 			relayPeersMap := make(map[string]proxy_models.RelayedConf)
+	// 			for _, relayedNode := range relayedNodes {
+	// 				payload, err := GetPeersForProxy(&relayedNode, true)
+	// 				if err == nil {
+	// 					relayedHost, err := GetHost(relayedNode.HostID.String())
+	// 					if err != nil {
+	// 						logger.Log(0, "error retrieving host for relayNode", relayedNode.ID.String(), err.Error())
+	// 					}
+	// 					relayedEndpoint, udpErr := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", relayedHost.EndpointIP, host.LocalListenPort))
+	// 					if udpErr == nil {
+	// 						relayPeersMap[host.PublicKey.String()] = proxy_models.RelayedConf{
+	// 							RelayedPeerEndpoint: relayedEndpoint,
+	// 							RelayedPeerPubKey:   relayedHost.PublicKey.String(),
+	// 							Peers:               payload.Peers,
+	// 						}
+	// 					}
+
+	// 				}
+	// 			}
+	// 			proxyPayload.IsRelay = true
+	// 			proxyPayload.RelayedPeerConf = relayPeersMap
+	// 		}
+	// 	}
+	// }
+
+	for _, nodeID := range host.Nodes {
+
+		node, err := GetNodeByID(nodeID)
+		if err != nil {
+			continue
+		}
+		currentPeers, err := GetNetworkNodes(node.Network)
+		if err == nil {
+			continue
+		}
+		for _, peer := range currentPeers {
+			if peer.ID == node.ID {
+				//skip yourself
+				continue
+			}
+			host, err := GetHost(peer.HostID.String())
+			if err != nil {
+				continue
+			}
+			proxyStatus := host.ProxyEnabled
+			listenPort := host.LocalListenPort
+			if proxyStatus {
+				listenPort = host.ProxyListenPort
+				if listenPort == 0 {
+					listenPort = proxy_models.NmProxyPort
+				}
+			} else if listenPort == 0 {
+				listenPort = host.ListenPort
+			}
+			if _, ok := peerConfMap[host.PublicKey.String()]; !ok {
+				peerConfMap[host.PublicKey.String()] = proxy_models.PeerConf{
+					Proxy:            proxyStatus,
+					PublicListenPort: int32(listenPort),
+					NetworkInfo:      make(map[string]proxy_models.NetworkInfo),
+				}
+			} else {
+				peerConfMap[host.PublicKey.String()].NetworkInfo[peer.Network] = proxy_models.NetworkInfo{
+					Address: net.IP(peer.PrimaryAddress()),
+				}
+			}
+
+			if peer.IsRelayed {
+				relayNode := FindRelay(&peer)
+				if relayNode != nil {
+					relayHost, err := GetHost(relayNode.HostID.String())
+					if err != nil {
+						logger.Log(0, "error retrieving host for relayNode", relayNode.ID.String(), err.Error())
+						continue
+					}
+					relayTo, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", relayHost.EndpointIP, relayHost.LocalListenPort))
+					if err == nil {
+						peerConfMap[host.PublicKey.String()] = proxy_models.PeerConf{
+							IsRelayed:        true,
+							RelayedTo:        relayTo,
+							Address:          net.ParseIP(peer.PrimaryAddress()),
+							Proxy:            proxyStatus,
+							PublicListenPort: int32(listenPort),
+						}
+					}
+
+				}
+
+			}
+		}
+
+	}
+
+	//proxyPayload.WgAddr = addr.String()
+	proxyPayload.PeerMap = peerConfMap
+	//proxyPayload.Network = node.Network
+	//proxyPayload.InterfaceName = node.Interface
+	//hardcode or read from host ??
+	proxyPayload.InterfaceName = models.WIREGUARD_INTERFACE
+
+	return proxyPayload, nil
+}
+
 // GetPeerUpdateForHost - gets the consolidated peer update for the host from all networks
 func GetPeerUpdateForHost(host *models.Host) (models.HostPeerUpdate, error) {
 	hostPeerUpdate := models.HostPeerUpdate{

mq/publishers.go

@@ -34,13 +34,13 @@ func PublishPeerUpdate(network string, publishToSelf bool) error {
 	return err
 }
 
-func PublishProxyPeerUpdate(node *models.Node) error {
-	proxyUpdate, err := logic.GetPeersForProxy(node, false)
+func PublishProxyPeerUpdate(host *models.Host) error {
+	proxyUpdate, err := logic.GetProxyUpdateForHost(host)
 	if err != nil {
 		return err
 	}
-	proxyUpdate.Action = proxy_models.AddNetwork
-	err = ProxyUpdate(&proxyUpdate, node)
+	proxyUpdate.Action = proxy_models.ProxyUpdate
+	err = ProxyUpdate(&proxyUpdate, host)
 	if err != nil {
 		logger.Log(1, "failed to send proxy update: ", err.Error())
 		return err
@@ -56,13 +56,13 @@ func PublishSingleHostUpdate(host *models.Host) error {
 		return err
 	}
 	if host.ProxyEnabled {
-		// proxyUpdate, err := logic.GetPeersForProxy(node, false)
-		// if err != nil {
-		// 	return err
-		// }
-		// proxyUpdate.Action = proxy_models.AddNetwork
-		// peerUpdate.ProxyUpdate = proxyUpdate
-
+		proxyUpdate, err := logic.GetProxyUpdateForHost(host)
+		if err != nil {
+			return err
+		}
+		proxyUpdate.Action = proxy_models.ProxyUpdate
+		proxyUpdate.Peers = peerUpdate.Peers
+		peerUpdate.ProxyUpdate = proxyUpdate
 	}
 
 	data, err := json.Marshal(&peerUpdate)
@@ -103,34 +103,25 @@ func NodeUpdate(node *models.Node) error {
 		logger.Log(2, "error publishing node update to peer ", node.ID.String(), err.Error())
 		return err
 	}
-	if host.ProxyEnabled {
-		err = PublishProxyPeerUpdate(node)
-		if err != nil {
-			logger.Log(1, "failed to publish proxy update to node", node.ID.String(), "on network", node.Network, ":", err.Error())
-		}
-	}
 
 	return nil
 }
 
 // ProxyUpdate -- publishes updates to peers related to proxy
-func ProxyUpdate(proxyPayload *proxy_models.ProxyManagerPayload, node *models.Node) error {
-	host, err := logic.GetHost(node.HostID.String())
-	if err != nil {
-		return nil
-	}
+func ProxyUpdate(proxyPayload *proxy_models.ProxyManagerPayload, host *models.Host) error {
+
 	if !servercfg.IsMessageQueueBackend() || !host.ProxyEnabled {
 		return nil
 	}
-	logger.Log(3, "publishing proxy update to "+node.ID.String())
+	logger.Log(3, "publishing proxy update to "+host.ID.String())
 
 	data, err := json.Marshal(proxyPayload)
 	if err != nil {
 		logger.Log(2, "error marshalling node update ", err.Error())
 		return err
 	}
-	if err = publish(host, fmt.Sprintf("proxy/%s/%s", node.Network, node.ID), data); err != nil {
-		logger.Log(2, "error publishing proxy update to peer ", node.ID.String(), err.Error())
+	if err = publish(host, fmt.Sprintf("proxy/%s/%s", host.ID, servercfg.GetServer()), data); err != nil {
+		logger.Log(2, "error publishing proxy update to peer ", host.ID.String(), err.Error())
 		return err
 	}
 	return nil