Feature: Auto-update client

client/internal/engine.go

@@ -50,6 +50,7 @@ import (
 	"github.com/netbirdio/netbird/client/internal/routemanager"
 	"github.com/netbirdio/netbird/client/internal/routemanager/systemops"
 	"github.com/netbirdio/netbird/client/internal/statemanager"
+	"github.com/netbirdio/netbird/client/internal/updatemanager"
 	cProto "github.com/netbirdio/netbird/client/proto"
 	"github.com/netbirdio/netbird/shared/management/domain"
 	semaphoregroup "github.com/netbirdio/netbird/util/semaphore-group"
@@ -198,6 +199,9 @@ type Engine struct {
 	latestSyncResponse  *mgmProto.SyncResponse
 	connSemaphore       *semaphoregroup.SemaphoreGroup
 	flowManager         nftypes.FlowManager
+
+	// auto-update
+	updateManager *updatemanager.UpdateManager
 }
 
 // Peer is an instance of the Connection Peer
@@ -240,6 +244,7 @@ func NewEngine(
 		statusRecorder: statusRecorder,
 		checks:         checks,
 		connSemaphore:  semaphoregroup.NewSemaphoreGroup(connInitLimit),
+		updateManager:  updatemanager.NewUpdateManager(clientCtx, statusRecorder),
 	}
 
 	sm := profilemanager.NewServiceManager("")
@@ -306,6 +311,10 @@ func (e *Engine) Stop() error {
 		e.srWatcher.Close()
 	}
 
+	if e.updateManager != nil {
+		e.updateManager.Stop()
+	}
+
 	e.statusRecorder.ReplaceOfflinePeers([]peer.State{})
 	e.statusRecorder.UpdateDNSStates([]peer.NSGroupState{})
 	e.statusRecorder.UpdateRelayStates([]relay.ProbeResult{})
@@ -696,6 +705,9 @@ func (e *Engine) handleSync(update *mgmProto.SyncResponse) error {
 	e.syncMsgMux.Lock()
 	defer e.syncMsgMux.Unlock()
 
+	if update.GetAutoUpdateVersion() != "skip" {
+		e.updateManager.SetVersion(update.GetAutoUpdateVersion())
+	}
 	if update.GetNetbirdConfig() != nil {
 		wCfg := update.GetNetbirdConfig()
 		err := e.updateTURNs(wCfg.GetTurns())

client/internal/updatemanager/manager.go

@@ -0,0 +1,183 @@
+package updatemanager
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	v "github.com/hashicorp/go-version"
+	log "github.com/sirupsen/logrus"
+
+	"github.com/netbirdio/netbird/client/internal/peer"
+	cProto "github.com/netbirdio/netbird/client/proto"
+	"github.com/netbirdio/netbird/version"
+)
+
+const (
+	latestVersion     = "latest"
+	disableAutoUpdate = "disabled"
+	unknownVersion    = "Unknown"
+)
+
+type UpdateManager struct {
+	ctx            context.Context
+	cancel         context.CancelFunc
+	version        string
+	latestVersion  string
+	update         *version.Update
+	lastTrigger    time.Time
+	statusRecorder *peer.Status
+	mutex          sync.Mutex
+	waitGroup      sync.WaitGroup
+}
+
+func NewUpdateManager(ctx context.Context, statusRecorder *peer.Status) *UpdateManager {
+	update := version.NewUpdate("nb/client")
+	ctx, cancel := context.WithCancel(ctx)
+	manager := &UpdateManager{
+		update:         update,
+		lastTrigger:    time.Now().Add(-10 * time.Minute),
+		statusRecorder: statusRecorder,
+		ctx:            ctx,
+		cancel:         cancel,
+		version:        disableAutoUpdate,
+		latestVersion:  unknownVersion,
+	}
+	update.SetDaemonVersion(version.NetbirdVersion())
+	update.SetOnUpdateListener(manager.Updated)
+	return manager
+}
+
+func (u *UpdateManager) SetVersion(v string) {
+	u.mutex.Lock()
+	if u.version != v {
+		log.Tracef("Auto-update version set to %s", v)
+		u.version = v
+		u.mutex.Unlock()
+		go u.Updated("N/A")
+	} else {
+		u.mutex.Unlock()
+	}
+}
+
+func (u *UpdateManager) Stop() {
+	u.update.StopWatch()
+	u.cancel()
+	u.waitGroup.Wait()
+}
+
+func (u *UpdateManager) Updated(latestVersion string) {
+	u.waitGroup.Add(1)
+	defer u.waitGroup.Done()
+	u.mutex.Lock()
+	defer u.mutex.Unlock()
+	select {
+	case <-u.ctx.Done():
+		return
+	default:
+	}
+	if latestVersion != "N/A" {
+		u.latestVersion = latestVersion
+	}
+	ctx, cancel := context.WithDeadline(u.ctx, time.Now().Add(time.Minute))
+	defer cancel()
+	u.CheckForUpdates(ctx)
+}
+
+func (u *UpdateManager) CheckForUpdates(ctx context.Context) {
+	if u.version == disableAutoUpdate {
+		log.Trace("Skipped checking for updates, auto-update is disabled")
+		return
+	}
+	currentVersionString := version.NetbirdVersion()
+	updateVersionString := u.version
+	if updateVersionString == latestVersion || updateVersionString == "" {
+		if u.latestVersion == unknownVersion {
+			log.Tracef("Latest version not fetched yet")
+			return
+		}
+		updateVersionString = u.latestVersion
+	}
+	currentVersion, err := v.NewVersion(currentVersionString)
+	if err != nil {
+		log.Errorf("Error checking for update, error parsing version `%s`: %v", currentVersionString, err)
+		return
+	}
+	updateVersion, err := v.NewVersion(updateVersionString)
+	if err != nil {
+		log.Errorf("Error checking for update, error parsing version `%s`: %v", updateVersionString, err)
+		return
+	}
+	if currentVersion.LessThan(updateVersion) {
+		if u.lastTrigger.Add(5 * time.Minute).Before(time.Now()) {
+			u.lastTrigger = time.Now()
+			log.Debugf("Auto-update triggered, current version: %s, target version: %s", currentVersionString, updateVersionString)
+			u.statusRecorder.PublishEvent(
+				cProto.SystemEvent_INFO,
+				cProto.SystemEvent_SYSTEM,
+				"Automatically updating client",
+				"Your client version is older than auto-update version set in Management, updating client now.",
+				nil,
+			)
+			err = u.triggerUpdate(ctx, updateVersionString)
+			if err != nil {
+				log.Errorf("Error triggering auto-update: %v", err)
+			}
+		}
+	} else {
+		log.Debugf("Current version (%s) is equal to or higher than auto-update version (%s)", currentVersionString, updateVersionString)
+	}
+}
+
+func downloadFileToTemporaryDir(ctx context.Context, fileURL string) (string, error) { //nolint:unused
+	tempDir, err := os.MkdirTemp("", "netbird-installer-*")
+	if err != nil {
+		return "", fmt.Errorf("error creating temporary directory: %w", err)
+	}
+	fileNameParts := strings.Split(fileURL, "/")
+	out, err := os.Create(filepath.Join(tempDir, fileNameParts[len(fileNameParts)-1]))
+	if err != nil {
+		return "", fmt.Errorf("error creating temporary file: %w", err)
+	}
+	defer func() {
+		if err := out.Close(); err != nil {
+			log.Errorf("Error closing temporary file: %v", err)
+		}
+	}()
+
+	req, err := http.NewRequestWithContext(ctx, "GET", fileURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("error creating file download request: %w", err)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("error downloading file: %w", err)
+	}
+	defer func() {
+		if err := resp.Body.Close(); err != nil {
+			log.Errorf("Error closing response body: %v", err)
+		}
+	}()
+
+	_, err = io.Copy(out, resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("error downloading file: %w", err)
+	}
+
+	log.Tracef("Downloaded update file to %s", out.Name())
+
+	return out.Name(), nil
+}
+
+func urlWithVersionArch(url, version string) string { //nolint:unused
+	url = strings.ReplaceAll(url, "%version", version)
+	url = strings.ReplaceAll(url, "%arch", runtime.GOARCH)
+	return url
+}

client/internal/updatemanager/update_darwin.go

@@ -0,0 +1,112 @@
+//go:build darwin
+
+package updatemanager
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"os/user"
+	"strings"
+	"syscall"
+)
+
+const (
+	pkgDownloadURL = "https://github.com/netbirdio/netbird/releases/download/v%version/netbird_%version_darwin_%arch.pkg"
+)
+
+func (u *UpdateManager) triggerUpdate(ctx context.Context, targetVersion string) error {
+	cmd := exec.CommandContext(ctx, "pkgutil", "--pkg-info", "io.netbird.client")
+	outBytes, err := cmd.Output()
+	if err != nil && cmd.ProcessState.ExitCode() == 1 {
+		// Not installed using pkg file, thus installed using Homebrew
+
+		return u.updateHomeBrew(ctx)
+	}
+	// Installed using pkg file
+	path, err := downloadFileToTemporaryDir(ctx, urlWithVersionArch(pkgDownloadURL, targetVersion))
+	if err != nil {
+		return fmt.Errorf("error downloading update file: %w", err)
+	}
+
+	volume := "/"
+	for _, v := range strings.Split(string(outBytes), "\n") {
+		trimmed := strings.TrimSpace(v)
+		if strings.HasPrefix(trimmed, "volume: ") {
+			volume = strings.Split(trimmed, ": ")[1]
+		}
+	}
+
+	cmd = exec.CommandContext(ctx, "installer", "-pkg", path, "-target", volume)
+
+	err = cmd.Start()
+	if err != nil {
+		return fmt.Errorf("error running pkg file: %w", err)
+	}
+	err = cmd.Process.Release()
+
+	return err
+}
+
+func (u *UpdateManager) updateHomeBrew(ctx context.Context) error {
+	// Homebrew must be run as a non-root user
+	// To find out which user installed NetBird using HomeBrew we can check the owner of our brew tap directory
+	fileInfo, err := os.Stat("/opt/homebrew/Library/Taps/netbirdio/homebrew-tap/")
+	if err != nil {
+		return fmt.Errorf("error getting homebrew installation path info: %w", err)
+	}
+
+	fileSysInfo, ok := fileInfo.Sys().(*syscall.Stat_t)
+	if !ok {
+		return fmt.Errorf("error checking file owner, sysInfo type is %T not *syscall.Stat_t", fileInfo.Sys())
+	}
+
+	// Get username from UID
+	installer, err := user.LookupId(fmt.Sprintf("%d", fileSysInfo.Uid))
+	if err != nil {
+		return fmt.Errorf("error looking up brew installer user: %w", err)
+	}
+	userName := installer.Name
+	// Get user HOME, required for brew to run correctly
+	// https://github.com/Homebrew/brew/issues/15833
+	homeDir := installer.HomeDir
+	// Homebrew does not support installing specific versions
+	// Thus it will always update to latest and ignore targetVersion
+	upgradeArgs := []string{"-u", userName, "/opt/homebrew/bin/brew", "upgrade", "netbirdio/tap/netbird"}
+	// Check if netbird-ui is installed
+	cmd := exec.CommandContext(ctx, "brew", "info", "--json", "netbirdio/tap/netbird-ui")
+	err = cmd.Run()
+	if err == nil {
+		// netbird-ui is installed
+		upgradeArgs = append(upgradeArgs, "netbirdio/tap/netbird-ui")
+	}
+	cmd = exec.CommandContext(ctx, "sudo", upgradeArgs...)
+	cmd.Env = append(cmd.Env, "HOME="+homeDir)
+
+	// Homebrew upgrade doesn't restart the client on its own
+	// So we have to wait for it to finish running and ensure it's done
+	// And then basically restart the netbird service
+	err = cmd.Run()
+	if err != nil {
+		return fmt.Errorf("error running brew upgrade: %w", err)
+	}
+
+	currentPID := os.Getpid()
+
+	// Restart netbird service after the fact
+	// This is a workaround since attempting to restart using launchctl will kill the service and die before starting
+	// the service again as it's a child process
+	// using SIGTERM should ensure a clean shutdown
+	process, err := os.FindProcess(currentPID)
+	if err != nil {
+		return fmt.Errorf("error finding current process: %w", err)
+	}
+	err = process.Signal(syscall.SIGTERM)
+	if err != nil {
+		return fmt.Errorf("error sending SIGTERM to current process: %w", err)
+	}
+	// We're dying now, which should restart us
+
+	return nil
+}

client/internal/updatemanager/update_freebsd.go

@@ -0,0 +1,10 @@
+//go:build freebsd
+
+package updatemanager
+
+import "context"
+
+func (u *UpdateManager) triggerUpdate(ctx context.Context, targetVersion string) error {
+	// TODO: Implement
+	return nil
+}

client/internal/updatemanager/update_linux.go

@@ -0,0 +1,10 @@
+//go:build linux
+
+package updatemanager
+
+import "context"
+
+func (u *UpdateManager) triggerUpdate(ctx context.Context, targetVersion string) error {
+	// TODO: Implement
+	return nil
+}

client/internal/updatemanager/update_windows.go

@@ -0,0 +1,77 @@
+//go:build windows
+
+package updatemanager
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+
+	"golang.org/x/sys/windows/registry"
+
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	msiDownloadURL     = "https://github.com/netbirdio/netbird/releases/download/v%version/netbird_installer_%version_windows_%arch.msi"
+	exeDownloadURL     = "https://github.com/netbirdio/netbird/releases/download/v%version/netbird_installer_%version_windows_%arch.exe"
+	uninstallKeyPath64 = `SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Netbird`
+	uninstallKeyPath32 = `SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Netbird`
+)
+
+func installationMethod() string {
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, uninstallKeyPath64, registry.QUERY_VALUE)
+	if err != nil {
+		k, err = registry.OpenKey(registry.LOCAL_MACHINE, uninstallKeyPath32, registry.QUERY_VALUE)
+		if err != nil {
+			return "MSI"
+		} else {
+			err = k.Close()
+			if err != nil {
+				log.Warnf("Error closing registry key: %v", err)
+			}
+		}
+	} else {
+		err = k.Close()
+		if err != nil {
+			log.Warnf("Error closing registry key: %v", err)
+		}
+	}
+	return "EXE"
+}
+
+func (u *UpdateManager) updateMSI(ctx context.Context, targetVersion string) error {
+	path, err := downloadFileToTemporaryDir(ctx, urlWithVersionArch(msiDownloadURL, targetVersion))
+	if err != nil {
+		return err
+	}
+	cmd := exec.CommandContext(ctx, "msiexec", "/quiet", "/i", path)
+	err = cmd.Run()
+	return err
+}
+
+func (u *UpdateManager) updateEXE(ctx context.Context, targetVersion string) error {
+	path, err := downloadFileToTemporaryDir(ctx, urlWithVersionArch(exeDownloadURL, targetVersion))
+	if err != nil {
+		return err
+	}
+	cmd := exec.CommandContext(ctx, path, "/S")
+	err = cmd.Start()
+	if err != nil {
+		return err
+	}
+	err = cmd.Process.Release()
+
+	return err
+}
+
+func (u *UpdateManager) triggerUpdate(ctx context.Context, targetVersion string) error {
+	switch installationMethod() {
+	case "EXE":
+		return u.updateEXE(ctx, targetVersion)
+	case "MSI":
+		return u.updateMSI(ctx, targetVersion)
+	default:
+		return fmt.Errorf("unsupported installation method: %s", installationMethod())
+	}
+}

client/ui/client_ui.go

@@ -1213,7 +1213,7 @@ func protoConfigToConfig(cfg *proto.GetConfigResponse) *profilemanager.Config {
 	return &config
 }
 
-func (s *serviceClient) onUpdateAvailable() {
+func (s *serviceClient) onUpdateAvailable(_ string) {
 	s.updateIndicationLock.Lock()
 	defer s.updateIndicationLock.Unlock()