feat(deploy): 在线更新 - 新增后台检查、强制备份迁移与失败自动回退
This commit is contained in:
1 parent
4ba9694f45
commit
db66ac1182
60 files changed
+4124
-93
No files matched your search
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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"`
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user