package server
import (
"archive/tar"
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"io/fs"
"log"
"net/http"
"os"
"path/filepath"
"strings"
"sync"
"time"
pgdb "github.com/Autumn-27/artex/db"
"github.com/klauspost/compress/zstd"
)
// 一键备份 / 恢复(迁移数据)。
//
// 备份包是 tar.zst,结构:
//
// db/
.copy PostgreSQL 各表的 COPY 文本数据(大表按分片追加 .000001…)
// files/ 数据目录(任务工作区、会话、流量、证据、归档包、MITM CA…)
// skills//… skill 目录
// manifest.json 最后写入:表结构、分片与行数、来源数据目录、顶层条目清单
//
// 恢复分两步:上传时只解包到 /.restore-pending 并对照当前 schema 校验,
// 然后请求重启;真正的替换在下次启动、任何组件打开数据之前由 ApplyPendingRestore
// 完成——运行中的 Agent、流量代理和 SQLite 索引都还没碰数据目录,替换才安全。
// 数据库在一个事务内整体替换,失败则保持原数据不动。
const (
backupFormat = 1
backupManifestName = "manifest.json"
backupPendingDir = ".restore-pending"
backupUploadPrefix = ".restore-upload-"
backupPreviousDir = ".restore-previous"
backupFailedDir = ".restore-failed"
backupDBDoneMarker = ".db-restored"
backupRestoreIDFile = ".restore-id"
backupMaxFiles = 20_000_000
backupTrafficIndex = "traffic/_index" // live SQLite; exported via SnapshotIndex
)
// backupCopyChunkBytes bounds each streamed DB COPY tar entry so large tables
// flush compressed bytes to the client without disk spooling or proxy timeouts.
var backupCopyChunkBytes = 8 << 20
// backupSkipped lists data-dir paths (slash form, relative) that hold transient
// staging state rather than data. Top-level dot entries are skipped as well.
var backupSkipped = map[string]bool{
"traffic/_delete_staging": true,
"archives/tasks/.staging": true,
"archives/tasks/.restore": true,
"evidence/.staging": true,
"traffic/_index/.snapshot": true,
}
type backupTableEntry struct {
pgdb.BackupTable
Parts int `json:"parts,omitempty"`
}
type backupManifest struct {
Format int `json:"format"`
Version string `json:"version"`
CreatedAt time.Time `json:"created_at"`
DataDir string `json:"data_dir"`
Separator string `json:"separator"`
Tables []backupTableEntry `json:"tables"`
Entries []string `json:"entries"`
Skills []string `json:"skills"`
}
// backupMu serializes export and restore staging: two concurrent restores
// would race on the pending directory, and an export racing a restore upload
// is never what the operator meant.
var backupMu sync.Mutex
// BackupRestoreResult is the outcome of the boot-time restore, reported to the
// UI after the restart that applied it.
type BackupRestoreResult struct {
ID string `json:"id,omitempty"`
Applied bool `json:"applied"`
Error string `json:"error,omitempty"`
At time.Time `json:"at"`
Source string `json:"source_version,omitempty"`
Created time.Time `json:"backup_created_at,omitempty"`
}
var (
bootRestoreMu sync.Mutex
bootRestore *BackupRestoreResult
)
// SetBootRestoreResult is called once by main with ApplyPendingRestore's result.
func SetBootRestoreResult(result *BackupRestoreResult) {
bootRestoreMu.Lock()
defer bootRestoreMu.Unlock()
bootRestore = result
}
func bootRestoreResult() *BackupRestoreResult {
bootRestoreMu.Lock()
defer bootRestoreMu.Unlock()
return bootRestore
}
// GET /api/system/backup/status
func (s *Server) backupStatus(w http.ResponseWriter, r *http.Request) {
_, err := os.Stat(filepath.Join(s.m.dir, backupPendingDir))
writeJSON(w, 200, map[string]any{"pending": err == nil, "last_restore": bootRestoreResult()})
}
// GET|HEAD /api/system/backup/export streams the backup package. Errors after
// the first byte abort the connection so a partial file never looks complete.
func (s *Server) backupExport(w http.ResponseWriter, r *http.Request) {
if s.pg(w) == nil {
return
}
if !backupMu.TryLock() {
w.Header().Set("X-Artex-Error-Code", "backup_busy")
writeProductError(w, 409, "backup_busy", "已有备份或恢复正在进行", nil)
return
}
defer backupMu.Unlock()
active, err := s.m.pg.CountActiveTasks(r.Context())
if err != nil {
log.Printf("[backup] 检查运行中任务失败:%v", err)
writeProductError(w, 500, "data_unavailable", "检查运行中任务失败", nil)
return
}
if active > 0 {
w.Header().Set("X-Artex-Error-Code", "backup_active_tasks")
writeProductError(w, 409, "backup_active_tasks", "存在未暂停的运行中或排队中任务,请先暂停或等待任务完成后再下载备份", map[string]any{"count": active})
return
}
name := "artex-backup-" + time.Now().Format("20060102-150405") + ".tar.zst"
w.Header().Set("Content-Type", "application/zstd")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("Cache-Control", "no-store")
setFileDisposition(w, "attachment", name)
if r.Method == http.MethodHead {
return
}
started := time.Now()
if err := s.writeBackup(r.Context(), w); err != nil {
log.Printf("[backup] 导出失败:%v", err)
panic(http.ErrAbortHandler)
}
log.Printf("[backup] 已导出备份 %s(%s)", name, time.Since(started).Round(time.Millisecond))
}
func (s *Server) writeBackup(ctx context.Context, out io.Writer) error {
encoder, err := zstd.NewWriter(out, zstd.WithEncoderLevel(zstd.SpeedDefault), zstd.WithEncoderCRC(true))
if err != nil {
return err
}
flusher, _ := out.(http.Flusher)
tw := tar.NewWriter(encoder)
manifest := backupManifest{
Format: backupFormat, Version: BuildVersion, CreatedAt: time.Now().UTC(),
DataDir: s.m.dir, Separator: string(filepath.Separator), Entries: []string{}, Skills: []string{},
}
chunkMax := backupCopyChunkBytes
if chunkMax <= 0 {
chunkMax = 8 << 20
}
var copyBuf []byte
err = s.m.pg.DumpTables(ctx, func(table pgdb.BackupTable, copyTo func(io.Writer) (int64, error)) error {
cw := copyChunkWriter{
tw: tw,
encoder: encoder,
flusher: flusher,
table: table.Name,
modTime: manifest.CreatedAt,
buf: copyBuf[:0],
chunkMax: chunkMax,
}
rows, copyErr := copyTo(&cw)
if copyErr != nil {
return copyErr
}
parts, err := cw.finish()
if err != nil {
return err
}
copyBuf = cw.buf[:0]
table.Rows = rows
entry := backupTableEntry{BackupTable: table}
if parts > 1 {
entry.Parts = parts
}
manifest.Tables = append(manifest.Tables, entry)
return nil
})
if err != nil {
return err
}
snapshot := ""
if tr := s.m.Traffic(); tr != nil {
spool, err := os.MkdirTemp(s.m.dir, ".backup-")
if err != nil {
return err
}
defer os.RemoveAll(spool)
snapshot = filepath.Join(spool, "index.sqlite")
if err := tr.SnapshotIndex(snapshot); err != nil {
return fmt.Errorf("快照流量索引: %w", err)
}
if err := addBackupFile(tw, snapshot, "files/"+backupTrafficIndex+"/index.sqlite"); err != nil {
return err
}
if err := encoder.Flush(); err != nil {
return err
}
if flusher != nil {
flusher.Flush()
}
}
err = walkBackupTree(s.m.dir, func(relative string, info fs.FileInfo) (bool, error) {
if !strings.Contains(relative, "/") {
if strings.HasPrefix(relative, ".") {
return false, nil
}
manifest.Entries = append(manifest.Entries, relative)
}
if backupSkipped[relative] || (snapshot != "" && relative == backupTrafficIndex) {
return false, nil
}
return true, addBackupEntry(tw, filepath.Join(s.m.dir, filepath.FromSlash(relative)), "files/"+relative, info)
})
if err != nil {
return err
}
if s.skillDir != "" {
err = walkBackupTree(s.skillDir, func(relative string, info fs.FileInfo) (bool, error) {
if strings.HasPrefix(relative, ".") {
return false, nil
}
if !strings.Contains(relative, "/") {
if !info.IsDir() {
return false, nil
}
manifest.Skills = append(manifest.Skills, relative)
}
return true, addBackupEntry(tw, filepath.Join(s.skillDir, filepath.FromSlash(relative)), "skills/"+relative, info)
})
if err != nil && !errors.Is(err, fs.ErrNotExist) {
return err
}
}
raw, err := json.MarshalIndent(manifest, "", " ")
if err != nil {
return err
}
if err := tw.WriteHeader(&tar.Header{Name: backupManifestName, Mode: archiveFileMode, Size: int64(len(raw)), ModTime: manifest.CreatedAt, Typeflag: tar.TypeReg}); err != nil {
return err
}
if _, err := tw.Write(raw); err != nil {
return err
}
if err := tw.Close(); err != nil {
return err
}
return encoder.Close()
}
func backupTableCopyPath(table string, part int) string {
if part == 0 {
return "db/" + table + ".copy"
}
return fmt.Sprintf("db/%s.copy.%06d", table, part)
}
func backupTablesOnly(entries []backupTableEntry) []pgdb.BackupTable {
tables := make([]pgdb.BackupTable, len(entries))
for i, entry := range entries {
tables[i] = entry.BackupTable
}
return tables
}
type copyChunkWriter struct {
tw *tar.Writer
encoder *zstd.Encoder
flusher http.Flusher
table string
modTime time.Time
buf []byte
chunkMax int
parts int
}
func (w *copyChunkWriter) Write(p []byte) (int, error) {
total := len(p)
for len(p) > 0 {
space := w.chunkMax - len(w.buf)
n := min(space, len(p))
w.buf = append(w.buf, p[:n]...)
p = p[n:]
if len(w.buf) == w.chunkMax {
if err := w.flushChunk(); err != nil {
return total - len(p), err
}
}
}
return total, nil
}
func (w *copyChunkWriter) finish() (int, error) {
if len(w.buf) > 0 || w.parts == 0 {
if err := w.flushChunk(); err != nil {
return w.parts, err
}
}
return w.parts, nil
}
func (w *copyChunkWriter) flushChunk() error {
header := &tar.Header{
Name: backupTableCopyPath(w.table, w.parts),
Mode: archiveFileMode,
Size: int64(len(w.buf)),
ModTime: w.modTime,
Typeflag: tar.TypeReg,
}
if err := w.tw.WriteHeader(header); err != nil {
return err
}
if len(w.buf) > 0 {
if _, err := w.tw.Write(w.buf); err != nil {
return err
}
}
w.buf = w.buf[:0]
w.parts++
if err := w.encoder.Flush(); err != nil {
return err
}
if w.flusher != nil {
w.flusher.Flush()
}
return nil
}
// walkBackupTree visits root's descendants in lexical order with slash-form
// relative paths. visit returns false to skip an entry (and its subtree).
// Symlinks are skipped: the package format only carries files and directories.
func walkBackupTree(root string, visit func(relative string, info fs.FileInfo) (bool, error)) error {
return filepath.WalkDir(root, func(current string, entry fs.DirEntry, walkErr error) error {
if walkErr != nil {
if current != root && errors.Is(walkErr, fs.ErrNotExist) {
return nil // removed while walking (an agent cleaned up)
}
return walkErr
}
relative, err := filepath.Rel(root, current)
if err != nil || relative == "." {
return err
}
if entry.Type()&fs.ModeSymlink != 0 {
log.Printf("[backup] 跳过符号链接:%s", current)
return nil
}
info, err := entry.Info()
if errors.Is(err, fs.ErrNotExist) {
return nil
}
if err != nil {
return err
}
if !info.IsDir() && !info.Mode().IsRegular() {
return nil
}
keep, err := visit(filepath.ToSlash(relative), info)
if err != nil {
return err
}
if !keep && info.IsDir() {
return filepath.SkipDir
}
return nil
})
}
func addBackupFile(tw *tar.Writer, path, name string) error {
info, err := os.Stat(path)
if err != nil {
return err
}
return addBackupEntry(tw, path, name, info)
}
func addBackupEntry(tw *tar.Writer, path, name string, info fs.FileInfo) error {
header, err := tar.FileInfoHeader(info, "")
if err != nil {
return err
}
header.Name = name
header.Uname, header.Gname = "", ""
if info.IsDir() {
header.Name += "/"
return tw.WriteHeader(header)
}
input, err := os.Open(path)
if errors.Is(err, fs.ErrNotExist) {
return nil // removed between listing and opening
}
if err != nil {
return err
}
defer input.Close()
if err := tw.WriteHeader(header); err != nil {
return err
}
// Exactly the stat'ed size: a file still being appended to is cut at that
// point instead of overflowing its tar entry.
if _, err := io.CopyN(tw, input, header.Size); err != nil {
return fmt.Errorf("读取 %s: %w", path, err)
}
return nil
}
// POST /api/system/backup/restore — body is the raw .tar.zst package.
func (s *Server) backupRestore(w http.ResponseWriter, r *http.Request) {
if s.pg(w) == nil {
return
}
if _, running := updHub.snapshot(); running {
writeProductError(w, 409, "backup_update_running", "更新正在进行中,无法恢复备份", nil)
return
}
if !backupMu.TryLock() {
writeProductError(w, 409, "backup_busy", "已有备份或恢复正在进行", nil)
return
}
defer backupMu.Unlock()
manifest, restoreID, err := s.stageBackupUpload(r.Context(), r.Body)
if err != nil {
log.Printf("[backup] 恢复包校验失败:%v", err)
writeProductError(w, 400, "backup_invalid", "备份包无效:"+err.Error(), map[string]any{"message": err.Error()})
return
}
log.Printf("[backup] 已接收备份(版本 %s,创建于 %s),即将重启以完成恢复", manifest.Version, manifest.CreatedAt.Format(time.RFC3339))
writeJSON(w, 202, map[string]any{"ok": true, "restore_id": restoreID, "version": manifest.Version, "created_at": manifest.CreatedAt})
go func() {
time.Sleep(500 * time.Millisecond)
requestRestart()
}()
}
func newBackupRestoreID() string {
var raw [16]byte
if _, err := rand.Read(raw[:]); err == nil {
return hex.EncodeToString(raw[:])
}
return fmt.Sprintf("%d", time.Now().UnixNano())
}
func (s *Server) stageBackupUpload(ctx context.Context, body io.Reader) (*backupManifest, string, error) {
upload, err := os.MkdirTemp(s.m.dir, backupUploadPrefix)
if err != nil {
return nil, "", err
}
staged := false
defer func() {
if !staged {
_ = os.RemoveAll(upload)
}
}()
if err := extractTarZst(body, upload, backupMaxFiles); err != nil {
return nil, "", fmt.Errorf("解包失败: %w", err)
}
manifest, err := readBackupManifest(upload)
if err != nil {
return nil, "", err
}
if err := s.m.pg.CheckRestoreTables(ctx, backupTablesOnly(manifest.Tables)); err != nil {
return nil, "", err
}
restoreID := newBackupRestoreID()
if err := os.WriteFile(filepath.Join(upload, backupRestoreIDFile), []byte(restoreID), archiveFileMode); err != nil {
return nil, "", err
}
pending := filepath.Join(s.m.dir, backupPendingDir)
oldPending := upload + "-old"
hadPending := false
if _, err := os.Lstat(pending); err == nil {
if err := os.Rename(pending, oldPending); err != nil {
return nil, "", err
}
hadPending = true
} else if !errors.Is(err, fs.ErrNotExist) {
return nil, "", err
}
if err := os.Rename(upload, pending); err != nil {
if hadPending {
_ = os.Rename(oldPending, pending)
}
return nil, "", err
}
staged = true
if hadPending {
_ = os.RemoveAll(oldPending)
}
return manifest, restoreID, nil
}
// readBackupManifest loads and validates the manifest of an extracted package:
// every name it lists must be a single local path element that actually exists,
// so a crafted manifest cannot point the restore outside the package.
func readBackupManifest(root string) (*backupManifest, error) {
raw, err := os.ReadFile(filepath.Join(root, backupManifestName))
if errors.Is(err, fs.ErrNotExist) {
return nil, errors.New("缺少 manifest.json(不是 ARTEX 备份包,或文件不完整)")
}
if err != nil {
return nil, err
}
var manifest backupManifest
if err := json.Unmarshal(raw, &manifest); err != nil {
return nil, fmt.Errorf("manifest.json 格式错误: %w", err)
}
if manifest.Format < 1 || manifest.Format > backupFormat {
return nil, fmt.Errorf("不支持的备份格式版本 %d(备份可能来自更新的 ARTEX 版本)", manifest.Format)
}
if len(manifest.Tables) == 0 {
return nil, errors.New("备份中没有数据库表")
}
for _, table := range manifest.Tables {
if !singleElement(table.Name) || len(table.Columns) == 0 {
return nil, fmt.Errorf("备份表名无效: %q", table.Name)
}
parts := max(table.Parts, 1)
if table.Parts < 0 || parts > backupMaxFiles {
return nil, fmt.Errorf("备份表 %s 分片数无效: %d", table.Name, table.Parts)
}
for part := range parts {
if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(backupTableCopyPath(table.Name, part)))); err != nil {
return nil, fmt.Errorf("缺少表 %s 的数据", table.Name)
}
}
}
for _, name := range manifest.Entries {
if !singleElement(name) || strings.HasPrefix(name, ".") {
return nil, fmt.Errorf("备份条目名无效: %q", name)
}
}
for _, name := range manifest.Skills {
if !singleElement(name) || strings.HasPrefix(name, ".") {
return nil, fmt.Errorf("备份 skill 名无效: %q", name)
}
}
return &manifest, nil
}
func singleElement(name string) bool {
return name != "" && filepath.IsLocal(name) && !strings.ContainsAny(name, `/\`)
}
// ApplyPendingRestore installs a backup staged by the restore endpoint. main
// calls it before anything opens the data directory or the database. It returns
// nil when nothing was pending.
//
// Steps are resumable: the database transaction is marked done inside the
// pending directory, and each top-level entry is moved aside and replaced one
// rename at a time, so a crash at any point is finished by the next boot. A
// database failure leaves current data untouched and parks the package in
// .restore-failed for inspection.
func ApplyPendingRestore(dataDir, skillDir string) (*BackupRestoreResult, error) {
if abs, err := filepath.Abs(dataDir); err == nil {
dataDir = abs
}
pending := filepath.Join(dataDir, backupPendingDir)
previous := filepath.Join(dataDir, backupPreviousDir)
if _, err := os.Stat(pending); err != nil {
if errors.Is(err, fs.ErrNotExist) {
_ = os.RemoveAll(previous) // leftover of a restore that crashed during cleanup
}
cleanBackupUploads(dataDir)
return nil, nil
}
cleanBackupUploads(dataDir)
result := &BackupRestoreResult{At: time.Now()}
if rawID, err := os.ReadFile(filepath.Join(pending, backupRestoreIDFile)); err == nil {
result.ID = strings.TrimSpace(string(rawID))
}
manifest, err := readBackupManifest(pending)
if err == nil {
result.Source, result.Created = manifest.Version, manifest.CreatedAt
log.Printf("[backup] 开始恢复备份(版本 %s,创建于 %s)", manifest.Version, manifest.CreatedAt.Format(time.RFC3339))
err = restoreBackupDatabase(pending, dataDir, manifest)
}
if err != nil {
result.Error = err.Error()
log.Printf("[backup] 恢复失败,当前数据保持不变:%v", err)
failed := filepath.Join(dataDir, backupFailedDir)
_ = os.RemoveAll(failed)
if renameErr := os.Rename(pending, failed); renameErr != nil {
log.Printf("[backup] 无法移走失败的恢复包,删除之:%v", renameErr)
_ = os.RemoveAll(pending)
}
return result, nil
}
if err := installBackupFiles(pending, dataDir, skillDir, manifest); err != nil {
// The database is already replaced; do not start the engine on half-installed
// files. Returning an error makes main exit non-zero so the supervisor retries.
result.Error = "数据库已恢复,但文件替换失败(下次启动会继续):" + err.Error()
log.Printf("[backup] %s", result.Error)
return result, err
}
if err := os.RemoveAll(previous); err != nil {
log.Printf("[backup] 清理旧数据失败:%v", err)
}
if err := os.RemoveAll(pending); err != nil {
result.Error = "恢复已完成,但清理暂存目录失败:" + err.Error()
log.Printf("[backup] %s", result.Error)
return result, err
}
result.Applied = true
log.Printf("[backup] 备份恢复完成")
return result, nil
}
func cleanBackupUploads(dataDir string) {
entries, _ := os.ReadDir(dataDir)
for _, entry := range entries {
if strings.HasPrefix(entry.Name(), backupUploadPrefix) || strings.HasPrefix(entry.Name(), ".backup-") {
_ = os.RemoveAll(filepath.Join(dataDir, entry.Name()))
}
}
}
func restoreBackupDatabase(pending, dataDir string, manifest *backupManifest) error {
marker := filepath.Join(pending, backupDBDoneMarker)
if _, err := os.Stat(marker); err == nil {
return nil
}
dsn, _, err := pgdb.DSN()
if err != nil {
return err
}
pg, err := pgdb.Open(dsn)
if err != nil {
return err
}
defer pg.Close()
// Created outside schema.sql; a fresh target database does not have them yet.
if err := pg.EnsureLLMRecordsTable(); err != nil {
return err
}
if err := pg.EnsureLLMUsageTable(); err != nil {
return err
}
tables := make([]pgdb.RestoreTable, len(manifest.Tables))
for i, table := range manifest.Tables {
name, parts := table.Name, max(table.Parts, 1)
tables[i] = pgdb.RestoreTable{
BackupTable: table.BackupTable,
Open: func() (io.ReadCloser, error) { return openBackupTableParts(pending, name, parts) },
}
}
move := pgdb.PathPrefixMove{From: manifest.DataDir, FromSeparator: manifest.Separator, To: dataDir, ToSeparator: string(filepath.Separator)}
if err := pg.RestoreTables(context.Background(), tables, move); err != nil {
return err
}
// A machine-specific interpreter path from the old host would break custom
// tools; dropping it lets startup re-detect the local one.
if value, ok, _ := pg.GetSetting(settingPythonInterp); ok && strings.TrimSpace(value) != "" {
if _, err := os.Stat(strings.TrimSpace(value)); err != nil {
if _, err := pg.Exec(`DELETE FROM settings WHERE key=$1`, settingPythonInterp); err != nil {
log.Printf("[backup] 清除失效的 python 解释器配置失败:%v", err)
}
}
}
return writeArchiveJournal(marker, map[string]any{"at": time.Now()})
}
func openBackupTableParts(pending, table string, parts int) (io.ReadCloser, error) {
if parts <= 1 {
return os.Open(filepath.Join(pending, filepath.FromSlash(backupTableCopyPath(table, 0))))
}
paths := make([]string, parts)
for i := range parts {
paths[i] = filepath.Join(pending, filepath.FromSlash(backupTableCopyPath(table, i)))
}
return &multiFileReader{paths: paths}, nil
}
type multiFileReader struct {
paths []string
index int
current *os.File
}
func (r *multiFileReader) Read(p []byte) (int, error) {
for {
if r.current == nil {
if r.index >= len(r.paths) {
return 0, io.EOF
}
f, err := os.Open(r.paths[r.index])
if err != nil {
return 0, err
}
r.current = f
r.index++
}
n, err := r.current.Read(p)
if n > 0 || (err != nil && !errors.Is(err, io.EOF)) {
if errors.Is(err, io.EOF) {
_ = r.current.Close()
r.current = nil
return n, nil
}
return n, err
}
if closeErr := r.current.Close(); closeErr != nil {
r.current = nil
return 0, closeErr
}
r.current = nil
}
}
func (r *multiFileReader) Close() error {
if r.current != nil {
err := r.current.Close()
r.current = nil
return err
}
return nil
}
func installBackupFiles(pending, dataDir, skillDir string, manifest *backupManifest) error {
previous := filepath.Join(dataDir, backupPreviousDir)
if err := os.MkdirAll(previous, archiveDirMode); err != nil {
return err
}
keep := make(map[string]bool, len(manifest.Entries))
for _, name := range manifest.Entries {
keep[name] = true
}
entries, err := os.ReadDir(dataDir)
if err != nil {
return err
}
for _, entry := range entries {
name := entry.Name()
if strings.HasPrefix(name, ".") || keep[name] {
continue
}
if err := moveAside(filepath.Join(dataDir, name), filepath.Join(previous, name)); err != nil {
return err
}
}
for _, name := range manifest.Entries {
source := filepath.Join(pending, "files", name)
if _, err := os.Lstat(source); errors.Is(err, fs.ErrNotExist) {
continue // already installed by an interrupted earlier boot
} else if err != nil {
return err
}
destination := filepath.Join(dataDir, name)
if _, err := os.Lstat(destination); err == nil {
if err := moveAside(destination, filepath.Join(previous, name)); err != nil {
return err
}
}
if err := os.Rename(source, destination); err != nil {
return err
}
}
if skillDir == "" {
return nil
}
if err := os.MkdirAll(skillDir, 0o755); err != nil {
return err
}
// Skills already present here are kept: built-in skills ship with this
// build and must not be downgraded by an older backup's copy.
for _, name := range manifest.Skills {
source := filepath.Join(pending, "skills", name)
destination := filepath.Join(skillDir, name)
if _, err := os.Lstat(source); err != nil {
continue
}
if _, err := os.Lstat(destination); err == nil {
continue
}
if err := os.Rename(source, destination); err != nil {
if err := copyBackupTree(source, destination); err != nil {
return fmt.Errorf("安装 skill %s: %w", name, err)
}
}
}
return nil
}
func moveAside(source, destination string) error {
if _, err := os.Lstat(destination); err == nil {
if err := os.RemoveAll(destination); err != nil {
return err
}
}
return os.Rename(source, destination)
}
// copyBackupTree is the fallback when the skill directory sits on another
// filesystem than the data directory (a Docker bind mount), where rename fails.
func copyBackupTree(source, destination string) error {
temporary := destination + ".restore-tmp"
_ = os.RemoveAll(temporary)
err := filepath.WalkDir(source, func(current string, entry fs.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
relative, err := filepath.Rel(source, current)
if err != nil {
return err
}
target := filepath.Join(temporary, relative)
if entry.IsDir() {
return os.MkdirAll(target, 0o755)
}
info, err := entry.Info()
if err != nil {
return err
}
input, err := os.Open(current)
if err != nil {
return err
}
defer input.Close()
output, err := os.OpenFile(target, os.O_CREATE|os.O_EXCL|os.O_WRONLY, info.Mode().Perm())
if err != nil {
return err
}
_, copyErr := io.Copy(output, input)
return errors.Join(copyErr, output.Close())
})
if err != nil {
_ = os.RemoveAll(temporary)
return err
}
return os.Rename(temporary, destination)
}