2022-02-19 00:34:18 +08:00
|
|
|
package functions
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"encoding/json"
|
2022-04-19 05:19:26 +08:00
|
|
|
"errors"
|
2022-02-19 00:34:18 +08:00
|
|
|
"fmt"
|
2022-05-19 21:11:56 +08:00
|
|
|
"net"
|
2022-04-19 05:19:26 +08:00
|
|
|
"os"
|
2022-05-25 22:31:44 +08:00
|
|
|
"strconv"
|
2022-02-19 00:34:18 +08:00
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
2022-05-19 21:11:56 +08:00
|
|
|
"github.com/cloverstd/tcping/ping"
|
2022-03-20 23:12:05 +08:00
|
|
|
"github.com/gravitl/netmaker/logger"
|
2022-02-19 00:34:18 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/auth"
|
|
|
|
"github.com/gravitl/netmaker/netclient/config"
|
2022-06-01 00:07:56 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/daemon"
|
2022-02-19 00:34:18 +08:00
|
|
|
"github.com/gravitl/netmaker/netclient/ncutils"
|
2022-04-19 05:19:26 +08:00
|
|
|
"github.com/gravitl/netmaker/tls"
|
2022-02-19 00:34:18 +08:00
|
|
|
)
|
|
|
|
|
2022-05-25 02:19:47 +08:00
|
|
|
// pubNetworks hold the currently publishable networks
|
|
|
|
var pubNetworks []string
|
|
|
|
|
2022-02-19 00:34:18 +08:00
|
|
|
// Checkin -- go routine that checks for public or local ip changes, publishes changes
|
|
|
|
// if there are no updates, simply "pings" the server as a checkin
|
2022-04-25 18:38:20 +08:00
|
|
|
func Checkin(ctx context.Context, wg *sync.WaitGroup) {
|
2022-02-19 00:34:18 +08:00
|
|
|
defer wg.Done()
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
2022-03-20 23:12:05 +08:00
|
|
|
logger.Log(0, "checkin routine closed")
|
2022-02-19 00:34:18 +08:00
|
|
|
return
|
|
|
|
//delay should be configuraable -> use cfg.Node.NetworkSettings.DefaultCheckInInterval ??
|
|
|
|
case <-time.After(time.Second * 60):
|
2022-05-25 02:19:47 +08:00
|
|
|
for _, network := range pubNetworks {
|
2022-04-12 22:43:02 +08:00
|
|
|
var nodeCfg config.ClientConfig
|
|
|
|
nodeCfg.Network = network
|
|
|
|
nodeCfg.ReadConfig()
|
|
|
|
if nodeCfg.Node.IsStatic != "yes" {
|
|
|
|
extIP, err := ncutils.GetPublicIP()
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(1, "error encountered checking public ip addresses: ", err.Error())
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
2022-04-12 22:43:02 +08:00
|
|
|
if nodeCfg.Node.Endpoint != extIP && extIP != "" {
|
|
|
|
logger.Log(1, "endpoint has changed from ", nodeCfg.Node.Endpoint, " to ", extIP)
|
|
|
|
nodeCfg.Node.Endpoint = extIP
|
|
|
|
if err := PublishNodeUpdate(&nodeCfg); err != nil {
|
|
|
|
logger.Log(0, "could not publish endpoint change")
|
2022-02-19 03:56:26 +08:00
|
|
|
}
|
2022-04-12 22:43:02 +08:00
|
|
|
}
|
|
|
|
intIP, err := getPrivateAddr()
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(1, "error encountered checking private ip addresses: ", err.Error())
|
|
|
|
}
|
|
|
|
if nodeCfg.Node.LocalAddress != intIP && intIP != "" {
|
|
|
|
logger.Log(1, "local Address has changed from ", nodeCfg.Node.LocalAddress, " to ", intIP)
|
|
|
|
nodeCfg.Node.LocalAddress = intIP
|
|
|
|
if err := PublishNodeUpdate(&nodeCfg); err != nil {
|
|
|
|
logger.Log(0, "could not publish local address change")
|
2022-02-19 03:56:26 +08:00
|
|
|
}
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
2022-04-22 20:36:42 +08:00
|
|
|
_ = UpdateLocalListenPort(&nodeCfg)
|
|
|
|
|
2022-04-12 22:43:02 +08:00
|
|
|
} else if nodeCfg.Node.IsLocal == "yes" && nodeCfg.Node.LocalRange != "" {
|
|
|
|
localIP, err := ncutils.GetLocalIP(nodeCfg.Node.LocalRange)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(1, "error encountered checking local ip addresses: ", err.Error())
|
|
|
|
}
|
|
|
|
if nodeCfg.Node.Endpoint != localIP && localIP != "" {
|
|
|
|
logger.Log(1, "endpoint has changed from "+nodeCfg.Node.Endpoint+" to ", localIP)
|
|
|
|
nodeCfg.Node.Endpoint = localIP
|
|
|
|
if err := PublishNodeUpdate(&nodeCfg); err != nil {
|
|
|
|
logger.Log(0, "could not publish localip change")
|
|
|
|
}
|
2022-02-19 23:45:25 +08:00
|
|
|
}
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
2022-05-03 23:43:15 +08:00
|
|
|
Hello(&nodeCfg)
|
2022-04-19 05:19:26 +08:00
|
|
|
checkCertExpiry(&nodeCfg)
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// PublishNodeUpdates -- saves node and pushes changes to broker
|
2022-04-12 22:43:02 +08:00
|
|
|
func PublishNodeUpdate(nodeCfg *config.ClientConfig) error {
|
2022-02-19 23:45:25 +08:00
|
|
|
if err := config.Write(nodeCfg, nodeCfg.Network); err != nil {
|
2022-02-19 00:34:18 +08:00
|
|
|
return err
|
|
|
|
}
|
2022-02-19 23:45:25 +08:00
|
|
|
data, err := json.Marshal(nodeCfg.Node)
|
2022-02-19 00:34:18 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-04-12 22:43:02 +08:00
|
|
|
if err = publish(nodeCfg, fmt.Sprintf("update/%s", nodeCfg.Node.ID), data, 1); err != nil {
|
2022-02-19 00:34:18 +08:00
|
|
|
return err
|
|
|
|
}
|
2022-04-22 20:36:42 +08:00
|
|
|
|
2022-03-20 23:12:05 +08:00
|
|
|
logger.Log(0, "sent a node update to server for node", nodeCfg.Node.Name, ", ", nodeCfg.Node.ID)
|
2022-02-19 00:34:18 +08:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-02-19 23:45:25 +08:00
|
|
|
// Hello -- ping the broker to let server know node it's alive and well
|
2022-04-12 22:43:02 +08:00
|
|
|
func Hello(nodeCfg *config.ClientConfig) {
|
|
|
|
if err := publish(nodeCfg, fmt.Sprintf("ping/%s", nodeCfg.Node.ID), []byte(ncutils.Version), 0); err != nil {
|
2022-03-20 23:12:05 +08:00
|
|
|
logger.Log(0, fmt.Sprintf("error publishing ping, %v", err))
|
2022-04-12 22:43:02 +08:00
|
|
|
logger.Log(0, "running pull on "+nodeCfg.Node.Network+" to reconnect")
|
|
|
|
_, err := Pull(nodeCfg.Node.Network, true)
|
2022-02-19 00:34:18 +08:00
|
|
|
if err != nil {
|
2022-04-12 22:43:02 +08:00
|
|
|
logger.Log(0, "could not run pull on "+nodeCfg.Node.Network+", error: "+err.Error())
|
2022-06-01 00:07:56 +08:00
|
|
|
} else {
|
|
|
|
daemon.Restart()
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
|
|
|
}
|
2022-05-20 22:50:11 +08:00
|
|
|
logger.Log(3, "checkin for", nodeCfg.Network, "complete")
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
|
|
|
|
2022-04-22 17:21:35 +08:00
|
|
|
// node cfg is required in order to fetch the traffic keys of that node for encryption
|
2022-04-12 22:43:02 +08:00
|
|
|
func publish(nodeCfg *config.ClientConfig, dest string, msg []byte, qos byte) error {
|
2022-02-19 00:34:18 +08:00
|
|
|
// setup the keys
|
2022-02-19 23:45:25 +08:00
|
|
|
trafficPrivKey, err := auth.RetrieveTrafficKey(nodeCfg.Node.Network)
|
2022-02-19 00:34:18 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-02-19 23:45:25 +08:00
|
|
|
serverPubKey, err := ncutils.ConvertBytesToKey(nodeCfg.Node.TrafficKeys.Server)
|
2022-02-19 00:34:18 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-05-20 22:50:11 +08:00
|
|
|
client, err := setupMQTT(nodeCfg, true)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("mq setup error %w", err)
|
|
|
|
}
|
2022-02-19 00:34:18 +08:00
|
|
|
defer client.Disconnect(250)
|
|
|
|
encrypted, err := ncutils.Chunk(msg, serverPubKey, trafficPrivKey)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-04-30 03:34:08 +08:00
|
|
|
if token := client.Publish(dest, qos, false, encrypted); !token.WaitTimeout(30*time.Second) || token.Error() != nil {
|
|
|
|
logger.Log(0, "could not connect to broker at "+nodeCfg.Server.Server+":8883")
|
|
|
|
var err error
|
|
|
|
if token.Error() == nil {
|
|
|
|
err = errors.New("connection timeout")
|
|
|
|
} else {
|
|
|
|
err = token.Error()
|
|
|
|
}
|
|
|
|
if err != nil {
|
2022-05-19 21:11:56 +08:00
|
|
|
return err
|
2022-04-30 03:34:08 +08:00
|
|
|
}
|
2022-02-19 00:34:18 +08:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2022-04-19 05:19:26 +08:00
|
|
|
|
|
|
|
func checkCertExpiry(cfg *config.ClientConfig) error {
|
2022-04-26 08:07:47 +08:00
|
|
|
cert, err := tls.ReadCert(ncutils.GetNetclientServerPath(cfg.Server.Server) + ncutils.GetSeparator() + "client.pem")
|
2022-04-19 05:19:26 +08:00
|
|
|
//if cert doesn't exist or will expire within 10 days
|
|
|
|
if errors.Is(err, os.ErrNotExist) || cert.NotAfter.Before(time.Now().Add(time.Hour*24*10)) {
|
2022-04-26 08:07:47 +08:00
|
|
|
key, err := tls.ReadKey(ncutils.GetNetclientPath() + ncutils.GetSeparator() + "client.key")
|
2022-04-19 05:19:26 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return RegisterWithServer(key, cfg)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2022-05-19 21:11:56 +08:00
|
|
|
|
2022-05-31 00:39:33 +08:00
|
|
|
func checkBroker(broker string, port string) error {
|
|
|
|
if broker == "" {
|
2022-05-31 00:54:30 +08:00
|
|
|
return errors.New("error: broker address is blank")
|
2022-05-31 00:39:33 +08:00
|
|
|
}
|
2022-05-31 00:56:58 +08:00
|
|
|
if port == "" {
|
|
|
|
return errors.New("error: broker port is blank")
|
|
|
|
}
|
2022-05-19 21:11:56 +08:00
|
|
|
_, err := net.LookupIP(broker)
|
|
|
|
if err != nil {
|
2022-05-20 22:50:11 +08:00
|
|
|
return errors.New("nslookup failed for broker ... check dns records")
|
2022-05-19 21:11:56 +08:00
|
|
|
}
|
|
|
|
pinger := ping.NewTCPing()
|
2022-05-31 00:39:33 +08:00
|
|
|
intPort, err := strconv.Atoi(port)
|
2022-05-25 22:31:44 +08:00
|
|
|
if err != nil {
|
2022-05-31 00:39:33 +08:00
|
|
|
logger.Log(1, "error converting port to int: "+err.Error())
|
|
|
|
}
|
2022-05-19 21:11:56 +08:00
|
|
|
pinger.SetTarget(&ping.Target{
|
|
|
|
Protocol: ping.TCP,
|
|
|
|
Host: broker,
|
2022-05-31 00:39:33 +08:00
|
|
|
Port: intPort,
|
2022-05-19 21:11:56 +08:00
|
|
|
Counter: 3,
|
|
|
|
Interval: 1 * time.Second,
|
|
|
|
Timeout: 2 * time.Second,
|
|
|
|
})
|
|
|
|
pingerDone := pinger.Start()
|
|
|
|
<-pingerDone
|
|
|
|
if pinger.Result().SuccessCounter == 0 {
|
2022-05-20 22:50:11 +08:00
|
|
|
return errors.New("unable to connect to broker port ... check netmaker server and firewalls")
|
2022-05-19 21:11:56 +08:00
|
|
|
}
|
2022-05-20 22:50:11 +08:00
|
|
|
return nil
|
2022-05-19 21:11:56 +08:00
|
|
|
}
|