Golang应用如何实现自我更新后自动重启

嗯，看起来在 Windows 上它不起作用：

我写了：

	// Get the path to the currently running executable
	executablePath, err := os.Executable()
	if err != nil {
		fmt.Println("Error:", err)
		return err
	}

	// Call syscall.Exec to restart the application
	err = syscall.Exec(executablePath, os.Args, os.Environ())
	if err != nil {
		fmt.Println("Error:", err)
	}

但得到了错误：

Error: not supported by windows

要实现Go应用程序的自我更新并自动重启，可以使用子进程管理的方式。以下是修改后的代码示例，通过启动新进程并优雅退出当前进程来实现平滑重启：

package main

import (
    "bufio"
    "encoding/json"
    "fmt"
    "io"
    "net"
    "net/http"
    "os"
    "os/exec"
    "os/signal"
    "path"
    "path/filepath"
    "runtime"
    "strings"
    "syscall"
    "time"
)

var version = "v1.0.0"

func downloadFile(filepath string, url string) error {
    if _, err := os.Stat(filepath); err == nil {
        return fmt.Errorf("file %s already exists", filepath)
    }

    dir := path.Dir(filepath)
    if _, err := os.Stat(dir); os.IsNotExist(err) {
        os.MkdirAll(dir, os.ModePerm)
    }

    out, err := os.Create(filepath)
    if err != nil {
        return err
    }
    defer out.Close()

    var netTransport = &http.Transport{
        Dial: (&net.Dialer{
            Timeout: 5 * time.Second,
        }).Dial,
        TLSHandshakeTimeout: 5 * time.Second,
    }
    var netClient = &http.Client{
        Timeout:   time.Second * 10,
        Transport: netTransport,
    }

    resp, err := netClient.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    _, err = io.Copy(out, resp.Body)
    return err
}

type Release struct {
    TagName string `json:"tag_name"`
    Assets  []struct {
        BrowserDownloadUrl string `json:"browser_download_url"`
    } `json:"assets"`
}

func getLatestRelease(repoUrl string) (*Release, error) {
    resp, err := http.Get(repoUrl)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var release Release
    if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
        return nil, err
    }

    return &release, nil
}

func restartApplication() error {
    self, err := os.Executable()
    if err != nil {
        return err
    }

    args := os.Args
    env := os.Environ()

    cmd := exec.Command(self, args[1:]...)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    cmd.Stdin = os.Stdin
    cmd.Env = env
    cmd.Dir, _ = os.Getwd()

    if err := cmd.Start(); err != nil {
        return err
    }

    os.Exit(0)
    return nil
}

func checkForUpdates() bool {
    repoUrl := "https://api.github.com/repos/HasanAbuKaram/testGoupdate/releases/latest"
    release, err := getLatestRelease(repoUrl)
    if err != nil {
        fmt.Println("Error:", err)
        return false
    }

    if release.TagName != version {
        fmt.Println("A new version is available:", release.TagName)
        fmt.Println("Options:")
        fmt.Println("a. Remind me now")
        fmt.Println("b. Download new file but do not install")
        fmt.Println("c. Download, install and restart")

        var option string
        fmt.Print("Enter your choice (a/b/c): ")
        fmt.Scanln(&option)

        option = strings.ToLower(option)

        switch option {
        case "a":
            fmt.Println("Remind me later")
        case "b":
            var url = release.Assets[0].BrowserDownloadUrl
            err := downloadFile(fmt.Sprintf("./bin/%v.exe", release.TagName), url)
            if err != nil {
                fmt.Println("Error downloading file:", err)
            }
            fmt.Println("File downloaded but not installed.")
        case "c":
            var url = release.Assets[0].BrowserDownloadUrl
            err := downloadFile(fmt.Sprintf("./bin/%v.exe", release.TagName), url)
            if err != nil {
                fmt.Println("Error downloading file:", err)
            } else {
                fmt.Println("File downloaded successfully.")
                if err := installBinary(fmt.Sprintf("./bin/%v.exe", release.TagName)); err != nil {
                    fmt.Println("Error installing binary:", err)
                } else {
                    fmt.Println("Restarting application...")
                    time.Sleep(2 * time.Second)
                    return true
                }
            }
        default:
            fmt.Println("Invalid option")
        }
    } else {
        fmt.Println("You are running the latest version: ", version)
    }
    return false
}

func installBinary(filepath string) error {
    currentExec, err := os.Executable()
    if err != nil {
        return err
    }

    if runtime.GOOS == "windows" {
        return installBinaryWindows(currentExec, filepath)
    }
    return installBinaryUnix(currentExec, filepath)
}

func installBinaryWindows(currentExec, newBinary string) error {
    backupPath := currentExec + ".bak"
    
    if err := os.Rename(currentExec, backupPath); err != nil {
        return err
    }

    if err := os.Rename(newBinary, currentExec); err != nil {
        os.Rename(backupPath, currentExec)
        return err
    }

    os.Remove(backupPath)
    return nil
}

func installBinaryUnix(currentExec, newBinary string) error {
    tempPath := currentExec + ".tmp"
    
    if err := os.Rename(currentExec, tempPath); err != nil {
        return err
    }

    if err := os.Rename(newBinary, currentExec); err != nil {
        os.Rename(tempPath, currentExec)
        return err
    }

    if err := os.Chmod(currentExec, 0755); err != nil {
        return err
    }

    os.Remove(tempPath)
    return nil
}

func main() {
    fmt.Printf("Hello, World! Running version %s\n", version)

    if checkForUpdates() {
        if err := restartApplication(); err != nil {
            fmt.Println("Error restarting application:", err)
        }
        return
    }

    ticker := time.NewTicker(1 * time.Hour)
    defer ticker.Stop()

    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, os.Interrupt, syscall.SIGTERM)

    go func() {
        for {
            sig := <-sigs
            if sig == os.Interrupt || sig == syscall.SIGTERM {
                reader := bufio.NewReader(os.Stdin)
                fmt.Print("Are you sure you want to exit? (y/n): ")
                text, _ := reader.ReadString('\n')
                text = strings.TrimSpace(text)
                if text == "y" || text == "Y" {
                    fmt.Println("Exiting...")
                    os.Exit(0)
                } else {
                    fmt.Println("Continuing...")
                }
            }
        }
    }()

    for {
        <-ticker.C
        if checkForUpdates() {
            if err := restartApplication(); err != nil {
                fmt.Println("Error restarting application:", err)
            }
            break
        }
    }
}

对于更复杂的场景，可以考虑使用双进程架构。以下是分离更新器和主程序的示例：

// updater.go
package main

import (
    "fmt"
    "os"
    "os/exec"
    "path/filepath"
    "time"
)

func main() {
    exePath, _ := os.Executable()
    exeDir := filepath.Dir(exePath)
    mainApp := filepath.Join(exeDir, "mainapp")
    
    for {
        cmd := exec.Command(mainApp)
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        cmd.Stdin = os.Stdin
        
        if err := cmd.Start(); err != nil {
            fmt.Printf("Failed to start main app: %v\n", err)
            time.Sleep(5 * time.Second)
            continue
        }
        
        if err := cmd.Wait(); err != nil {
            fmt.Printf("Main app exited: %v\n", err)
            
            if cmd.ProcessState.ExitCode() == 42 {
                fmt.Println("Restarting after update...")
                continue
            }
        }
        
        time.Sleep(5 * time.Second)
    }
}

// mainapp.go
package main

import (
    "fmt"
    "os"
    "time"
)

func main() {
    fmt.Println("Main application running...")
    
    if shouldUpdate() {
        performUpdate()
        os.Exit(42)
    }
    
    for {
        time.Sleep(time.Second)
    }
}

func shouldUpdate() bool {
    return false
}

func performUpdate() {
    fmt.Println("Performing update...")
}

对于跨平台兼容性，可以使用以下重启函数：

func restartSelf() error {
    executable, err := os.Executable()
    if err != nil {
        return err
    }
    
    args := os.Args
    env := os.Environ()
    
    cmd := &exec.Cmd{
        Path:   executable,
        Args:   args,
        Env:    env,
        Stdin:  os.Stdin,
        Stdout: os.Stdout,
        Stderr: os.Stderr,
    }
    
    if err := cmd.Start(); err != nil {
        return err
    }
    
    os.Exit(0)
    return nil
}