gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2024-09-22 00:06:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix publish peers

Browse source
This commit is contained in:
Matthew R Kasun 2022-01-18 22:32:12 +00:00
parent cec92773b5
commit a926709c10
4 changed files with 124 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
controllers/node_grpc.go
View file

@ -10,6 +10,7 @@ import (
"github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/mq"
"github.com/gravitl/netmaker/servercfg"
)
@ -85,6 +86,10 @@ 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.NewPeer(node); err != nil {
logger.Log(0, "failed to inform peers of new node "+err.Error())
}
return response, nil
}

52
logic/nodes.go
View file

@ -4,7 +4,9 @@ import (
"encoding/json"
"errors"
"fmt"
"net"
"sort"
"strconv"
"strings"
"time"
@ -14,6 +16,7 @@ import (
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/servercfg"
"github.com/gravitl/netmaker/validation"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
)
// GetNetworkNodes - gets the nodes of a network
@ -83,11 +86,52 @@ func UncordonNode(nodeid string) (models.Node, error) {
return node, err
}
// GetPeers - gets the peers of a given node
func GetPeers(node *models.Node) ([]models.Node, error) {
if IsLeader(node) {
SetNetworkServerPeers(node)
// GetWGNodePeers - gets the wg peers of a given node
func GetWGNodePeers(node *models.Node) ([]wgtypes.PeerConfig, error){
var peers []wgtypes.PeerConfig
var peerData wgtypes.PeerConfig
nodes, err := GetPeers(node)
if err != nil {
return peers, err
}
logger.Log(0, "the peers of " + node.Name + " are:")
for _, peer := range nodes {
logger.Log(0, "peer: " + peer.Name)
}
for _, peer := range nodes {
//this should not happen but it does
if peer.Name == node.Name {
logger.Log(0, "GetPeers returned me " + node.Name)
continue
}
pubkey, err :=wgtypes.ParseKey(peer.PublicKey)
if err != nil {
logger.Log(0, "ParseKey failed " +err.Error())
continue
}
endpoint := peer.Endpoint + ":" + strconv.Itoa(int(peer.ListenPort))
address, err := net.ResolveUDPAddr("udp", endpoint)
if err != nil {
logger.Log(0, "could not resolve endpoint " + err.Error())
continue
}
///Persitent Keepalive
//Allowed IPs
peerData = wgtypes.PeerConfig{
PublicKey: pubkey,
Endpoint: address,
}
peers = append (peers, peerData)
}
return peers, nil
}
// GetPeers - gets a list of nodes that are peers of a given node
func GetPeers(node *models.Node) ([]models.Node, error) {
//if IsLeader(node) {
// logger.Log(0, node.Name + " is a leader")
// SetNetworkServerPeers(node)
//}
excludeIsRelayed := node.IsRelay != "yes"
var relayedNode string
if node.IsRelayed == "yes" {

4
main.go
View file

@ -208,10 +208,6 @@ func runMessageQueue(wg *sync.WaitGroup) {
client.Disconnect(240)
logger.Log(0, "ping sub failed")
}
if token := client.Subscribe("metrics/#", 0, mq.Metrics); token.Wait() && token.Error() != nil {
client.Disconnect(240)
logger.Log(0, "metrics sub failed")
}
if token := client.Subscribe("update/localaddress/#", 0, mq.LocalAddressUpdate); token.Wait() && token.Error() != nil {
client.Disconnect(240)
logger.Log(0, "metrics sub failed")

86
mq/mq.go
View file

@ -3,24 +3,24 @@ package mq
import (
"encoding/json"
"errors"
"net"
"strconv"
"strings"
"time"
mqtt "github.com/eclipse/paho.mqtt.golang"
"github.com/gravitl/netmaker/database"
"github.com/gravitl/netmaker/logger"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/gravitl/netmaker/servercfg"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
)
var DefaultHandler mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
logger.Log(0, "MQTT Message: Topic: "+string(msg.Topic())+" Message: "+string(msg.Payload()))
}
var Metrics mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
logger.Log(0, "Metrics Handler")
//TODOD -- handle metrics data ---- store to database?
}
var Ping mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
logger.Log(0, "Ping Handler: "+msg.Topic())
go func() {
@ -42,6 +42,9 @@ var Ping mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
return
}
node.SetLastCheckIn()
if err := logic.UpdateNode(&node, &node) ; err != nil {
logger.Log(0, "error updating node "+ err.Error())
}
logger.Log(0, "ping processed")
// --TODO --set client version once feature is implemented.
//node.SetClientVersion(msg.Payload())
@ -63,6 +66,9 @@ var PublicKeyUpdate mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Mess
}
node.PublicKey = key
node.SetLastCheckIn()
if err := logic.UpdateNode(&node, &node) ; err != nil {
logger.Log(0, "error updating node "+ err.Error())
}
if err := UpdatePeers(client, node); err != nil {
logger.Log(0, "error updating peers "+err.Error())
}
@ -86,36 +92,64 @@ var IPUpdate mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
}
node.Endpoint = ip
node.SetLastCheckIn()
if err := logic.UpdateNode(&node, &node) ; err != nil {
logger.Log(0, "error updating node "+ err.Error())
}
if err != UpdatePeers(client, node) {
logger.Log(0, "error updating peers "+err.Error())
}
}()
}
func UpdatePeers(client mqtt.Client, node models.Node) error {
peersToUpdate, err := logic.GetNetworkNodes(node.Network)
func UpdatePeers(client mqtt.Client, newnode models.Node) error {
networkNodes, err := logic.GetNetworkNodes(newnode.Network)
if err != nil {
logger.Log(0, "error retrieving peers to be updated "+err.Error())
return err
}
for _, peerToUpdate := range peersToUpdate {
peers, _, _, err := logic.GetServerPeers(&peerToUpdate)
if err != nil {
logger.Log(0, "error retrieving peers "+err.Error())
return err
}
if peerToUpdate.ID == node.ID {
keepalive, _ := time.ParseDuration(string(newnode.PersistentKeepalive)+"s")
for _, node := range networkNodes {
var peers []wgtypes.PeerConfig
var peerUpdate models.PeerUpdate
for _, peer := range networkNodes{
if peer.ID == node.ID {
//skip
continue
}
var peerUpdate models.PeerUpdate
pubkey, err := wgtypes.ParseKey(peer.PublicKey)
if err != nil {
return err
}
if node.Endpoint == peer.Endpoint {
if node.LocalAddress != peer.LocalAddress && peer.LocalAddress != "" {
peer.Endpoint = peer.LocalAddress
}else {
continue
}
}
endpoint := peer.Endpoint + ":" + strconv.Itoa(int(peer.ListenPort))
//fmt.Println("endpoint: ", endpoint, peer.Endpoint, peer.ListenPort)
address, err := net.ResolveUDPAddr("udp", endpoint)
if err != nil {
return err
}
//calculate Allowed IPs.
var peerData wgtypes.PeerConfig
peerData = wgtypes.PeerConfig{
PublicKey: pubkey,
Endpoint: address,
PersistentKeepaliveInterval: &keepalive,
//AllowedIPs: allowedIPs
}
peers = append (peers, peerData)
}
peerUpdate.Network = node.Network
peerUpdate.Peers = peers
data, err := json.Marshal(peerUpdate)
data, err := json.Marshal(&peerUpdate)
if err != nil {
logger.Log(0, "error marshaling peer update "+err.Error())
return err
}
if token := client.Publish("/update/peers/"+peerToUpdate.ID, 0, false, data); token.Wait() && token.Error() != nil {
if token := client.Publish("/update/peers/"+node.ID, 0, false, data); token.Wait() && token.Error() != nil {
logger.Log(0, "error sending peer updatte to no")
return err
}
@ -154,3 +188,19 @@ func GetID(topic string) (string, error) {
//the last part of the topic will be the node.ID
return parts[count-1], nil
}
func NewPeer(node models.Node) error {
opts := mqtt.NewClientOptions()
broker := servercfg.GetMessageQueueEndpoint()
logger.Log(0, "broker: "+broker)
opts.AddBroker(broker)
client := mqtt.NewClient(opts)
if token := client.Connect(); token.Wait() && token.Error() != nil {
return token.Error()
}
if err := UpdatePeers(client, node); err != nil {
return err
}
return nil
}