2022-01-03 00:02:59 +08:00
|
|
|
package functions
|
|
|
|
|
|
|
|
import (
|
2022-01-04 04:22:26 +08:00
|
|
|
"context"
|
2022-01-03 00:02:59 +08:00
|
|
|
"encoding/json"
|
|
|
|
"log"
|
2022-01-04 04:22:26 +08:00
|
|
|
"os"
|
|
|
|
"os/signal"
|
2022-01-11 03:35:53 +08:00
|
|
|
"runtime"
|
2022-01-04 04:22:26 +08:00
|
|
|
"syscall"
|
2022-01-03 00:02:59 +08:00
|
|
|
"time"
|
|
|
|
|
|
|
|
mqtt "github.com/eclipse/paho.mqtt.golang"
|
2022-01-05 23:05:51 +08:00
|
|
|
"github.com/gravitl/netmaker/models"
|
2022-01-03 00:02:59 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/config"
|
|
|
|
"github.com/gravitl/netmaker/netclient/ncutils"
|
2022-01-05 23:05:51 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/wireguard"
|
|
|
|
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
|
2022-01-03 00:02:59 +08:00
|
|
|
)
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// Daemon runs netclient daemon from command line
|
2022-01-03 00:02:59 +08:00
|
|
|
func Daemon() error {
|
2022-01-04 05:26:40 +08:00
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
2022-01-03 00:02:59 +08:00
|
|
|
networks, err := ncutils.GetSystemNetworks()
|
|
|
|
if err != nil {
|
2022-01-04 07:27:13 +08:00
|
|
|
cancel()
|
2022-01-03 00:02:59 +08:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
for _, network := range networks {
|
2022-01-16 07:16:44 +08:00
|
|
|
go MessageQueue(ctx, network)
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
2022-01-04 05:26:40 +08:00
|
|
|
quit := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(quit, syscall.SIGTERM, os.Interrupt)
|
|
|
|
<-quit
|
|
|
|
cancel()
|
2022-01-04 06:21:52 +08:00
|
|
|
ncutils.Log("all done")
|
2022-01-03 00:02:59 +08:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// SetupMQTT creates a connection to broker and return client
|
2022-01-21 18:19:17 +08:00
|
|
|
func SetupMQTT(cfg *config.ClientConfig) mqtt.Client {
|
2022-01-03 00:02:59 +08:00
|
|
|
opts := mqtt.NewClientOptions()
|
|
|
|
ncutils.Log("setting broker to " + cfg.Server.CoreDNSAddr + ":1883")
|
|
|
|
opts.AddBroker(cfg.Server.CoreDNSAddr + ":1883")
|
|
|
|
opts.SetDefaultPublishHandler(All)
|
|
|
|
client := mqtt.NewClient(opts)
|
|
|
|
if token := client.Connect(); token.Wait() && token.Error() != nil {
|
|
|
|
log.Fatal(token.Error())
|
|
|
|
}
|
2022-01-04 04:22:26 +08:00
|
|
|
return client
|
|
|
|
}
|
|
|
|
|
2022-01-16 07:16:44 +08:00
|
|
|
// MessageQueue sets up Message Queue and subsribes/publishes updates to/from server
|
|
|
|
func MessageQueue(ctx context.Context, network string) {
|
2022-01-04 06:21:52 +08:00
|
|
|
ncutils.Log("netclient go routine started for " + network)
|
2022-01-21 19:16:49 +08:00
|
|
|
var cfg config.ClientConfig
|
2022-01-04 06:21:52 +08:00
|
|
|
cfg.Network = network
|
|
|
|
cfg.ReadConfig()
|
|
|
|
ncutils.Log("daemon started for network:" + network)
|
2022-01-21 19:16:49 +08:00
|
|
|
client := SetupMQTT(&cfg)
|
2022-01-21 18:19:17 +08:00
|
|
|
if cfg.DebugOn {
|
|
|
|
if token := client.Subscribe("#", 0, nil); token.Wait() && token.Error() != nil {
|
|
|
|
log.Fatal(token.Error())
|
|
|
|
}
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
2022-01-20 04:00:03 +08:00
|
|
|
if token := client.Subscribe("update/"+cfg.Node.ID, 0, NodeUpdate); token.Wait() && token.Error() != nil {
|
|
|
|
log.Fatal(token.Error())
|
|
|
|
}
|
|
|
|
if token := client.Subscribe("/update/peers/"+cfg.Node.ID, 0, UpdatePeers); token.Wait() && token.Error() != nil {
|
|
|
|
log.Fatal(token.Error())
|
|
|
|
}
|
2022-01-04 06:21:52 +08:00
|
|
|
defer client.Disconnect(250)
|
2022-01-21 19:16:49 +08:00
|
|
|
go Checkin(ctx, &cfg, network)
|
2022-01-04 06:21:52 +08:00
|
|
|
<-ctx.Done()
|
|
|
|
ncutils.Log("shutting down daemon")
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// All -- mqtt message hander for all ('#') topics
|
2022-01-03 00:02:59 +08:00
|
|
|
var All mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
|
2022-01-20 04:00:03 +08:00
|
|
|
ncutils.Log("default message handler -- received message but not handling")
|
2022-01-03 00:02:59 +08:00
|
|
|
ncutils.Log("Topic: " + string(msg.Topic()))
|
2022-01-20 04:00:03 +08:00
|
|
|
//ncutils.Log("Message: " + string(msg.Payload()))
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// NodeUpdate -- mqtt message handler for /update/<NodeID> topic
|
2022-01-03 00:02:59 +08:00
|
|
|
var NodeUpdate mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
|
|
|
|
ncutils.Log("received message to update node " + string(msg.Payload()))
|
2022-01-05 23:05:51 +08:00
|
|
|
//potentiall blocking i/o so do this in a go routine
|
|
|
|
go func() {
|
2022-01-11 03:35:53 +08:00
|
|
|
var newNode models.Node
|
|
|
|
var cfg config.ClientConfig
|
|
|
|
cfg.Network = newNode.Network
|
|
|
|
cfg.ReadConfig()
|
|
|
|
err := json.Unmarshal(msg.Payload(), &newNode)
|
2022-01-05 23:05:51 +08:00
|
|
|
if err != nil {
|
|
|
|
ncutils.Log("error unmarshalling node update data" + err.Error())
|
|
|
|
return
|
|
|
|
}
|
2022-01-11 03:35:53 +08:00
|
|
|
//check if interface name has changed if so delete.
|
|
|
|
if cfg.Node.Interface != newNode.Interface {
|
|
|
|
if err = wireguard.RemoveConf(cfg.Node.Interface, true); err != nil {
|
2022-01-13 05:23:34 +08:00
|
|
|
ncutils.PrintLog("could not delete old interface "+cfg.Node.Interface+": "+err.Error(), 1)
|
2022-01-11 03:35:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
newNode.PullChanges = "no"
|
|
|
|
//ensure that OS never changes
|
|
|
|
newNode.OS = runtime.GOOS
|
|
|
|
cfg.Node = newNode
|
|
|
|
switch newNode.Action {
|
|
|
|
case models.NODE_DELETE:
|
2022-01-13 05:23:34 +08:00
|
|
|
if err := RemoveLocalInstance(&cfg, cfg.Network); err != nil {
|
|
|
|
ncutils.PrintLog("error deleting local instance: "+err.Error(), 1)
|
2022-01-11 03:35:53 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
case models.NODE_UPDATE_KEY:
|
2022-01-21 20:07:38 +08:00
|
|
|
if err := UpdateKeys(&cfg, client); err != nil {
|
|
|
|
ncutils.PrintLog("err updating wireguard keys: "+err.Error(), 1)
|
|
|
|
}
|
2022-01-11 03:35:53 +08:00
|
|
|
case models.NODE_NOOP:
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
//Save new config
|
|
|
|
if err := config.Write(&cfg, cfg.Network); err != nil {
|
|
|
|
ncutils.PrintLog("error updating node configuration: "+err.Error(), 1)
|
|
|
|
}
|
2022-01-05 23:05:51 +08:00
|
|
|
nameserver := cfg.Server.CoreDNSAddr
|
2022-01-13 05:23:34 +08:00
|
|
|
privateKey, err := wireguard.RetrievePrivKey(newNode.Network)
|
2022-01-06 00:07:09 +08:00
|
|
|
if err != nil {
|
2022-01-11 03:35:53 +08:00
|
|
|
ncutils.Log("error reading PrivateKey " + err.Error())
|
2022-01-06 00:07:09 +08:00
|
|
|
return
|
|
|
|
}
|
2022-01-13 05:23:34 +08:00
|
|
|
if err := wireguard.UpdateWgInterface(cfg.Node.Interface, privateKey, nameserver, newNode); err != nil {
|
2022-01-05 23:05:51 +08:00
|
|
|
ncutils.Log("error updating wireguard config " + err.Error())
|
|
|
|
return
|
|
|
|
}
|
2022-01-21 18:19:17 +08:00
|
|
|
file := ncutils.GetNetclientPathSpecific() + cfg.Node.Interface + ".conf"
|
|
|
|
ncutils.Log("applyWGQuickConf to " + file)
|
|
|
|
err = wireguard.ApplyWGQuickConf(file)
|
2022-01-05 23:05:51 +08:00
|
|
|
if err != nil {
|
2022-01-11 03:35:53 +08:00
|
|
|
ncutils.Log("error restarting wg after node update " + err.Error())
|
2022-01-05 23:05:51 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}()
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// UpdatePeers -- mqtt message handler for /update/peers/<NodeID> topic
|
2022-01-03 00:02:59 +08:00
|
|
|
var UpdatePeers mqtt.MessageHandler = func(client mqtt.Client, msg mqtt.Message) {
|
2022-01-05 23:05:51 +08:00
|
|
|
go func() {
|
|
|
|
var peerUpdate models.PeerUpdate
|
|
|
|
err := json.Unmarshal(msg.Payload(), &peerUpdate)
|
|
|
|
if err != nil {
|
|
|
|
ncutils.Log("error unmarshalling peer data")
|
|
|
|
return
|
|
|
|
}
|
2022-01-20 04:00:03 +08:00
|
|
|
ncutils.Log("update peer handler")
|
2022-01-05 23:05:51 +08:00
|
|
|
var cfg config.ClientConfig
|
|
|
|
cfg.Network = peerUpdate.Network
|
|
|
|
cfg.ReadConfig()
|
2022-01-16 07:16:44 +08:00
|
|
|
err = wireguard.UpdateWgPeers(cfg.Node.Interface, peerUpdate.Peers)
|
2022-01-15 03:30:26 +08:00
|
|
|
if err != nil {
|
|
|
|
ncutils.Log("error updating wireguard peers" + err.Error())
|
2022-01-05 23:05:51 +08:00
|
|
|
return
|
|
|
|
}
|
2022-01-20 04:00:03 +08:00
|
|
|
file := ncutils.GetNetclientPathSpecific() + cfg.Node.Interface + ".conf"
|
|
|
|
ncutils.Log("applyWGQuickConf to " + file)
|
|
|
|
err = wireguard.ApplyWGQuickConf(file)
|
2022-01-05 23:05:51 +08:00
|
|
|
if err != nil {
|
|
|
|
ncutils.Log("error restarting wg after peer update " + err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}()
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
|
|
|
|
2022-01-11 03:35:53 +08:00
|
|
|
// UpdateKeys -- updates private key and returns new publickey
|
2022-01-21 20:07:38 +08:00
|
|
|
func UpdateKeys(cfg *config.ClientConfig, client mqtt.Client) error {
|
2022-01-11 03:35:53 +08:00
|
|
|
ncutils.Log("received message to update keys")
|
2022-01-05 23:05:51 +08:00
|
|
|
//potentiall blocking i/o so do this in a go routine
|
2022-01-11 03:35:53 +08:00
|
|
|
key, err := wgtypes.GeneratePrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
ncutils.Log("error generating privatekey " + err.Error())
|
2022-01-21 20:07:38 +08:00
|
|
|
return err
|
2022-01-11 03:35:53 +08:00
|
|
|
}
|
2022-01-13 05:23:34 +08:00
|
|
|
if err := wireguard.UpdatePrivateKey(cfg.Node.Interface, key.String()); err != nil {
|
2022-01-11 03:35:53 +08:00
|
|
|
ncutils.Log("error updating wireguard key " + err.Error())
|
2022-01-21 20:07:38 +08:00
|
|
|
return err
|
2022-01-11 03:35:53 +08:00
|
|
|
}
|
2022-01-21 20:07:38 +08:00
|
|
|
cfg.Node.PublicKey = key.PublicKey().String()
|
|
|
|
PublishNodeUpdate(cfg)
|
2022-01-15 03:30:26 +08:00
|
|
|
if err := config.ModConfig(&cfg.Node); err != nil {
|
|
|
|
ncutils.Log("error updating local config " + err.Error())
|
|
|
|
}
|
2022-01-21 20:07:38 +08:00
|
|
|
return nil
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// Checkin -- go routine that checks for public or local ip changes, publishes changes
|
2022-01-04 04:22:26 +08:00
|
|
|
// if there are no updates, simply "pings" the server as a checkin
|
2022-01-21 18:19:17 +08:00
|
|
|
func Checkin(ctx context.Context, cfg *config.ClientConfig, network string) {
|
2022-01-04 06:21:52 +08:00
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
|
|
|
ncutils.Log("Checkin cancelled")
|
|
|
|
return
|
|
|
|
//delay should be configuraable -> use cfg.Node.NetworkSettings.DefaultCheckInInterval ??
|
2022-01-19 06:36:10 +08:00
|
|
|
case <-time.After(time.Second * 60):
|
2022-01-04 06:21:52 +08:00
|
|
|
ncutils.Log("Checkin running")
|
2022-01-15 03:30:26 +08:00
|
|
|
//read latest config
|
|
|
|
cfg.ReadConfig()
|
2022-01-04 06:21:52 +08:00
|
|
|
if cfg.Node.Roaming == "yes" && cfg.Node.IsStatic != "yes" {
|
|
|
|
extIP, err := ncutils.GetPublicIP()
|
|
|
|
if err != nil {
|
|
|
|
ncutils.PrintLog("error encountered checking ip addresses: "+err.Error(), 1)
|
|
|
|
}
|
|
|
|
if cfg.Node.Endpoint != extIP && extIP != "" {
|
|
|
|
ncutils.PrintLog("endpoint has changed from "+cfg.Node.Endpoint+" to "+extIP, 1)
|
2022-01-21 18:19:17 +08:00
|
|
|
cfg.Node.Endpoint = extIP
|
|
|
|
PublishNodeUpdate(cfg)
|
2022-01-04 06:21:52 +08:00
|
|
|
}
|
|
|
|
intIP, err := getPrivateAddr()
|
|
|
|
if err != nil {
|
|
|
|
ncutils.PrintLog("error encountered checking ip addresses: "+err.Error(), 1)
|
|
|
|
}
|
|
|
|
if cfg.Node.LocalAddress != intIP && intIP != "" {
|
|
|
|
ncutils.PrintLog("local Address has changed from "+cfg.Node.LocalAddress+" to "+intIP, 1)
|
2022-01-21 18:19:17 +08:00
|
|
|
cfg.Node.LocalAddress = intIP
|
|
|
|
PublishNodeUpdate(cfg)
|
2022-01-04 06:21:52 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
localIP, err := ncutils.GetLocalIP(cfg.Node.LocalRange)
|
|
|
|
if err != nil {
|
|
|
|
ncutils.PrintLog("error encountered checking ip addresses: "+err.Error(), 1)
|
|
|
|
}
|
|
|
|
if cfg.Node.Endpoint != localIP && localIP != "" {
|
|
|
|
ncutils.PrintLog("endpoint has changed from "+cfg.Node.Endpoint+" to "+localIP, 1)
|
2022-01-21 18:19:17 +08:00
|
|
|
cfg.Node.Endpoint = localIP
|
|
|
|
PublishNodeUpdate(cfg)
|
2022-01-04 06:21:52 +08:00
|
|
|
}
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
2022-01-04 06:21:52 +08:00
|
|
|
Hello(cfg, network)
|
|
|
|
ncutils.Log("Checkin complete")
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-21 18:19:17 +08:00
|
|
|
// PublishNodeUpdates -- saves node and pushes changes to broker
|
|
|
|
func PublishNodeUpdate(cfg *config.ClientConfig) {
|
|
|
|
if err := config.Write(cfg, cfg.Network); err != nil {
|
|
|
|
ncutils.Log("error saving configuration" + err.Error())
|
2022-01-15 03:30:26 +08:00
|
|
|
}
|
2022-01-04 04:22:26 +08:00
|
|
|
client := SetupMQTT(cfg)
|
2022-01-21 18:19:17 +08:00
|
|
|
data, err := json.Marshal(cfg.Node)
|
|
|
|
if err != nil {
|
|
|
|
ncutils.Log("error marshling node update " + err.Error())
|
2022-01-03 00:02:59 +08:00
|
|
|
}
|
2022-01-21 18:19:17 +08:00
|
|
|
if token := client.Publish("update/"+cfg.Node.ID, 0, false, data); token.Wait() && token.Error() != nil {
|
|
|
|
ncutils.Log("error publishing endpoint update " + token.Error().Error())
|
2022-01-15 03:30:26 +08:00
|
|
|
}
|
2022-01-04 04:22:26 +08:00
|
|
|
client.Disconnect(250)
|
|
|
|
}
|
|
|
|
|
2022-01-04 07:27:13 +08:00
|
|
|
// Hello -- ping the broker to let server know node is alive and doing fine
|
2022-01-21 18:19:17 +08:00
|
|
|
func Hello(cfg *config.ClientConfig, network string) {
|
2022-01-04 04:22:26 +08:00
|
|
|
client := SetupMQTT(cfg)
|
2022-01-15 03:30:26 +08:00
|
|
|
ncutils.Log("sending ping " + cfg.Node.ID)
|
|
|
|
if token := client.Publish("ping/"+cfg.Node.ID, 2, false, "hello world!"); token.Wait() && token.Error() != nil {
|
2022-01-04 04:22:26 +08:00
|
|
|
ncutils.Log("error publishing ping " + token.Error().Error())
|
|
|
|
}
|
|
|
|
client.Disconnect(250)
|
|
|
|
}
|