feat(deploy): 在线更新 - 新增后台检查、强制备份迁移与失败自动回退

This commit is contained in:
ddCat committed 2026-08-30 22:15:17 +08:00
1 parent 4ba9694f45
commit db66ac1182
60 files changed
+4124 -93

No files matched your search

+550
View File
@@ -0,0 +1,550 @@
package hostupdate
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
"sync"
"time"
)
const maxReleaseResponseBytes = 4 << 20
type Config struct {
Repository string
InstallDir string
ComposeFile string
EnvFile string
StateDir string
BackupDir string
HealthURL string
GitHubToken string
StableWindow time.Duration
StepTimeout time.Duration
BinaryPath string
ServiceName string
SelfUpdate bool
}
type commandRunner interface {
Run(context.Context, string, []string, []string, io.Writer, io.Writer) error
}
type execRunner struct{ dir string }
func (r execRunner) Run(ctx context.Context, name string, args, environment []string, stdout, stderr io.Writer) error {
command := exec.CommandContext(ctx, name, args...)
command.Dir = r.dir
command.Env = append(os.Environ(), environment...)
command.Stdout = stdout
command.Stderr = stderr
return command.Run()
}
type persistedState struct {
LatestRelease *Release `json:"latestRelease,omitempty"`
LastBackup *Backup `json:"lastBackup,omitempty"`
RollbackVersion string `json:"rollbackVersion,omitempty"`
Operation Operation `json:"operation"`
}
type Manager struct {
mu sync.Mutex
config Config
runner commandRunner
httpClient *http.Client
state persistedState
}
func NewManager(config Config) (*Manager, error) {
config.Repository = strings.TrimSpace(config.Repository)
if config.Repository == "" {
config.Repository = "ddcat-ai/open-ai-canvas"
}
if config.InstallDir == "" {
config.InstallDir = "/opt/open-ai-canvas"
}
if config.ComposeFile == "" {
config.ComposeFile = "docker-compose.deploy.yml"
}
if config.EnvFile == "" {
config.EnvFile = ".env"
}
if config.StateDir == "" {
config.StateDir = "/var/lib/open-ai-canvas-updater"
}
if config.BackupDir == "" {
config.BackupDir = filepath.Join(config.InstallDir, "backups")
}
if config.StableWindow <= 0 {
config.StableWindow = 30 * time.Second
}
if config.StepTimeout <= 0 {
config.StepTimeout = 20 * time.Minute
}
if err := os.MkdirAll(config.StateDir, 0o700); err != nil {
return nil, fmt.Errorf("创建更新器状态目录:%w", err)
}
if err := os.MkdirAll(config.BackupDir, 0o700); err != nil {
return nil, fmt.Errorf("创建备份目录:%w", err)
}
manager := &Manager{
config: config,
runner: execRunner{dir: config.InstallDir},
httpClient: &http.Client{Timeout: 30 * time.Second},
state: persistedState{Operation: Operation{Phase: PhaseIdle, Logs: []LogEntry{}}},
}
if err := manager.loadState(); err != nil {
return nil, err
}
if manager.state.Operation.Phase.Active() {
manager.state.Operation.Phase = PhaseManualIntervention
manager.state.Operation.Error = "更新器进程在操作期间退出,请检查容器与数据库状态后手动处理"
manager.appendLogLocked(PhaseManualIntervention, manager.state.Operation.Error)
_ = manager.saveStateLocked()
}
return manager, nil
}
func (m *Manager) Snapshot() Status {
m.mu.Lock()
defer m.mu.Unlock()
return m.snapshotLocked()
}
func (m *Manager) Check(ctx context.Context) (Status, error) {
m.mu.Lock()
if m.state.Operation.Phase.Active() {
status := m.snapshotLocked()
m.mu.Unlock()
return status, errors.New("更新操作正在进行,暂时不能检查新版本")
}
m.state.Operation.Phase = PhaseChecking
m.state.Operation.Error = ""
m.appendLogLocked(PhaseChecking, "正在读取 GitHub Release")
_ = m.saveStateLocked()
m.mu.Unlock()
release, err := m.latestRelease(ctx)
m.mu.Lock()
defer m.mu.Unlock()
if err != nil {
m.state.Operation.Phase = PhaseFailed
m.state.Operation.Error = err.Error()
m.appendLogLocked(PhaseFailed, "检查更新失败")
_ = m.saveStateLocked()
return m.snapshotLocked(), err
}
m.state.LatestRelease = release
current, currentErr := m.currentVersion()
if currentErr != nil {
m.state.Operation.Phase = PhaseFailed
m.state.Operation.Error = currentErr.Error()
_ = m.saveStateLocked()
return m.snapshotLocked(), currentErr
}
if CompareVersions(current, release.Version) < 0 {
m.state.Operation.Phase = PhaseReady
m.appendLogLocked(PhaseReady, fmt.Sprintf("发现新版本 %s", release.Version))
} else {
m.state.Operation.Phase = PhaseNoUpdate
m.appendLogLocked(PhaseNoUpdate, "当前已是最新版本")
}
_ = m.saveStateLocked()
return m.snapshotLocked(), nil
}
func (m *Manager) StartUpdate(targetVersion string) (Status, error) {
targetVersion = strings.TrimSpace(targetVersion)
m.mu.Lock()
defer m.mu.Unlock()
if m.state.Operation.Phase.Active() {
return m.snapshotLocked(), errors.New("已有更新操作正在进行")
}
if m.state.LatestRelease == nil || m.state.LatestRelease.Version != targetVersion {
return m.snapshotLocked(), errors.New("目标版本与最近一次检查结果不一致,请重新检查更新")
}
current, err := m.currentVersion()
if err != nil {
return m.snapshotLocked(), err
}
if CompareVersions(current, targetVersion) >= 0 {
return m.snapshotLocked(), errors.New("目标版本必须高于当前版本")
}
now := time.Now().UTC()
m.state.Operation = Operation{
ID: randomID(),
Phase: PhasePreflight,
FromVersion: current,
TargetVersion: targetVersion,
StartedAt: &now,
Logs: []LogEntry{{At: now, Phase: PhasePreflight, Message: "开始更新前检查"}},
}
_ = m.saveStateLocked()
go m.runUpdate(current, targetVersion)
return m.snapshotLocked(), nil
}
func (m *Manager) StartRollback(reason string) (Status, error) {
m.mu.Lock()
defer m.mu.Unlock()
if m.state.Operation.Phase.Active() {
return m.snapshotLocked(), errors.New("已有更新操作正在进行")
}
if m.state.RollbackVersion == "" || m.state.LastBackup == nil {
return m.snapshotLocked(), errors.New("没有可用的回退版本或已校验备份")
}
current, err := m.currentVersion()
if err != nil {
return m.snapshotLocked(), err
}
now := time.Now().UTC()
target := m.state.RollbackVersion
m.state.Operation = Operation{
ID: randomID(),
Phase: PhaseRollingBack,
FromVersion: current,
TargetVersion: target,
StartedAt: &now,
Logs: []LogEntry{{At: now, Phase: PhaseRollingBack, Message: "管理员发起人工回退:" + strings.TrimSpace(reason)}},
}
_ = m.saveStateLocked()
backup := *m.state.LastBackup
go m.runRollback(target, backup, false)
return m.snapshotLocked(), nil
}
func (m *Manager) runUpdate(fromVersion, targetVersion string) {
nextCompose, err := m.prepareTargetCompose(targetVersion)
if err != nil {
m.failWithoutRollback(PhaseFailed, err)
return
}
defer os.Remove(nextCompose)
if err := m.preflight(nextCompose, targetVersion); err != nil {
m.failWithoutRollback(PhaseFailed, err)
return
}
updaterBinary, err := m.prepareUpdaterBinary(targetVersion)
if err != nil {
m.failWithoutRollback(PhaseFailed, err)
return
}
if updaterBinary != "" {
defer os.Remove(updaterBinary)
}
m.setPhase(PhaseBackingUp, "创建 PostgreSQL 与数据目录 ZIP 备份")
backup, err := m.createBackup(fromVersion)
if err != nil {
m.failWithoutRollback(PhaseFailed, err)
return
}
m.mu.Lock()
m.state.LastBackup = &backup
m.state.RollbackVersion = fromVersion
_ = m.saveStateLocked()
m.mu.Unlock()
if err := replaceFile(m.composePath(), m.previousComposePath(), 0o600); err != nil {
m.failWithoutRollback(PhaseFailed, fmt.Errorf("保存旧 Compose 配置:%w", err))
return
}
m.setPhase(PhasePulling, "拉取目标版本镜像")
if err := m.compose(nextCompose, targetVersion, m.config.StepTimeout, nil, "pull", "backend", "web"); err != nil {
m.failWithoutRollback(PhaseFailed, err)
return
}
if err := m.verifyImages(targetVersion); err != nil {
m.failWithoutRollback(PhaseFailed, err)
return
}
m.setPhase(PhaseDraining, "停止 Web 与 Backend,等待后台任务优雅退出")
if err := m.compose(m.composePath(), fromVersion, m.config.StepTimeout, nil, "stop", "web", "backend"); err != nil {
m.failWithRollback(err, fromVersion, backup)
return
}
m.setPhase(PhaseMigrating, "执行目标版本数据库迁移")
if err := m.compose(nextCompose, targetVersion, m.config.StepTimeout, nil, "run", "--rm", "migrate"); err != nil {
m.failWithRollback(err, fromVersion, backup)
return
}
m.setPhase(PhaseSwitching, "切换 Compose 配置与镜像版本")
if err := setEnvValue(m.envPath(), "CANVAS_IMAGE_TAG", strings.TrimPrefix(targetVersion, "v")); err != nil {
m.failWithRollback(err, fromVersion, backup)
return
}
if err := replaceFile(nextCompose, m.composePath(), 0o600); err != nil {
_ = setEnvValue(m.envPath(), "CANVAS_IMAGE_TAG", strings.TrimPrefix(fromVersion, "v"))
m.failWithRollback(err, fromVersion, backup)
return
}
if err := m.compose(m.composePath(), targetVersion, m.config.StepTimeout, nil, "up", "-d", "--remove-orphans", "--wait", "--wait-timeout", "600"); err != nil {
m.failWithRollback(err, fromVersion, backup)
return
}
m.setPhase(PhaseVerifying, "验证健康状态、运行版本和稳定窗口")
if err := m.verifyHealthy(targetVersion); err != nil {
m.failWithRollback(err, fromVersion, backup)
return
}
if updaterBinary != "" {
if err := replaceFile(updaterBinary, m.config.BinaryPath, 0o755); err != nil {
m.mu.Lock()
now := time.Now().UTC()
m.state.Operation.Phase = PhaseManualIntervention
m.state.Operation.FinishedAt = &now
m.state.Operation.Error = "应用已更新,但 Host Updater 自更新失败:" + safeOperationError(err)
m.appendLogLocked(PhaseManualIntervention, "应用版本已切换,更新器二进制需要人工更新")
_ = m.saveStateLocked()
m.mu.Unlock()
return
}
}
m.mu.Lock()
now := time.Now().UTC()
m.state.Operation.Phase = PhaseSucceeded
m.state.Operation.FinishedAt = &now
m.state.Operation.Error = ""
m.appendLogLocked(PhaseSucceeded, fmt.Sprintf("已成功更新到 %s", targetVersion))
if updaterBinary != "" {
m.appendLogLocked(PhaseSucceeded, "Host Updater 二进制已同步到目标 Release")
}
_ = m.saveStateLocked()
m.mu.Unlock()
if updaterBinary != "" && m.config.ServiceName != "" {
go m.restartSelf()
}
}
func (m *Manager) failWithoutRollback(phase Phase, err error) {
m.mu.Lock()
defer m.mu.Unlock()
now := time.Now().UTC()
m.state.Operation.Phase = phase
m.state.Operation.Error = safeOperationError(err)
m.state.Operation.FinishedAt = &now
m.appendLogLocked(phase, "更新已中止,尚未修改运行版本")
_ = m.saveStateLocked()
}
func (m *Manager) failWithRollback(cause error, targetVersion string, backup Backup) {
m.mu.Lock()
m.state.Operation.Error = safeOperationError(cause)
m.state.Operation.AutomaticRollback = true
m.state.Operation.Phase = PhaseRollingBack
m.appendLogLocked(PhaseRollingBack, "更新失败,正在自动恢复旧版本和数据库备份")
_ = m.saveStateLocked()
m.mu.Unlock()
m.runRollback(targetVersion, backup, true)
}
func (m *Manager) runRollback(targetVersion string, backup Backup, automatic bool) {
var failures []error
if err := m.compose(m.composePath(), targetVersion, 5*time.Minute, nil, "stop", "web", "backend"); err != nil {
failures = append(failures, err)
}
if _, err := os.Stat(m.previousComposePath()); err == nil {
if err := replaceFile(m.previousComposePath(), m.composePath(), 0o600); err != nil {
failures = append(failures, fmt.Errorf("恢复旧 Compose 配置:%w", err))
}
}
if err := m.restoreDatabase(backup); err != nil {
failures = append(failures, err)
}
if err := setEnvValue(m.envPath(), "CANVAS_IMAGE_TAG", strings.TrimPrefix(targetVersion, "v")); err != nil {
failures = append(failures, err)
}
started := true
if err := m.compose(m.composePath(), targetVersion, m.config.StepTimeout, nil, "up", "-d", "--remove-orphans", "--wait", "--wait-timeout", "600"); err != nil {
started = false
failures = append(failures, err)
}
if started {
if err := m.verifyHealthy(targetVersion); err != nil {
failures = append(failures, err)
}
}
rollbackErr := errors.Join(failures...)
m.mu.Lock()
defer m.mu.Unlock()
now := time.Now().UTC()
m.state.Operation.FinishedAt = &now
m.state.Operation.AutomaticRollback = automatic
if rollbackErr != nil {
m.state.Operation.Phase = PhaseManualIntervention
m.state.Operation.RollbackError = safeOperationError(rollbackErr)
m.appendLogLocked(PhaseManualIntervention, "自动回退未能完成,需要人工介入")
} else {
m.state.Operation.Phase = PhaseRolledBack
m.state.Operation.RollbackError = ""
m.appendLogLocked(PhaseRolledBack, fmt.Sprintf("已恢复到 %s", targetVersion))
}
_ = m.saveStateLocked()
}
func (m *Manager) snapshotLocked() Status {
current, err := m.currentVersion()
checks := m.checks(current, err)
status := Status{
Supported: true,
Connected: true,
Repository: m.config.Repository,
Deployment: "docker-compose-host-updater",
CurrentVersion: current,
LatestRelease: cloneRelease(m.state.LatestRelease),
Checks: checks,
LastBackup: cloneBackup(m.state.LastBackup),
RollbackVersion: m.state.RollbackVersion,
Operation: cloneOperation(m.state.Operation),
}
if status.LatestRelease != nil && err == nil {
status.UpdateAvailable = CompareVersions(current, status.LatestRelease.Version) < 0
}
return status
}
func (m *Manager) checks(current string, currentErr error) []Check {
items := []Check{
{Key: "updater", Label: "Host Updater", Status: "passed", Detail: runtime.GOOS + "/" + runtime.GOARCH, Blocking: true},
{Key: "version", Label: "当前版本", Status: "passed", Detail: current, Blocking: true},
{Key: "backup", Label: "数据库备份 ZIP", Status: "pending", Detail: "开始更新后自动创建并校验", Blocking: true},
{Key: "images", Label: "目标镜像", Status: "pending", Detail: "拉取后校验仓库摘要", Blocking: true},
{Key: "migration", Label: "数据库迁移", Status: "pending", Detail: "在旧服务完全停止后执行", Blocking: true},
}
if currentErr != nil {
items[1].Status = "failed"
items[1].Detail = currentErr.Error()
}
if m.state.LastBackup != nil {
items[2].Status = "passed"
items[2].Detail = m.state.LastBackup.ID + " · " + m.state.LastBackup.Checksum
}
return items
}
func (m *Manager) setPhase(phase Phase, message string) {
m.mu.Lock()
defer m.mu.Unlock()
m.state.Operation.Phase = phase
m.appendLogLocked(phase, message)
_ = m.saveStateLocked()
}
func (m *Manager) appendLogLocked(phase Phase, message string) {
m.state.Operation.Logs = append(m.state.Operation.Logs, LogEntry{At: time.Now().UTC(), Phase: phase, Message: message})
if len(m.state.Operation.Logs) > 200 {
m.state.Operation.Logs = append([]LogEntry(nil), m.state.Operation.Logs[len(m.state.Operation.Logs)-200:]...)
}
}
func (m *Manager) loadState() error {
data, err := os.ReadFile(m.statePath())
if errors.Is(err, os.ErrNotExist) {
return nil
}
if err != nil {
return fmt.Errorf("读取更新器状态:%w", err)
}
if err := json.Unmarshal(data, &m.state); err != nil {
return fmt.Errorf("解析更新器状态:%w", err)
}
if m.state.Operation.Phase == "" {
m.state.Operation.Phase = PhaseIdle
}
return nil
}
func (m *Manager) saveStateLocked() error {
data, err := json.MarshalIndent(m.state, "", " ")
if err != nil {
return err
}
temporary, err := os.CreateTemp(m.config.StateDir, ".state-*.json")
if err != nil {
return err
}
temporaryName := temporary.Name()
defer os.Remove(temporaryName)
if err := temporary.Chmod(0o600); err != nil {
temporary.Close()
return err
}
if _, err := temporary.Write(data); err != nil {
temporary.Close()
return err
}
if err := temporary.Sync(); err != nil {
temporary.Close()
return err
}
if err := temporary.Close(); err != nil {
return err
}
return os.Rename(temporaryName, m.statePath())
}
func (m *Manager) statePath() string { return filepath.Join(m.config.StateDir, "state.json") }
func (m *Manager) composePath() string {
return filepath.Join(m.config.InstallDir, m.config.ComposeFile)
}
func (m *Manager) envPath() string { return filepath.Join(m.config.InstallDir, m.config.EnvFile) }
func (m *Manager) previousComposePath() string {
return filepath.Join(m.config.StateDir, "previous-compose.yml")
}
func randomID() string {
buffer := make([]byte, 12)
if _, err := rand.Read(buffer); err != nil {
return strconv.FormatInt(time.Now().UnixNano(), 36)
}
return hex.EncodeToString(buffer)
}
func safeOperationError(err error) string {
if err == nil {
return ""
}
message := strings.TrimSpace(err.Error())
if len(message) > 1200 {
message = message[:1200]
}
return message
}
func cloneRelease(value *Release) *Release {
if value == nil {
return nil
}
cloned := *value
return &cloned
}
func cloneBackup(value *Backup) *Backup {
if value == nil {
return nil
}
cloned := *value
cloned.Path = ""
return &cloned
}
func cloneOperation(value Operation) Operation {
value.Logs = append([]LogEntry(nil), value.Logs...)
return value
}
+612
View File
@@ -0,0 +1,612 @@
package hostupdate
import (
"archive/zip"
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"runtime"
"sort"
"strings"
"syscall"
"time"
)
type githubRelease struct {
TagName string `json:"tag_name"`
Name string `json:"name"`
Body string `json:"body"`
HTMLURL string `json:"html_url"`
PublishedAt time.Time `json:"published_at"`
Draft bool `json:"draft"`
Prerelease bool `json:"prerelease"`
}
func (m *Manager) latestRelease(ctx context.Context) (*Release, error) {
url := "https://api.github.com/repos/" + m.config.Repository + "/releases?per_page=30"
request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return nil, err
}
request.Header.Set("Accept", "application/vnd.github+json")
request.Header.Set("User-Agent", "open-ai-canvas-host-updater")
request.Header.Set("X-GitHub-Api-Version", "2022-11-28")
if m.config.GitHubToken != "" {
request.Header.Set("Authorization", "Bearer "+m.config.GitHubToken)
}
response, err := m.httpClient.Do(request)
if err != nil {
return nil, fmt.Errorf("请求 GitHub Release:%w", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
_, _ = io.Copy(io.Discard, io.LimitReader(response.Body, 64<<10))
return nil, fmt.Errorf("GitHub Release 返回 HTTP %d", response.StatusCode)
}
var releases []githubRelease
decoder := json.NewDecoder(io.LimitReader(response.Body, maxReleaseResponseBytes))
if err := decoder.Decode(&releases); err != nil {
return nil, fmt.Errorf("解析 GitHub Release:%w", err)
}
filtered := make([]githubRelease, 0, len(releases))
for _, release := range releases {
if !release.Draft && strings.HasPrefix(release.TagName, "v") {
filtered = append(filtered, release)
}
}
if len(filtered) == 0 {
return nil, errors.New("GitHub 尚未发布可用 Release")
}
sort.SliceStable(filtered, func(i, j int) bool { return CompareVersions(filtered[i].TagName, filtered[j].TagName) > 0 })
latest := filtered[0]
return &Release{Version: latest.TagName, Name: latest.Name, Body: latest.Body, URL: latest.HTMLURL, PublishedAt: latest.PublishedAt, Prerelease: latest.Prerelease}, nil
}
func (m *Manager) currentVersion() (string, error) {
values, err := readEnvFile(m.envPath())
if err != nil {
return "", err
}
version := strings.TrimSpace(values["CANVAS_IMAGE_TAG"])
if version == "" || version == "latest" {
return "", errors.New("CANVAS_IMAGE_TAG 必须固定为发布版本,不能使用 latest")
}
if !strings.HasPrefix(version, "v") {
version = "v" + version
}
return version, nil
}
func (m *Manager) prepareTargetCompose(targetVersion string) (string, error) {
url := fmt.Sprintf("https://raw.githubusercontent.com/%s/%s/%s", m.config.Repository, targetVersion, m.config.ComposeFile)
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
defer cancel()
request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return "", err
}
response, err := m.httpClient.Do(request)
if err != nil {
return "", fmt.Errorf("下载目标 Compose:%w", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return "", fmt.Errorf("下载目标 Compose 返回 HTTP %d", response.StatusCode)
}
data, err := io.ReadAll(io.LimitReader(response.Body, 2<<20))
if err != nil {
return "", err
}
if len(data) == 0 {
return "", errors.New("目标 Compose 文件为空")
}
path := filepath.Join(m.config.StateDir, "compose-"+strings.TrimPrefix(targetVersion, "v")+".next.yml")
if err := os.WriteFile(path, data, 0o600); err != nil {
return "", fmt.Errorf("保存目标 Compose:%w", err)
}
return path, nil
}
func (m *Manager) preflight(composePath, targetVersion string) error {
if _, err := os.Stat(m.composePath()); err != nil {
return fmt.Errorf("读取当前 Compose:%w", err)
}
if _, err := os.Stat(m.envPath()); err != nil {
return fmt.Errorf("读取部署环境:%w", err)
}
var disk syscall.Statfs_t
if err := syscall.Statfs(m.config.BackupDir, &disk); err != nil {
return fmt.Errorf("检查备份磁盘空间:%w", err)
}
available := int64(disk.Bavail) * int64(disk.Bsize)
if available < 2<<30 {
return fmt.Errorf("备份目录可用空间不足 2 GiB:当前 %d MiB", available>>20)
}
if err := m.compose(composePath, targetVersion, 2*time.Minute, nil, "config", "--quiet"); err != nil {
return fmt.Errorf("目标 Compose 校验失败:%w", err)
}
current, err := m.currentVersion()
if err != nil {
return err
}
if err := m.checkHealthOnce(m.healthURL(), current); err != nil {
return fmt.Errorf("当前运行版本与部署配置不一致或服务未就绪:%w", err)
}
return nil
}
func (m *Manager) prepareUpdaterBinary(targetVersion string) (string, error) {
if !m.config.SelfUpdate {
return "", nil
}
if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") {
return "", fmt.Errorf("Host Updater 自更新不支持 %s/%s", runtime.GOOS, runtime.GOARCH)
}
if strings.TrimSpace(m.config.BinaryPath) == "" {
return "", errors.New("未配置 Host Updater 二进制路径")
}
baseURL := fmt.Sprintf("https://github.com/%s/releases/download/%s/", m.config.Repository, targetVersion)
asset := "open-ai-canvas-host-updater-linux-" + runtime.GOARCH
checksums, err := m.downloadReleaseAsset(baseURL+"SHA256SUMS", 1<<20)
if err != nil {
return "", fmt.Errorf("下载 Host Updater 校验清单:%w", err)
}
expected := ""
for _, line := range strings.Split(string(checksums), "\n") {
fields := strings.Fields(line)
if len(fields) == 2 && fields[1] == asset {
expected = fields[0]
break
}
}
if len(expected) != 64 {
return "", fmt.Errorf("目标 Release 的 SHA256SUMS 缺少 %s", asset)
}
binary, err := m.downloadReleaseAsset(baseURL+asset, 128<<20)
if err != nil {
return "", fmt.Errorf("下载目标 Host Updater:%w", err)
}
hash := sha256.Sum256(binary)
actual := hex.EncodeToString(hash[:])
if actual != expected {
return "", fmt.Errorf("Host Updater 校验失败:期望 %s,实际 %s", expected, actual)
}
path := filepath.Join(m.config.StateDir, asset+"-"+strings.TrimPrefix(targetVersion, "v")+".next")
if err := os.WriteFile(path, binary, 0o700); err != nil {
return "", err
}
return path, nil
}
func (m *Manager) downloadReleaseAsset(url string, limit int64) ([]byte, error) {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
return nil, err
}
request.Header.Set("User-Agent", "open-ai-canvas-host-updater")
response, err := m.httpClient.Do(request)
if err != nil {
return nil, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return nil, fmt.Errorf("HTTP %d", response.StatusCode)
}
reader := io.LimitReader(response.Body, limit+1)
data, err := io.ReadAll(reader)
if err != nil {
return nil, err
}
if int64(len(data)) > limit {
return nil, errors.New("Release 资产超过允许大小")
}
return data, nil
}
func (m *Manager) restartSelf() {
time.Sleep(time.Second)
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
_ = m.runner.Run(ctx, "systemctl", []string{"restart", m.config.ServiceName}, nil, io.Discard, io.Discard)
}
func (m *Manager) compose(composePath, imageTag string, timeout time.Duration, stdout io.Writer, arguments ...string) error {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
args := []string{"compose", "--env-file", m.envPath(), "-f", composePath}
args = append(args, arguments...)
var stderr bytes.Buffer
if stdout == nil {
stdout = io.Discard
}
err := m.runner.Run(ctx, "docker", args, []string{"CANVAS_IMAGE_TAG=" + strings.TrimPrefix(imageTag, "v")}, stdout, &stderr)
if err != nil {
message := strings.TrimSpace(stderr.String())
if len(message) > 1000 {
message = message[len(message)-1000:]
}
if message != "" {
return fmt.Errorf("docker compose %s:%s", strings.Join(arguments, " "), message)
}
return fmt.Errorf("docker compose %s:%w", strings.Join(arguments, " "), err)
}
return nil
}
func (m *Manager) verifyImages(targetVersion string) error {
owner := strings.SplitN(m.config.Repository, "/", 2)[0]
for _, image := range []string{"ghcr.io/" + owner + "/open-ai-canvas-backend:", "ghcr.io/" + owner + "/open-ai-canvas-web:"} {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
var output bytes.Buffer
var stderr bytes.Buffer
err := m.runner.Run(ctx, "docker", []string{"image", "inspect", image + strings.TrimPrefix(targetVersion, "v"), "--format", "{{json .RepoDigests}}"}, nil, &output, &stderr)
cancel()
if err != nil {
return fmt.Errorf("校验目标镜像摘要失败:%s", strings.TrimSpace(stderr.String()))
}
if !strings.Contains(output.String(), "@sha256:") {
return fmt.Errorf("目标镜像 %s 未包含仓库摘要", image+targetVersion)
}
}
return nil
}
func (m *Manager) createBackup(version string) (Backup, error) {
now := time.Now().UTC()
id := "backup-" + now.Format("20060102-150405")
path := filepath.Join(m.config.BackupDir, id+".zip")
temporary := path + ".partial"
file, err := os.OpenFile(temporary, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err != nil {
return Backup{}, fmt.Errorf("创建备份文件:%w", err)
}
removeTemporary := true
defer func() {
_ = file.Close()
if removeTemporary {
_ = os.Remove(temporary)
}
}()
hasher := sha256.New()
archive := zip.NewWriter(io.MultiWriter(file, hasher))
metadata, _ := json.MarshalIndent(map[string]any{"id": id, "version": version, "createdAt": now, "format": 1}, "", " ")
if err := writeZipBytes(archive, "metadata.json", metadata); err != nil {
return Backup{}, err
}
databaseEntry, err := archive.CreateHeader(&zip.FileHeader{Name: "database.dump", Method: zip.Store})
if err != nil {
return Backup{}, err
}
values, err := readEnvFile(m.envPath())
if err != nil {
return Backup{}, err
}
postgresUser := firstNonEmpty(values["POSTGRES_USER"], "open_ai_canvas")
postgresDB := firstNonEmpty(values["POSTGRES_DB"], "open_ai_canvas")
if err := m.compose(m.composePath(), version, m.config.StepTimeout, databaseEntry, "exec", "-T", "postgres", "pg_dump", "-U", postgresUser, "-d", postgresDB, "-Fc"); err != nil {
return Backup{}, fmt.Errorf("备份 PostgreSQL:%w", err)
}
dataEntry, err := archive.CreateHeader(&zip.FileHeader{Name: "backend-data.tar", Method: zip.Store})
if err != nil {
return Backup{}, err
}
if err := m.compose(m.composePath(), version, m.config.StepTimeout, dataEntry, "exec", "-T", "backend", "tar", "-C", "/data", "-cf", "-", "."); err != nil {
return Backup{}, fmt.Errorf("备份数据目录:%w", err)
}
if err := archive.Close(); err != nil {
return Backup{}, fmt.Errorf("完成 ZIP 备份:%w", err)
}
if err := file.Sync(); err != nil {
return Backup{}, fmt.Errorf("同步 ZIP 备份:%w", err)
}
if err := file.Close(); err != nil {
return Backup{}, err
}
if err := os.Rename(temporary, path); err != nil {
return Backup{}, fmt.Errorf("提交 ZIP 备份:%w", err)
}
removeTemporary = false
stat, err := os.Stat(path)
if err != nil {
return Backup{}, err
}
checksum := "sha256:" + hex.EncodeToString(hasher.Sum(nil))
if err := verifyZipBackup(path, checksum); err != nil {
return Backup{}, err
}
return Backup{ID: id, Path: path, Checksum: checksum, Size: stat.Size(), CreatedAt: now, Version: version}, nil
}
func writeZipBytes(writer *zip.Writer, name string, data []byte) error {
entry, err := writer.CreateHeader(&zip.FileHeader{Name: name, Method: zip.Deflate})
if err != nil {
return err
}
_, err = entry.Write(data)
return err
}
func verifyZipBackup(path, expected string) error {
file, err := os.Open(path)
if err != nil {
return err
}
hasher := sha256.New()
if _, err := io.Copy(hasher, file); err != nil {
file.Close()
return err
}
if err := file.Close(); err != nil {
return err
}
actual := "sha256:" + hex.EncodeToString(hasher.Sum(nil))
if actual != expected {
return fmt.Errorf("ZIP 备份校验失败:期望 %s,实际 %s", expected, actual)
}
archive, err := zip.OpenReader(path)
if err != nil {
return fmt.Errorf("ZIP 备份无法打开:%w", err)
}
defer archive.Close()
required := map[string]bool{"metadata.json": false, "database.dump": false, "backend-data.tar": false}
for _, entry := range archive.File {
if _, ok := required[entry.Name]; ok && entry.UncompressedSize64 > 0 {
required[entry.Name] = true
}
}
for name, present := range required {
if !present {
return fmt.Errorf("ZIP 备份缺少有效文件 %s", name)
}
}
return nil
}
func (m *Manager) restoreDatabase(backup Backup) error {
if err := verifyZipBackup(backup.Path, backup.Checksum); err != nil {
return fmt.Errorf("拒绝恢复未通过校验的备份:%w", err)
}
archive, err := zip.OpenReader(backup.Path)
if err != nil {
return err
}
defer archive.Close()
var dump *zip.File
for _, entry := range archive.File {
if entry.Name == "database.dump" {
dump = entry
break
}
}
if dump == nil {
return errors.New("备份中不存在 database.dump")
}
reader, err := dump.Open()
if err != nil {
return err
}
defer reader.Close()
values, err := readEnvFile(m.envPath())
if err != nil {
return err
}
postgresUser := firstNonEmpty(values["POSTGRES_USER"], "open_ai_canvas")
postgresDB := firstNonEmpty(values["POSTGRES_DB"], "open_ai_canvas")
if postgresDB == "postgres" || strings.HasPrefix(postgresDB, "template") {
return fmt.Errorf("拒绝覆盖 PostgreSQL 系统数据库 %q", postgresDB)
}
if err := m.compose(m.composePath(), backup.Version, 5*time.Minute, nil, "exec", "-T", "postgres", "dropdb", "-U", postgresUser, "--if-exists", "--force", postgresDB); err != nil {
return fmt.Errorf("删除待恢复数据库:%w", err)
}
if err := m.compose(m.composePath(), backup.Version, 5*time.Minute, nil, "exec", "-T", "postgres", "createdb", "-U", postgresUser, "-O", postgresUser, postgresDB); err != nil {
return fmt.Errorf("重建待恢复数据库:%w", err)
}
ctx, cancel := context.WithTimeout(context.Background(), m.config.StepTimeout)
defer cancel()
args := []string{"compose", "--env-file", m.envPath(), "-f", m.composePath(), "exec", "-T", "postgres", "pg_restore", "-U", postgresUser, "-d", postgresDB, "--no-owner", "--no-privileges"}
var stderr bytes.Buffer
command := execCommandWithInput{runner: m.runner, input: reader}
if err := command.Run(ctx, "docker", args, []string{"CANVAS_IMAGE_TAG=" + strings.TrimPrefix(backup.Version, "v")}, io.Discard, &stderr); err != nil {
return fmt.Errorf("恢复 PostgreSQL:%s", strings.TrimSpace(stderr.String()))
}
return nil
}
type execCommandWithInput struct {
runner commandRunner
input io.Reader
}
func (c execCommandWithInput) Run(ctx context.Context, name string, args, environment []string, stdout, stderr io.Writer) error {
runner, ok := c.runner.(execRunner)
if !ok {
return errors.New("当前命令执行器不支持标准输入")
}
command := exec.CommandContext(ctx, name, args...)
command.Dir = runner.dir
command.Env = append(os.Environ(), environment...)
command.Stdin = c.input
command.Stdout = stdout
command.Stderr = stderr
return command.Run()
}
func (m *Manager) verifyHealthy(targetVersion string) error {
healthURL := m.healthURL()
deadline := time.Now().Add(10 * time.Minute)
stableSince := time.Time{}
for time.Now().Before(deadline) {
if err := m.checkHealthOnce(healthURL, targetVersion); err != nil {
stableSince = time.Time{}
} else if stableSince.IsZero() {
stableSince = time.Now()
} else if time.Since(stableSince) >= m.config.StableWindow {
return nil
}
time.Sleep(2 * time.Second)
}
return fmt.Errorf("目标版本 %s 未在健康检查窗口内稳定就绪", targetVersion)
}
func (m *Manager) healthURL() string {
if configured := strings.TrimSpace(m.config.HealthURL); configured != "" {
return configured
}
values, err := readEnvFile(m.envPath())
if err != nil {
return "http://127.0.0.1:3000/api/health/ready"
}
return "http://127.0.0.1:" + firstNonEmpty(values["CANVAS_HTTP_PORT"], "3000") + "/api/health/ready"
}
func (m *Manager) checkHealthOnce(healthURL, targetVersion string) error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
request, _ := http.NewRequestWithContext(ctx, http.MethodGet, healthURL, nil)
response, err := m.httpClient.Do(request)
if err != nil {
return err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return fmt.Errorf("健康接口返回 HTTP %d", response.StatusCode)
}
var payload struct {
Code int `json:"code"`
Data struct {
Build struct {
Version string `json:"version"`
} `json:"build"`
} `json:"data"`
}
if err := json.NewDecoder(io.LimitReader(response.Body, 256<<10)).Decode(&payload); err != nil {
return err
}
if payload.Code != 0 {
return errors.New("健康接口业务状态异常")
}
if payload.Data.Build.Version != "" && CompareVersions(payload.Data.Build.Version, targetVersion) != 0 {
return fmt.Errorf("运行版本仍为 %s,期望 %s", payload.Data.Build.Version, targetVersion)
}
return nil
}
func readEnvFile(path string) (map[string]string, error) {
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("读取 %s:%w", path, err)
}
values := make(map[string]string)
for _, line := range strings.Split(string(data), "\n") {
line = strings.TrimSpace(line)
if line == "" || strings.HasPrefix(line, "#") {
continue
}
key, value, ok := strings.Cut(line, "=")
if ok {
values[strings.TrimSpace(key)] = strings.Trim(strings.TrimSpace(value), "\"")
}
}
return values, nil
}
func setEnvValue(path, key, value string) error {
data, err := os.ReadFile(path)
if err != nil {
return err
}
lines := strings.Split(strings.TrimSuffix(string(data), "\n"), "\n")
found := false
for index, line := range lines {
trimmed := strings.TrimSpace(line)
if strings.HasPrefix(trimmed, key+"=") {
lines[index] = key + "=" + value
found = true
}
}
if !found {
lines = append(lines, key+"="+value)
}
stat, err := os.Stat(path)
if err != nil {
return err
}
temporary, err := os.CreateTemp(filepath.Dir(path), ".env-*.tmp")
if err != nil {
return err
}
temporaryName := temporary.Name()
defer os.Remove(temporaryName)
if err := temporary.Chmod(stat.Mode().Perm()); err != nil {
temporary.Close()
return err
}
if _, err := temporary.WriteString(strings.Join(lines, "\n") + "\n"); err != nil {
temporary.Close()
return err
}
if err := temporary.Sync(); err != nil {
temporary.Close()
return err
}
if err := temporary.Close(); err != nil {
return err
}
return os.Rename(temporaryName, path)
}
func replaceFile(source, target string, mode os.FileMode) error {
data, err := os.ReadFile(source)
if err != nil {
return err
}
if mode == 0 {
if stat, statErr := os.Stat(target); statErr == nil {
mode = stat.Mode().Perm()
} else {
mode = 0o600
}
}
temporary, err := os.CreateTemp(filepath.Dir(target), ".compose-*.tmp")
if err != nil {
return err
}
temporaryName := temporary.Name()
defer os.Remove(temporaryName)
if err := temporary.Chmod(mode); err != nil {
temporary.Close()
return err
}
if _, err := temporary.Write(data); err != nil {
temporary.Close()
return err
}
if err := temporary.Sync(); err != nil {
temporary.Close()
return err
}
if err := temporary.Close(); err != nil {
return err
}
return os.Rename(temporaryName, target)
}
func firstNonEmpty(values ...string) string {
for _, value := range values {
if strings.TrimSpace(value) != "" {
return strings.TrimSpace(value)
}
}
return ""
}
@@ -0,0 +1,92 @@
package hostupdate
import (
"archive/zip"
"crypto/sha256"
"encoding/hex"
"io"
"os"
"path/filepath"
"strings"
"testing"
)
func TestSetEnvValuePreservesOtherSettings(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, ".env")
if err := os.WriteFile(path, []byte("# keep\nCANVAS_IMAGE_TAG=1.0.0\nPOSTGRES_DB=canvas\n"), 0o640); err != nil {
t.Fatal(err)
}
if err := setEnvValue(path, "CANVAS_IMAGE_TAG", "1.2.2-preview.1"); err != nil {
t.Fatal(err)
}
data, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
value := string(data)
if !strings.Contains(value, "# keep\n") || !strings.Contains(value, "POSTGRES_DB=canvas\n") || !strings.Contains(value, "CANVAS_IMAGE_TAG=1.2.2-preview.1\n") {
t.Fatalf("unexpected env contents: %q", value)
}
stat, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
if stat.Mode().Perm() != 0o640 {
t.Fatalf("mode=%o, want 640", stat.Mode().Perm())
}
}
func TestVerifyZipBackupRejectsCorruption(t *testing.T) {
path := filepath.Join(t.TempDir(), "backup.zip")
file, err := os.Create(path)
if err != nil {
t.Fatal(err)
}
archive := zip.NewWriter(file)
for name, content := range map[string]string{
"metadata.json": "{}",
"database.dump": "database",
"backend-data.tar": "data",
} {
entry, createErr := archive.Create(name)
if createErr != nil {
t.Fatal(createErr)
}
if _, writeErr := io.WriteString(entry, content); writeErr != nil {
t.Fatal(writeErr)
}
}
if err := archive.Close(); err != nil {
t.Fatal(err)
}
if err := file.Close(); err != nil {
t.Fatal(err)
}
data, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
hash := sha256.Sum256(data)
checksum := "sha256:" + hex.EncodeToString(hash[:])
if err := verifyZipBackup(path, checksum); err != nil {
t.Fatalf("valid backup rejected: %v", err)
}
if err := os.WriteFile(path, append(data, byte(1)), 0o600); err != nil {
t.Fatal(err)
}
if err := verifyZipBackup(path, checksum); err == nil {
t.Fatal("corrupted backup was accepted")
}
}
func TestCurrentVersionRejectsLatest(t *testing.T) {
installDir := t.TempDir()
if err := os.WriteFile(filepath.Join(installDir, ".env"), []byte("CANVAS_IMAGE_TAG=latest\n"), 0o600); err != nil {
t.Fatal(err)
}
manager := &Manager{config: Config{InstallDir: installDir, EnvFile: ".env"}}
if _, err := manager.currentVersion(); err == nil {
t.Fatal("latest tag was accepted")
}
}
+101
View File
@@ -0,0 +1,101 @@
package hostupdate
import (
"crypto/subtle"
"encoding/json"
"errors"
"io"
"net/http"
"strings"
)
type Server struct {
manager *Manager
token string
}
func NewServer(manager *Manager, token string) (*Server, error) {
if manager == nil {
return nil, errors.New("更新管理器不能为空")
}
if len(strings.TrimSpace(token)) < 32 {
return nil, errors.New("CANVAS_UPDATER_TOKEN 至少需要 32 个字符")
}
return &Server{manager: manager, token: strings.TrimSpace(token)}, nil
}
func (s *Server) Handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /v1/status", func(w http.ResponseWriter, _ *http.Request) { writeJSON(w, http.StatusOK, s.manager.Snapshot()) })
mux.HandleFunc("POST /v1/check", func(w http.ResponseWriter, r *http.Request) {
status, err := s.manager.Check(r.Context())
if err != nil {
writeError(w, http.StatusBadGateway, err, status)
return
}
writeJSON(w, http.StatusOK, status)
})
mux.HandleFunc("POST /v1/update", func(w http.ResponseWriter, r *http.Request) {
var request StartRequest
if err := decodeJSON(r, &request); err != nil {
writeError(w, http.StatusBadRequest, err, nil)
return
}
status, err := s.manager.StartUpdate(request.TargetVersion)
if err != nil {
writeError(w, http.StatusConflict, err, status)
return
}
writeJSON(w, http.StatusAccepted, status)
})
mux.HandleFunc("POST /v1/rollback", func(w http.ResponseWriter, r *http.Request) {
var request RollbackRequest
if err := decodeJSON(r, &request); err != nil {
writeError(w, http.StatusBadRequest, err, nil)
return
}
status, err := s.manager.StartRollback(request.Reason)
if err != nil {
writeError(w, http.StatusConflict, err, status)
return
}
writeJSON(w, http.StatusAccepted, status)
})
return s.authorize(mux)
}
func (s *Server) authorize(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
provided := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer "))
if len(provided) != len(s.token) || subtle.ConstantTimeCompare([]byte(provided), []byte(s.token)) != 1 {
writeError(w, http.StatusUnauthorized, errors.New("更新器认证失败"), nil)
return
}
w.Header().Set("Cache-Control", "no-store")
next.ServeHTTP(w, r)
})
}
func decodeJSON(r *http.Request, target any) error {
defer r.Body.Close()
decoder := json.NewDecoder(io.LimitReader(r.Body, 64<<10))
decoder.DisallowUnknownFields()
if err := decoder.Decode(target); err != nil {
return err
}
return nil
}
func writeError(w http.ResponseWriter, status int, err error, data any) {
writeJSONStatus(w, status, map[string]any{"error": err.Error(), "data": data})
}
func writeJSON(w http.ResponseWriter, status int, value any) {
writeJSONStatus(w, status, value)
}
func writeJSONStatus(w http.ResponseWriter, status int, value any) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(value)
}
+100
View File
@@ -0,0 +1,100 @@
package hostupdate
import "time"
type Phase string
const (
PhaseIdle Phase = "idle"
PhaseChecking Phase = "checking"
PhaseReady Phase = "ready"
PhaseNoUpdate Phase = "no_update"
PhasePreflight Phase = "preflight"
PhaseBackingUp Phase = "backing_up"
PhasePulling Phase = "pulling"
PhaseDraining Phase = "draining"
PhaseMigrating Phase = "migrating"
PhaseSwitching Phase = "switching"
PhaseVerifying Phase = "verifying"
PhaseSucceeded Phase = "succeeded"
PhaseRollingBack Phase = "rolling_back"
PhaseRolledBack Phase = "rolled_back"
PhaseFailed Phase = "failed"
PhaseManualIntervention Phase = "manual_intervention"
)
func (p Phase) Active() bool {
switch p {
case PhasePreflight, PhaseBackingUp, PhasePulling, PhaseDraining, PhaseMigrating, PhaseSwitching, PhaseVerifying, PhaseRollingBack:
return true
default:
return false
}
}
type Release struct {
Version string `json:"version"`
Name string `json:"name"`
Body string `json:"body"`
URL string `json:"url"`
PublishedAt time.Time `json:"publishedAt"`
Prerelease bool `json:"prerelease"`
}
type Check struct {
Key string `json:"key"`
Label string `json:"label"`
Status string `json:"status"`
Detail string `json:"detail,omitempty"`
Blocking bool `json:"blocking"`
}
type Backup struct {
ID string `json:"id"`
Path string `json:"path"`
Checksum string `json:"checksum"`
Size int64 `json:"size"`
CreatedAt time.Time `json:"createdAt"`
Version string `json:"version"`
}
type LogEntry struct {
At time.Time `json:"at"`
Phase Phase `json:"phase"`
Message string `json:"message"`
}
type Operation struct {
ID string `json:"id,omitempty"`
Phase Phase `json:"phase"`
FromVersion string `json:"fromVersion,omitempty"`
TargetVersion string `json:"targetVersion,omitempty"`
StartedAt *time.Time `json:"startedAt,omitempty"`
FinishedAt *time.Time `json:"finishedAt,omitempty"`
Error string `json:"error,omitempty"`
RollbackError string `json:"rollbackError,omitempty"`
AutomaticRollback bool `json:"automaticRollback"`
Logs []LogEntry `json:"logs"`
}
type Status struct {
Supported bool `json:"supported"`
Connected bool `json:"connected"`
Repository string `json:"repository"`
Deployment string `json:"deployment"`
CurrentVersion string `json:"currentVersion"`
LatestRelease *Release `json:"latestRelease,omitempty"`
UpdateAvailable bool `json:"updateAvailable"`
Checks []Check `json:"checks"`
LastBackup *Backup `json:"lastBackup,omitempty"`
RollbackVersion string `json:"rollbackVersion,omitempty"`
Operation Operation `json:"operation"`
}
type StartRequest struct {
TargetVersion string `json:"targetVersion"`
}
type RollbackRequest struct {
Reason string `json:"reason"`
}
+79
View File
@@ -0,0 +1,79 @@
package hostupdate
import (
"strconv"
"strings"
)
type versionPart struct {
major, minor, patch int
pre []string
}
func CompareVersions(left, right string) int {
a, aok := parseVersion(left)
b, bok := parseVersion(right)
if !aok || !bok {
return strings.Compare(strings.TrimSpace(left), strings.TrimSpace(right))
}
for _, pair := range [][2]int{{a.major, b.major}, {a.minor, b.minor}, {a.patch, b.patch}} {
if pair[0] < pair[1] {
return -1
}
if pair[0] > pair[1] {
return 1
}
}
if len(a.pre) == 0 && len(b.pre) > 0 {
return 1
}
if len(a.pre) > 0 && len(b.pre) == 0 {
return -1
}
for index := 0; index < len(a.pre) || index < len(b.pre); index++ {
if index >= len(a.pre) {
return -1
}
if index >= len(b.pre) {
return 1
}
an, aerr := strconv.Atoi(a.pre[index])
bn, berr := strconv.Atoi(b.pre[index])
switch {
case aerr == nil && berr == nil && an < bn:
return -1
case aerr == nil && berr == nil && an > bn:
return 1
case aerr == nil && berr != nil:
return -1
case aerr != nil && berr == nil:
return 1
case a.pre[index] < b.pre[index]:
return -1
case a.pre[index] > b.pre[index]:
return 1
}
}
return 0
}
func parseVersion(raw string) (versionPart, bool) {
value := strings.TrimPrefix(strings.TrimSpace(raw), "v")
value = strings.SplitN(value, "+", 2)[0]
parts := strings.SplitN(value, "-", 2)
core := strings.Split(parts[0], ".")
if len(core) != 3 {
return versionPart{}, false
}
major, err1 := strconv.Atoi(core[0])
minor, err2 := strconv.Atoi(core[1])
patch, err3 := strconv.Atoi(core[2])
if err1 != nil || err2 != nil || err3 != nil {
return versionPart{}, false
}
parsed := versionPart{major: major, minor: minor, patch: patch}
if len(parts) == 2 && parts[1] != "" {
parsed.pre = strings.FieldsFunc(parts[1], func(r rune) bool { return r == '.' || r == '-' })
}
return parsed, true
}
@@ -0,0 +1,27 @@
package hostupdate
import "testing"
func TestCompareVersions(t *testing.T) {
tests := []struct {
left, right string
want int
}{
{"v1.2.0-preview.2", "v1.2.0-preview.3", -1},
{"v1.2.0-preview.10", "v1.2.0-preview.3", 1},
{"v1.2.0-preview.3", "v1.2.0", -1},
{"v1.2.1", "v1.2.0", 1},
{"v1.2.0", "v1.2.0", 0},
}
for _, test := range tests {
got := CompareVersions(test.left, test.right)
if got < 0 {
got = -1
} else if got > 0 {
got = 1
}
if got != test.want {
t.Fatalf("CompareVersions(%q, %q)=%d, want %d", test.left, test.right, got, test.want)
}
}
}