Move installer to ui code

Author: pappz

client/internal/updatemanager/installer/installer.go

@@ -5,6 +5,8 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -22,15 +24,11 @@ func (u *Installer) copyUpdater() (string, error) {
 
 	dstPath := filepath.Join(u.tempDir, updaterBinary)
 
-	execPath, err := os.Executable()
-	if err != nil {
-		return "", fmt.Errorf("failed to get executable path: %w", err)
-	}
-
-	updaterSrcPath := filepath.Join(filepath.Dir(execPath), uiName)
-
+	//updaterSrcPath := "/Applications/NetBird.app/Contents/MacOS/netbird-ui"
+	updaterSrcPath := "/Users/pzoli/go/src/github.com/netbirdio/netbird/client/ui/ui"
 	srcFile, err := os.Open(updaterSrcPath)
 	if err != nil {
+		log.Debugf("Failed to open updater binary: %v", err)
 		return "", fmt.Errorf("failed to open source file: %w", err)
 	}
 	defer srcFile.Close()

client/ui/client_ui.go

@@ -43,6 +43,7 @@ import (
 	"github.com/netbirdio/netbird/client/ui/desktop"
 	"github.com/netbirdio/netbird/client/ui/event"
 	"github.com/netbirdio/netbird/client/ui/process"
+	"github.com/netbirdio/netbird/client/ui/update"
 
 	"github.com/netbirdio/netbird/util"
 
@@ -59,6 +60,10 @@ const (
 )
 
 func main() {
+	if update.IsUpdateBinary() {
+		update.Execute()
+		return
+	}
 	flags := parseFlags()
 
 	// Initialize file logging if needed.

client/ui/update/main.go

@@ -0,0 +1,94 @@
+package update
+
+import (
+	"context"
+	"flag"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+
+	"github.com/netbirdio/netbird/client/internal/updatemanager/installer"
+	"github.com/netbirdio/netbird/util"
+)
+
+var (
+	tempDirFlag    string
+	installerFile  string
+	serviceDirFlag string
+	dryRunFlag     bool
+)
+
+func init() {
+	flag.StringVar(&tempDirFlag, "temp-dir", "", "temporary dir")
+	flag.StringVar(&installerFile, "installer-file", "", "installer file")
+	flag.StringVar(&serviceDirFlag, "service-dir", "", "service directory")
+	flag.BoolVar(&dryRunFlag, "dry-run", false, "dry run the update process without making any changes")
+}
+
+// IsUpdateBinary checks if the current executable is named "update" or "update.exe"
+func IsUpdateBinary() bool {
+	// Remove extension for cross-platform compatibility
+	execPath, err := os.Executable()
+	if err != nil {
+		return false
+	}
+	baseName := filepath.Base(execPath)
+	name := strings.TrimSuffix(baseName, filepath.Ext(baseName))
+
+	return name == installer.UpdaterBinaryNameWithoutExtension()
+}
+
+func Execute() {
+	ui := NewUI()
+
+	// Create a context with timeout for the entire update process
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+	defer cancel()
+
+	ui.ShowUpdateProgress(ctx)
+	// Run the update function in a goroutine
+	go func() {
+		defer cancel()
+
+		if err := updateFunc(); err != nil {
+			log.Errorf("update failed: %v", err)
+			// The UI will handle the error display through context cancellation
+			return
+		}
+
+		// Success - the UI will automatically close the window
+		log.Infof("update completed successfully")
+	}()
+
+	// Start the Fyne app event loop (blocks until window is closed or context is done)
+	ui.Run()
+}
+
+func updateFunc() error {
+	if err := setupLogToFile(tempDirFlag); err != nil {
+		return err
+	}
+
+	log.Infof("updater started: %s", serviceDirFlag)
+	updater := installer.NewWithDir(tempDirFlag)
+	if err := updater.Setup(context.Background(), dryRunFlag, installerFile, serviceDirFlag); err != nil {
+		log.Errorf("failed to update application: %v", err)
+		return err
+	}
+	return nil
+}
+
+func setupLogToFile(dir string) error {
+	logFile := filepath.Join(dir, installer.LogFile)
+
+	if _, err := os.Stat(logFile); err == nil {
+		if err := os.Remove(logFile); err != nil {
+			log.Errorf("failed to remove existing log file: %v\n", err)
+		}
+	}
+
+	return util.InitLog("debug", util.LogConsole, logFile)
+}

client/ui/update/progresswindow.go

@@ -0,0 +1,104 @@
+package update
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/app"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/widget"
+	log "github.com/sirupsen/logrus"
+)
+
+type UI struct {
+	app             fyne.App
+	wUpdateProgress fyne.Window
+}
+
+func NewUI() *UI {
+	// Create the Fyne application.
+	a := app.NewWithID("NetBird-update")
+
+	return &UI{
+		app: a,
+	}
+}
+
+func (u *UI) Run() {
+	u.app.Run()
+}
+
+func (u *UI) ShowUpdateProgress(ctx context.Context) {
+	log.Infof("show installer progress window")
+	u.wUpdateProgress = u.app.NewWindow("Automatically updating client")
+
+	statusLabel := widget.NewLabel("Updating...")
+	infoLabel := widget.NewLabel("Your client version is older than the auto-update version set in Management.\nUpdating client now.")
+	content := container.NewVBox(infoLabel, statusLabel)
+	u.wUpdateProgress.SetContent(content)
+	u.wUpdateProgress.CenterOnScreen()
+	u.wUpdateProgress.SetFixedSize(true)
+	u.wUpdateProgress.SetCloseIntercept(func() {}) // lock window until result known
+	u.wUpdateProgress.RequestFocus()
+	u.wUpdateProgress.Show()
+
+	// Initialize dot updater
+	updateText := dotUpdater()
+
+	// Channel to receive the result from RPC call
+	resultErrCh := make(chan error, 1)
+	resultOkCh := make(chan struct{}, 1)
+
+	// Update UI with dots and wait for result
+	go func() {
+		ticker := time.NewTicker(time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				u.showInstallerResult(statusLabel, ctx.Err())
+				return
+			case err := <-resultErrCh:
+				u.showInstallerResult(statusLabel, err)
+				return
+			case <-resultOkCh:
+				u.wUpdateProgress.SetCloseIntercept(nil)
+				u.wUpdateProgress.Close()
+				return
+			case <-ticker.C:
+				statusLabel.SetText(updateText())
+			}
+		}
+	}()
+}
+
+func (u *UI) showInstallerResult(statusLabel *widget.Label, err error) {
+	u.wUpdateProgress.SetCloseIntercept(nil)
+	switch {
+	case errors.Is(err, context.DeadlineExceeded):
+		log.Warn("update watcher timed out")
+		statusLabel.SetText("Update timed out. Please try again.")
+	case errors.Is(err, context.Canceled):
+		log.Info("update watcher canceled")
+		statusLabel.SetText("Update canceled.")
+	case err != nil:
+		log.Errorf("update failed: %v", err)
+		statusLabel.SetText("Update failed: " + err.Error())
+	default:
+		u.wUpdateProgress.Close()
+	}
+}
+
+// dotUpdater returns a closure that cycles through dots for a loading animation.
+func dotUpdater() func() string {
+	dotCount := 0
+	return func() string {
+		dotCount = (dotCount + 1) % 4
+		return fmt.Sprintf("%s%s", "Updating", strings.Repeat(".", dotCount))
+	}
+}