Golang二进制文件的OTA更新实现

对于Go二进制文件的OTA更新，你的思路基本正确，但需要处理自我替换的问题。以下是实现方案：

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "os/exec"
    "path/filepath"
    "runtime"
)

// 主程序更新逻辑
func updateBinary() error {
    // 1. 检查当前版本
    currentVersion := getCurrentVersion()
    
    // 2. 从仓库获取最新版本
    latestVersion, err := fetchLatestVersion()
    if err != nil {
        return err
    }
    
    if currentVersion >= latestVersion {
        return nil // 无需更新
    }
    
    // 3. 下载新版本
    newBinaryPath, err := downloadNewVersion(latestVersion)
    if err != nil {
        return err
    }
    
    // 4. 启动更新器进程进行替换
    return launchUpdater(newBinaryPath)
}

// 下载新版本
func downloadNewVersion(version string) (string, error) {
    url := fmt.Sprintf("https://example.com/app/v%s/app-%s-%s", 
        version, runtime.GOOS, runtime.GOARCH)
    
    resp, err := http.Get(url)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    // 创建临时文件
    tmpFile, err := os.CreateTemp("", "update-*.tmp")
    if err != nil {
        return "", err
    }
    defer tmpFile.Close()
    
    // 写入临时文件
    _, err = io.Copy(tmpFile, resp.Body)
    if err != nil {
        return "", err
    }
    
    // 设置可执行权限
    if runtime.GOOS != "windows" {
        os.Chmod(tmpFile.Name(), 0755)
    }
    
    return tmpFile.Name(), nil
}

// 启动更新器进程
func launchUpdater(newBinaryPath string) error {
    // 获取当前可执行文件路径
    exePath, err := os.Executable()
    if err != nil {
        return err
    }
    
    // 创建更新器脚本/程序
    updaterScript := createUpdaterScript(exePath, newBinaryPath)
    
    // 启动更新器（独立进程）
    cmd := exec.Command(updaterScript)
    if err := cmd.Start(); err != nil {
        return err
    }
    
    // 主程序退出
    os.Exit(0)
    return nil
}

// 创建更新器脚本
func createUpdaterScript(currentPath, newPath string) string {
    var script string
    
    if runtime.GOOS == "windows" {
        script = fmt.Sprintf(`@echo off
timeout /t 2 /nobreak >nul
del "%s"
move "%s" "%s"
start "" "%s"`,
            currentPath, newPath, currentPath, currentPath)
        
        scriptPath := filepath.Join(os.TempDir(), "updater.bat")
        os.WriteFile(scriptPath, []byte(script), 0644)
        return scriptPath
    } else {
        script = fmt.Sprintf(`#!/bin/bash
sleep 2
rm -f "%s"
mv "%s" "%s"
chmod +x "%s"
"%s" &`,
            currentPath, newPath, currentPath, currentPath, currentPath)
        
        scriptPath := filepath.Join(os.TempDir(), "updater.sh")
        os.WriteFile(scriptPath, []byte(script), 0755)
        return scriptPath
    }
}

// 版本管理函数
func getCurrentVersion() string {
    // 从嵌入信息或配置文件读取
    return "1.0.0"
}

func fetchLatestVersion() (string, error) {
    // 从API或版本文件获取
    resp, err := http.Get("https://example.com/version.txt")
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    version, _ := io.ReadAll(resp.Body)
    return string(version), nil
}

对于关键的第5、6、7点，解决方案是：

1. 使用独立更新器进程：主程序启动一个独立的更新器进程（脚本或Go程序），然后退出
2. 更新器等待主程序退出：更新器等待几秒确保主程序完全退出
3. 执行替换操作：更新器删除旧文件，移动新文件到原位置
4. 启动新版本：更新器启动新版本程序

更健壮的实现可以使用专门的更新器二进制文件：

// updater.go - 独立的更新器程序
package main

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

func main() {
    if len(os.Args) < 3 {
        fmt.Println("Usage: updater <current> <new>")
        os.Exit(1)
    }
    
    currentPath := os.Args[1]
    newPath := os.Args[2]
    
    // 等待主程序退出
    time.Sleep(2 * time.Second)
    
    // 删除当前文件
    os.Remove(currentPath)
    
    // 移动新文件
    err := os.Rename(newPath, currentPath)
    if err != nil {
        // 如果跨卷移动失败，使用复制
        copyFile(newPath, currentPath)
        os.Remove(newPath)
    }
    
    // 设置权限
    if runtime.GOOS != "windows" {
        os.Chmod(currentPath, 0755)
    }
    
    // 启动新程序
    cmd := exec.Command(currentPath)
    cmd.Start()
}

func copyFile(src, dst string) error {
    in, err := os.Open(src)
    if err != nil {
        return err
    }
    defer in.Close()
    
    out, err := os.Create(dst)
    if err != nil {
        return err
    }
    defer out.Close()
    
    _, err = io.Copy(out, in)
    return err
}

主程序调用方式：

func launchUpdater(newBinaryPath string) error {
    exePath, _ := os.Executable()
    
    // 编译或使用预编译的更新器
    updaterPath := "/path/to/updater"
    
    cmd := exec.Command(updaterPath, exePath, newBinaryPath)
    if err := cmd.Start(); err != nil {
        return err
    }
    
    os.Exit(0)
    return nil
}

这种方法确保了：

• 主程序完全退出后才进行文件操作
• 使用独立进程避免文件锁定问题
• 支持跨平台操作（Windows/Linux/macOS）
• 提供回滚机制（可保留旧版本备份）