fix(updater): 增强自更新校验和回滚

Author: orange-juzipi

cmd/root.go

@@ -33,6 +33,7 @@ func CreateRootCmd() *cobra.Command {
 	rootCmd.AddCommand(CreateDoctorCmd())
 	rootCmd.AddCommand(CreateCheckUpdateCmd())
 	rootCmd.AddCommand(CreateUpdateCmd())
+	rootCmd.AddCommand(CreateRollbackCmd())
 	rootCmd.AddCommand(CreateVersionCmd())
 
 	// 全局标志

cmd/update.go

@@ -117,3 +117,21 @@ func CreateUpdateCmd() *cobra.Command {
 		},
 	}
 }
+
+// CreateRollbackCmd 创建回滚命令。
+func CreateRollbackCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:           "rollback",
+		Short:         "回滚到上一个版本",
+		Long:          "使用上一次更新保留的备份二进制回滚当前程序",
+		SilenceErrors: true,
+		SilenceUsage:  true,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := updater.Rollback(); err != nil {
+				return err
+			}
+			fmt.Println("已回滚到上一个版本")
+			return nil
+		},
+	}
+}

internal/updater/updater.go

@@ -13,6 +13,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strconv"
@@ -24,10 +25,11 @@ import (
 )
 
 const (
-	githubRepo      = "https-cert/deploy"
-	githubAPIURL    = "https://api.github.com/repos/" + githubRepo + "/releases/latest"
-	downloadTimeout = 10 * time.Minute
-	downloadRetries = 3
+	githubRepo       = "https-cert/deploy"
+	githubAPIURL     = "https://api.github.com/repos/" + githubRepo + "/releases/latest"
+	downloadTimeout  = 10 * time.Minute
+	downloadRetries  = 3
+	smokeTestTimeout = 15 * time.Second
 )
 
 // 常见的 GitHub 镜像加速服务
@@ -136,13 +138,12 @@ func PerformUpdate(ctx context.Context, info *UpdateInfo) error {
 	logger.Info("下载更新中...", "version", info.LatestVersion)
 
 	// 获取当前可执行文件路径
-	execPath, err := os.Executable()
+	execPath, err := currentExecutablePath()
 	if err != nil {
-		return fmt.Errorf("获取可执行文件路径失败: %w", err)
+		return err
 	}
-	execPath, err = filepath.EvalSymlinks(execPath)
-	if err != nil {
-		return fmt.Errorf("解析可执行文件路径失败: %w", err)
+	if err := checkExecutableWritable(execPath); err != nil {
+		return err
 	}
 
 	// 创建临时目录
@@ -174,6 +175,8 @@ func PerformUpdate(ctx context.Context, info *UpdateInfo) error {
 				return fmt.Errorf("文件校验失败: %w", err)
 			}
 		}
+	} else {
+		logger.Warn("未找到 checksum 文件，跳过下载文件校验", "binary", info.BinaryName)
 	}
 
 	// 设置可执行权限（Unix 系统）
@@ -182,25 +185,156 @@ func PerformUpdate(ctx context.Context, info *UpdateInfo) error {
 			return fmt.Errorf("设置可执行权限失败: %w", err)
 		}
 	}
+	if err := smokeTestBinary(ctx, newBinaryPath); err != nil {
+		return err
+	}
 
 	// 备份当前版本
-	backupPath := execPath + ".backup"
-	if err := copyFile(execPath, backupPath); err != nil {
-		return fmt.Errorf("备份当前版本失败: %w", err)
+	backupPath, err := backupExecutable(execPath)
+	if err != nil {
+		return err
 	}
 
 	// 替换可执行文件
 	if err := replaceExecutable(newBinaryPath, execPath); err != nil {
-		// 恢复备份
-		if restoreErr := os.Rename(backupPath, execPath); restoreErr != nil {
+		if restoreErr := restoreBackup(backupPath, execPath); restoreErr != nil {
 			return fmt.Errorf("替换失败且恢复备份失败: %w, 恢复错误: %v", err, restoreErr)
 		}
 		return fmt.Errorf("替换可执行文件失败: %w", err)
 	}
 
-	// 删除备份
-	os.Remove(backupPath)
+	logger.Info("更新成功，已保留上一版本备份", "backup", backupPath)
+
+	return nil
+}
+
+// Rollback 回滚到上一次更新保留的备份版本。
+func Rollback() error {
+	execPath, err := currentExecutablePath()
+	if err != nil {
+		return err
+	}
+	if err := checkExecutableWritable(execPath); err != nil {
+		return err
+	}
+
+	backupPath := backupPathFor(execPath)
+	if _, err := os.Stat(backupPath); err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("未找到可回滚备份: %s", backupPath)
+		}
+		return fmt.Errorf("检查回滚备份失败: %w", err)
+	}
+
+	if err := restoreBackup(backupPath, execPath); err != nil {
+		return fmt.Errorf("回滚失败: %w", err)
+	}
+	logger.Info("回滚成功", "backup", backupPath)
+	return nil
+}
+
+// currentExecutablePath 返回当前可执行文件的真实路径。
+func currentExecutablePath() (string, error) {
+	execPath, err := os.Executable()
+	if err != nil {
+		return "", fmt.Errorf("获取可执行文件路径失败: %w", err)
+	}
+	execPath, err = filepath.EvalSymlinks(execPath)
+	if err != nil {
+		return "", fmt.Errorf("解析可执行文件路径失败: %w", err)
+	}
+	return execPath, nil
+}
+
+// checkExecutableWritable 检查当前二进制和所在目录是否可写。
+func checkExecutableWritable(execPath string) error {
+	if strings.TrimSpace(execPath) == "" {
+		return fmt.Errorf("可执行文件路径不能为空")
+	}
 
+	info, err := os.Stat(execPath)
+	if err != nil {
+		return fmt.Errorf("检查当前二进制失败: %w", err)
+	}
+	if info.IsDir() {
+		return fmt.Errorf("当前二进制路径不是文件: %s", execPath)
+	}
+
+	file, err := os.Open(execPath)
+	if err != nil {
+		return fmt.Errorf("当前二进制不可读: %w", err)
+	}
+	if err := file.Close(); err != nil {
+		return fmt.Errorf("关闭当前二进制失败: %w", err)
+	}
+
+	parentDir := filepath.Dir(execPath)
+	probe, err := os.CreateTemp(parentDir, ".anssl-update-write-*")
+	if err != nil {
+		return fmt.Errorf("当前二进制所在目录不可写: %w", err)
+	}
+	probePath := probe.Name()
+	if err := probe.Close(); err != nil {
+		os.Remove(probePath)
+		return fmt.Errorf("关闭写权限探测文件失败: %w", err)
+	}
+	if err := os.Remove(probePath); err != nil {
+		return fmt.Errorf("删除写权限探测文件失败: %w", err)
+	}
+	return nil
+}
+
+// smokeTestBinary 通过 version 命令验证新二进制可执行。
+func smokeTestBinary(ctx context.Context, binaryPath string) error {
+	smokeCtx, cancel := context.WithTimeout(ctx, smokeTestTimeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(smokeCtx, binaryPath, "version")
+	output, err := cmd.CombinedOutput()
+	if smokeCtx.Err() == context.DeadlineExceeded {
+		return fmt.Errorf("新二进制 smoke test 超时")
+	}
+	if err != nil {
+		return fmt.Errorf("新二进制 smoke test 失败: %w\n%s", err, strings.TrimSpace(string(output)))
+	}
+	return nil
+}
+
+// backupPathFor 返回当前二进制的备份路径。
+func backupPathFor(execPath string) string {
+	return execPath + ".backup"
+}
+
+// backupExecutable 备份当前二进制，成功更新后仍保留该备份供 rollback 使用。
+func backupExecutable(execPath string) (string, error) {
+	backupPath := backupPathFor(execPath)
+	if err := copyFile(execPath, backupPath); err != nil {
+		return "", fmt.Errorf("备份当前版本失败: %w", err)
+	}
+	return backupPath, nil
+}
+
+// restoreBackup 使用备份恢复当前二进制，同时保留备份文件。
+func restoreBackup(backupPath, execPath string) error {
+	restorePath := execPath + ".restore"
+	os.Remove(restorePath)
+	if err := copyFile(backupPath, restorePath); err != nil {
+		return fmt.Errorf("准备恢复文件失败: %w", err)
+	}
+	if _, err := os.Stat(execPath); os.IsNotExist(err) {
+		if err := copyFile(restorePath, execPath); err != nil {
+			os.Remove(restorePath)
+			return err
+		}
+		return os.Remove(restorePath)
+	} else if err != nil {
+		os.Remove(restorePath)
+		return err
+	}
+	if err := replaceExecutable(restorePath, execPath); err != nil {
+		os.Remove(restorePath)
+		return err
+	}
 	return nil
 }
 

internal/updater/updater_test.go

@@ -5,11 +5,14 @@ import (
 	"archive/zip"
 	"bytes"
 	"compress/gzip"
+	"context"
 	"os"
 	"path/filepath"
+	"runtime"
 	"testing"
 )
 
+// TestExtractBinaryTarGzFindsExecutableByName 验证 tar.gz 包中可以按名称提取可执行文件。
 func TestExtractBinaryTarGzFindsExecutableByName(t *testing.T) {
 	tempDir := t.TempDir()
 	archivePath := filepath.Join(tempDir, "anssl-linux-amd64.tar.gz")
@@ -27,6 +30,7 @@ func TestExtractBinaryTarGzFindsExecutableByName(t *testing.T) {
 	assertFileContent(t, extractedPath, "binary-content")
 }
 
+// TestExtractBinaryZipFindsExecutableByName 验证 zip 包中可以按名称提取可执行文件。
 func TestExtractBinaryZipFindsExecutableByName(t *testing.T) {
 	tempDir := t.TempDir()
 	archivePath := filepath.Join(tempDir, "anssl-windows-amd64.zip")
@@ -44,6 +48,7 @@ func TestExtractBinaryZipFindsExecutableByName(t *testing.T) {
 	assertFileContent(t, extractedPath, "windows-binary-content")
 }
 
+// TestExtractBinaryTarGzMissingExecutable 验证压缩包缺少可执行文件时返回错误。
 func TestExtractBinaryTarGzMissingExecutable(t *testing.T) {
 	tempDir := t.TempDir()
 	archivePath := filepath.Join(tempDir, "anssl-linux-amd64.tar.gz")
@@ -57,11 +62,85 @@ func TestExtractBinaryTarGzMissingExecutable(t *testing.T) {
 	}
 }
 
+// TestSmokeTestBinaryRunsVersion 验证 smoke test 会执行新二进制的 version 命令。
+func TestSmokeTestBinaryRunsVersion(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("shell script smoke test is Unix-only")
+	}
+
+	tempDir := t.TempDir()
+	binaryPath := filepath.Join(tempDir, "anssl")
+	if err := os.WriteFile(binaryPath, []byte("#!/bin/sh\nif [ \"$1\" = \"version\" ]; then echo v-test; exit 0; fi\nexit 1\n"), 0755); err != nil {
+		t.Fatalf("write smoke binary: %v", err)
+	}
+
+	if err := smokeTestBinary(context.Background(), binaryPath); err != nil {
+		t.Fatalf("smokeTestBinary() error = %v", err)
+	}
+}
+
+// TestSmokeTestBinaryFails 验证 smoke test 会拒绝执行失败的新二进制。
+func TestSmokeTestBinaryFails(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("shell script smoke test is Unix-only")
+	}
+
+	tempDir := t.TempDir()
+	binaryPath := filepath.Join(tempDir, "anssl")
+	if err := os.WriteFile(binaryPath, []byte("#!/bin/sh\nexit 1\n"), 0755); err != nil {
+		t.Fatalf("write smoke binary: %v", err)
+	}
+
+	if err := smokeTestBinary(context.Background(), binaryPath); err == nil {
+		t.Fatal("smokeTestBinary() error = nil, want error")
+	}
+}
+
+// TestRestoreBackupRestoresMissingExecutable 验证目标文件缺失时可以从备份恢复。
+func TestRestoreBackupRestoresMissingExecutable(t *testing.T) {
+	tempDir := t.TempDir()
+	execPath := filepath.Join(tempDir, "anssl")
+	backupPath := backupPathFor(execPath)
+	if err := os.WriteFile(backupPath, []byte("backup-binary"), 0755); err != nil {
+		t.Fatalf("write backup: %v", err)
+	}
+
+	if err := restoreBackup(backupPath, execPath); err != nil {
+		t.Fatalf("restoreBackup() error = %v", err)
+	}
+
+	assertFileContent(t, execPath, "backup-binary")
+	assertFileContent(t, backupPath, "backup-binary")
+}
+
+// TestRestoreBackupReplacesExistingExecutable 验证目标文件存在时可以从备份替换恢复。
+func TestRestoreBackupReplacesExistingExecutable(t *testing.T) {
+	tempDir := t.TempDir()
+	execPath := filepath.Join(tempDir, "anssl")
+	backupPath := backupPathFor(execPath)
+	if err := os.WriteFile(execPath, []byte("current-binary"), 0755); err != nil {
+		t.Fatalf("write current binary: %v", err)
+	}
+	if err := os.WriteFile(backupPath, []byte("backup-binary"), 0755); err != nil {
+		t.Fatalf("write backup: %v", err)
+	}
+
+	if err := restoreBackup(backupPath, execPath); err != nil {
+		t.Fatalf("restoreBackup() error = %v", err)
+	}
+
+	assertFileContent(t, execPath, "backup-binary")
+	assertFileContent(t, backupPath, "backup-binary")
+}
+
 type archiveEntry struct {
-	name    string
+	// name 是压缩包内文件名。
+	name string
+	// content 是压缩包内文件内容。
 	content string
 }
 
+// writeTarGzArchive 写入测试用 tar.gz 压缩包。
 func writeTarGzArchive(t *testing.T, archivePath string, entries []archiveEntry) {
 	t.Helper()
 
@@ -94,6 +173,7 @@ func writeTarGzArchive(t *testing.T, archivePath string, entries []archiveEntry)
 	}
 }
 
+// writeZipArchive 写入测试用 zip 压缩包。
 func writeZipArchive(t *testing.T, archivePath string, entries []archiveEntry) {
 	t.Helper()
 
@@ -118,6 +198,7 @@ func writeZipArchive(t *testing.T, archivePath string, entries []archiveEntry) {
 	}
 }
 
+// assertFileContent 断言文件内容等于预期字符串。
 func assertFileContent(t *testing.T, filePath, want string) {
 	t.Helper()