mirror of
https://github.com/RuoJi6/ARTEX.git
synced 2026-11-21 09:01:50 +08:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4d2c327df7 | ||
|
|
c6f7c29b71 |
No files matched your search
@@ -4,6 +4,10 @@
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### 新增与改进
|
||||
|
||||
- 新增一键备份与迁移(#160):在系统配置中下载包含数据库、任务工作区、会话、流量、证据、归档包、MITM 证书和 skills 的单个备份文件,并可在另一实例上传恢复。恢复先校验备份,再在重启时整体替换;数据库替换失败时保留原数据,中断后下次启动继续完成文件替换。
|
||||
|
||||
## [0.3.30] - 2026-11-14
|
||||
|
||||
### 新增与改进
|
||||
|
||||
@@ -189,6 +189,18 @@ ARTEX_TARGETS=linux/amd64,windows/amd64 ./build.sh --release
|
||||
|
||||
---
|
||||
|
||||
## 一键备份与迁移
|
||||
|
||||
在 **系统配置 → 系统与账号** 的 **备份与迁移** 卡片中:
|
||||
|
||||
- **下载备份**:生成单个 `artex-backup-<时间>.tar.zst`,浏览器直接落盘。导出前需先暂停或等待所有运行中/排队中的任务完成,避免导出期间文件写入导致不一致。内容包括 PostgreSQL 全部业务表(同一快照事务内分片流式导出,表间一致)、数据目录(任务工作区、会话、证据、任务归档包、MITM CA 证书、流量及其 SQLite 索引快照)和 skills 目录。不含系统运行日志(`server_logs`)和 `jwt.key`。
|
||||
- **从备份恢复**:在新机器上先正常安装并启动 ARTEX,登录后上传备份文件。服务端先完整解包并按当前数据库结构校验,通过后重启;重启时、在任何组件打开数据之前替换数据:数据库在一个事务内整体替换(失败则原数据不变,恢复包移到 `data/.restore-failed` 供排查),数据目录逐项替换;若文件替换失败,进程会非零退出由守护脚本重试,直到全部替换完成才启动业务引擎。卡片会显示上次恢复的结果。
|
||||
- 恢复会**覆盖当前实例的全部数据**并重启停止当前运行中的任务;备份中未结束的任务在恢复后会保持暂停,需手动恢复,不会在新机器上自动继续向目标发起请求。登录密码、Basic Auth、LLM 与其他配置都随数据库迁移,恢复后用原实例的密码登录。
|
||||
- 新机器上已存在的同名 skill 保留本机版本(避免旧备份覆盖新版内置 skill),其余 skill 从备份装入。
|
||||
- 只能恢复到**相同或更新版本**的 ARTEX;备份含当前版本不认识的表或列时会拒绝恢复。旧路径(如任务归档包的绝对路径)会自动改写到新数据目录。
|
||||
- 恢复依赖 `start.sh` / `start.bat`(Docker 下为镜像 ENTRYPOINT)重启程序,与页面一键更新相同。
|
||||
- 恢复期间需在数据目录所在磁盘额外预留约一份**未压缩备份包**大小的临时空间(解包后的数据库文本与文件);若前面有 Nginx 反向代理,请按下方反代示例为 `/api/system/backup/` 放宽 `client_max_body_size` 并关闭 `proxy_request_buffering`。
|
||||
|
||||
## 更新升级
|
||||
|
||||
> 升级只换程序、不动数据:Postgres 数据卷 `pgdata`、`./data`(jwt.key / SQLite 等)、`./skills` 都会保留。**数据库迁移无需手动执行**——`artex` 每次启动会幂等重跑 `schema.sql`(含 `ADD COLUMN` / `CREATE INDEX IF NOT EXISTS`),即“重启即迁移”。升级前仍建议先备份 `./data` 与数据库。
|
||||
@@ -453,6 +465,22 @@ server {
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Connection "";
|
||||
}
|
||||
|
||||
# 一键备份 / 恢复:允许大体积备份流式上传与下载,避免触发默认 1m 限制与请求体缓冲
|
||||
location /api/system/backup/ {
|
||||
proxy_pass http://127.0.0.1:8787;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
|
||||
client_max_body_size 0;
|
||||
proxy_request_buffering off;
|
||||
proxy_buffering off;
|
||||
proxy_cache off;
|
||||
proxy_read_timeout 3600s;
|
||||
proxy_send_timeout 3600s;
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Connection "";
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
+12
-4
@@ -90,6 +90,18 @@ func run() int {
|
||||
log.Printf("[config] 配置文件: %s (不存在 — 将仅尝试环境变量 ARTEX_PG_DSN)", cfgPath)
|
||||
}
|
||||
|
||||
// 页面「恢复备份」暂存的数据必须在任何组件打开数据目录与数据库之前装好。
|
||||
skillDir := config.SkillDir()
|
||||
if abs, err := filepath.Abs(skillDir); err == nil {
|
||||
skillDir = abs
|
||||
}
|
||||
restoreResult, err := server.ApplyPendingRestore(*dataDir, skillDir)
|
||||
if err != nil {
|
||||
log.Printf("[backup] 恢复文件替换未完成,终止本次启动等待重试:%v", err)
|
||||
return 1
|
||||
}
|
||||
server.SetBootRestoreResult(restoreResult)
|
||||
|
||||
sigCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
ctx, shutdown := shutdownContext(sigCtx)
|
||||
@@ -107,10 +119,6 @@ func run() int {
|
||||
settle := time.AfterFunc(selfupdate.SettleDelay, selfupdate.Settle)
|
||||
defer settle.Stop()
|
||||
|
||||
skillDir := config.SkillDir()
|
||||
if abs, err := filepath.Abs(skillDir); err == nil {
|
||||
skillDir = abs
|
||||
}
|
||||
log.Printf("[config] skill 目录: %s", skillDir)
|
||||
srv := server.New(ctx, mgr, skillDir, *dataDir, config.BaseDir())
|
||||
defer srv.Close()
|
||||
|
||||
+362
@@ -0,0 +1,362 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/stdlib"
|
||||
)
|
||||
|
||||
// BackupTable describes one table's columns, in the order its COPY data uses,
|
||||
// and how many rows the data holds.
|
||||
type BackupTable struct {
|
||||
Name string `json:"name"`
|
||||
Columns []string `json:"columns"`
|
||||
Rows int64 `json:"rows"`
|
||||
}
|
||||
|
||||
// RestoreTable is one table's COPY text-format data to load during a restore.
|
||||
type RestoreTable struct {
|
||||
BackupTable
|
||||
Open func() (io.ReadCloser, error)
|
||||
}
|
||||
|
||||
// PathPrefixMove rewrites absolute paths recorded under an old data directory
|
||||
// (task_archives.archive_path) so they point at the restoring instance's one.
|
||||
// Separators are carried separately so a Windows backup lands on Linux intact.
|
||||
type PathPrefixMove struct{ From, FromSeparator, To, ToSeparator string }
|
||||
|
||||
// backupSkippedTables are neither exported nor replaced: server_logs is this
|
||||
// process's own runtime log ring, not data worth migrating.
|
||||
var backupSkippedTables = map[string]bool{"server_logs": true}
|
||||
|
||||
// tableColumnsSQL lists every ordinary table of the application schema with its
|
||||
// writable columns. Generated columns cannot be COPY'd in, so they are left out.
|
||||
const tableColumnsSQL = `
|
||||
SELECT c.relname::text, array_agg(a.attname::text ORDER BY a.attnum)
|
||||
FROM pg_class c
|
||||
JOIN pg_namespace n ON n.oid = c.relnamespace
|
||||
JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped AND a.attgenerated = ''
|
||||
WHERE n.nspname = current_schema() AND c.relkind = 'r'
|
||||
GROUP BY c.relname
|
||||
ORDER BY c.relname`
|
||||
|
||||
func ident(name string) string { return pgx.Identifier{name}.Sanitize() }
|
||||
|
||||
func columnList(columns []string) string {
|
||||
quoted := make([]string, len(columns))
|
||||
for i, column := range columns {
|
||||
quoted[i] = ident(column)
|
||||
}
|
||||
return strings.Join(quoted, ", ")
|
||||
}
|
||||
|
||||
// withPgx runs fn on one pooled connection's native pgx handle; COPY is only
|
||||
// reachable through it.
|
||||
func (d *DB) withPgx(ctx context.Context, fn func(*pgx.Conn) error) error {
|
||||
conn, err := d.Conn(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer conn.Close()
|
||||
return conn.Raw(func(driverConn any) error {
|
||||
native, ok := driverConn.(*stdlib.Conn)
|
||||
if !ok {
|
||||
return fmt.Errorf("unexpected driver connection %T", driverConn)
|
||||
}
|
||||
return fn(native.Conn())
|
||||
})
|
||||
}
|
||||
|
||||
func queryTables(ctx context.Context, tx pgx.Tx) ([]BackupTable, error) {
|
||||
rows, err := tx.Query(ctx, tableColumnsSQL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var tables []BackupTable
|
||||
for rows.Next() {
|
||||
var table BackupTable
|
||||
if err := rows.Scan(&table.Name, &table.Columns); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !backupSkippedTables[table.Name] {
|
||||
tables = append(tables, table)
|
||||
}
|
||||
}
|
||||
return tables, rows.Err()
|
||||
}
|
||||
|
||||
// CountActiveTasks returns how many non-deleted, non-terminal tasks are not
|
||||
// paused (running, created/unpaused, or queued). Exporting while any exist
|
||||
// would race with live disk writes and put active tasks into the backup.
|
||||
func (d *DB) CountActiveTasks(ctx context.Context) (int, error) {
|
||||
var count int
|
||||
err := d.QueryRowContext(ctx, `
|
||||
SELECT COUNT(*)
|
||||
FROM tasks
|
||||
WHERE deleted_at IS NULL
|
||||
AND paused = false
|
||||
AND status NOT IN ('done', 'failed', 'timeout')`).Scan(&count)
|
||||
return count, err
|
||||
}
|
||||
|
||||
// DumpTables exports every application table from a single read-only
|
||||
// REPEATABLE READ snapshot, so rows written while the dump runs never produce a
|
||||
// backup whose tables disagree with each other. emit is called once per table
|
||||
// with a function that writes the table's COPY text data and returns its row
|
||||
// count; emit records the count itself.
|
||||
func (d *DB) DumpTables(ctx context.Context, emit func(BackupTable, func(io.Writer) (int64, error)) error) error {
|
||||
return d.withPgx(ctx, func(conn *pgx.Conn) error {
|
||||
tx, err := conn.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback(ctx) //nolint:errcheck // read-only; nothing to keep
|
||||
tables, err := queryTables(ctx, tx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, table := range tables {
|
||||
statement := fmt.Sprintf("COPY %s (%s) TO STDOUT", ident(table.Name), columnList(table.Columns))
|
||||
copyTo := func(w io.Writer) (int64, error) {
|
||||
tag, err := tx.Conn().PgConn().CopyTo(ctx, w, statement)
|
||||
return tag.RowsAffected(), err
|
||||
}
|
||||
if err := emit(table, copyTo); err != nil {
|
||||
return fmt.Errorf("备份表 %s: %w", table.Name, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// CheckRestoreTables reports whether every table and column of a backup exists
|
||||
// in the current schema. A backup taken by a newer ARTEX may carry columns this
|
||||
// build does not know; loading it would fail halfway, so it is refused upfront.
|
||||
func (d *DB) CheckRestoreTables(ctx context.Context, tables []BackupTable) error {
|
||||
return d.withPgx(ctx, func(conn *pgx.Conn) error {
|
||||
tx, err := conn.BeginTx(ctx, pgx.TxOptions{AccessMode: pgx.ReadOnly})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback(ctx) //nolint:errcheck // read-only
|
||||
current, err := queryTables(ctx, tx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return checkRestoreTables(current, tables)
|
||||
})
|
||||
}
|
||||
|
||||
func checkRestoreTables(current, tables []BackupTable) error {
|
||||
known := make(map[string]map[string]bool, len(current))
|
||||
for _, table := range current {
|
||||
columns := make(map[string]bool, len(table.Columns))
|
||||
for _, column := range table.Columns {
|
||||
columns[column] = true
|
||||
}
|
||||
known[table.Name] = columns
|
||||
}
|
||||
seen := make(map[string]bool, len(tables))
|
||||
for _, table := range tables {
|
||||
if seen[table.Name] {
|
||||
return fmt.Errorf("备份中表 %s 重复", table.Name)
|
||||
}
|
||||
seen[table.Name] = true
|
||||
columns, ok := known[table.Name]
|
||||
if !ok {
|
||||
return fmt.Errorf("备份包含当前版本不存在的表 %s(备份可能来自更新的 ARTEX 版本)", table.Name)
|
||||
}
|
||||
for _, column := range table.Columns {
|
||||
if !columns[column] {
|
||||
return fmt.Errorf("备份表 %s 含当前版本不存在的列 %s(备份可能来自更新的 ARTEX 版本)", table.Name, column)
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type foreignKey struct{ table, name, definition string }
|
||||
|
||||
// RestoreTables replaces the contents of every application table with the given
|
||||
// data in one transaction: either the whole backup lands or nothing changes.
|
||||
// Tables of the current schema that the backup does not carry end up empty;
|
||||
// columns it does not carry take their defaults.
|
||||
//
|
||||
// Foreign keys are dropped for the load and re-added afterwards (which
|
||||
// re-validates them), and user triggers are disabled so derived rows such as
|
||||
// task_asset_links come from the backup instead of being regenerated on insert.
|
||||
// Both only need table ownership, unlike session_replication_role, which needs
|
||||
// superuser. Serial sequences are moved past the restored ids.
|
||||
func (d *DB) RestoreTables(ctx context.Context, tables []RestoreTable, move PathPrefixMove) error {
|
||||
return d.withPgx(ctx, func(conn *pgx.Conn) error {
|
||||
tx, err := conn.Begin(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback(ctx) //nolint:errcheck // no-op once committed
|
||||
if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock($1)`, schemaMigrationLockKey); err != nil {
|
||||
return fmt.Errorf("coordinate with schema migration: %w", err)
|
||||
}
|
||||
current, err := queryTables(ctx, tx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
backup := make([]BackupTable, len(tables))
|
||||
for i, table := range tables {
|
||||
backup[i] = table.BackupTable
|
||||
}
|
||||
if err := checkRestoreTables(current, backup); err != nil {
|
||||
return err
|
||||
}
|
||||
names := make([]string, len(current))
|
||||
for i, table := range current {
|
||||
names[i] = ident(table.Name)
|
||||
}
|
||||
|
||||
keys, err := listForeignKeys(ctx, tx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, key := range keys {
|
||||
if _, err := tx.Exec(ctx, fmt.Sprintf("ALTER TABLE %s DROP CONSTRAINT %s", key.table, ident(key.name))); err != nil {
|
||||
return fmt.Errorf("暂时移除外键 %s: %w", key.name, err)
|
||||
}
|
||||
}
|
||||
for _, name := range names {
|
||||
if _, err := tx.Exec(ctx, "ALTER TABLE "+name+" DISABLE TRIGGER USER"); err != nil {
|
||||
return fmt.Errorf("暂停触发器 %s: %w", name, err)
|
||||
}
|
||||
}
|
||||
if len(names) > 0 {
|
||||
if _, err := tx.Exec(ctx, "TRUNCATE "+strings.Join(names, ", ")); err != nil {
|
||||
return fmt.Errorf("清空当前数据: %w", err)
|
||||
}
|
||||
}
|
||||
for _, table := range tables {
|
||||
if err := copyIn(ctx, tx, table); err != nil {
|
||||
return fmt.Errorf("恢复表 %s: %w", table.Name, err)
|
||||
}
|
||||
}
|
||||
if move.From != "" && (move.From != move.To || move.FromSeparator != move.ToSeparator) {
|
||||
// Runs while triggers are still off so updated_at keeps the backup's value.
|
||||
from := strings.TrimSuffix(move.From, move.FromSeparator) + move.FromSeparator
|
||||
to := strings.TrimSuffix(move.To, move.ToSeparator) + move.ToSeparator
|
||||
if _, err := tx.Exec(ctx, `
|
||||
UPDATE task_archives SET archive_path = $2 || replace(substr(archive_path, length($1) + 1), $3, $4)
|
||||
WHERE left(archive_path, length($1)) = $1`, from, to, move.FromSeparator, move.ToSeparator); err != nil {
|
||||
return fmt.Errorf("改写归档包路径: %w", err)
|
||||
}
|
||||
}
|
||||
// Any non-terminal task that was not paused when backed up (for example,
|
||||
// from an older backup) is forced into a manual pause so restoring onto a
|
||||
// new host never resumes scanning targets on its own.
|
||||
if _, err := tx.Exec(ctx, `
|
||||
UPDATE tasks
|
||||
SET paused = true,
|
||||
pause_reason = CASE WHEN COALESCE(pause_reason, '') = '' THEN 'paused_by_user' ELSE pause_reason END,
|
||||
queued = false,
|
||||
queued_at = NULL,
|
||||
schedule_paused = false,
|
||||
schedule_manual_until = NULL,
|
||||
active_run_seconds = active_run_seconds + CASE WHEN run_segment_started_at IS NOT NULL THEN GREATEST(0, FLOOR(EXTRACT(EPOCH FROM (now() - run_segment_started_at)))::bigint) ELSE 0 END,
|
||||
run_segment_started_at = NULL
|
||||
WHERE deleted_at IS NULL
|
||||
AND paused = false
|
||||
AND status NOT IN ('done', 'failed', 'timeout')`); err != nil {
|
||||
return fmt.Errorf("暂停恢复后的未完成任务: %w", err)
|
||||
}
|
||||
for _, key := range keys {
|
||||
if _, err := tx.Exec(ctx, fmt.Sprintf("ALTER TABLE %s ADD CONSTRAINT %s %s", key.table, ident(key.name), key.definition)); err != nil {
|
||||
return fmt.Errorf("恢复外键 %s: %w", key.name, err)
|
||||
}
|
||||
}
|
||||
for _, name := range names {
|
||||
if _, err := tx.Exec(ctx, "ALTER TABLE "+name+" ENABLE TRIGGER USER"); err != nil {
|
||||
return fmt.Errorf("恢复触发器 %s: %w", name, err)
|
||||
}
|
||||
}
|
||||
if err := resetSequences(ctx, tx); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Commit(ctx)
|
||||
})
|
||||
}
|
||||
|
||||
func listForeignKeys(ctx context.Context, tx pgx.Tx) ([]foreignKey, error) {
|
||||
rows, err := tx.Query(ctx, `
|
||||
SELECT conrelid::regclass::text, conname::text, pg_get_constraintdef(oid)
|
||||
FROM pg_constraint
|
||||
WHERE contype = 'f' AND connamespace = current_schema()::regnamespace
|
||||
ORDER BY 1, 2`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var keys []foreignKey
|
||||
for rows.Next() {
|
||||
var key foreignKey
|
||||
if err := rows.Scan(&key.table, &key.name, &key.definition); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
keys = append(keys, key)
|
||||
}
|
||||
return keys, rows.Err()
|
||||
}
|
||||
|
||||
func copyIn(ctx context.Context, tx pgx.Tx, table RestoreTable) error {
|
||||
data, err := table.Open()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer data.Close()
|
||||
statement := fmt.Sprintf("COPY %s (%s) FROM STDIN", ident(table.Name), columnList(table.Columns))
|
||||
tag, err := tx.Conn().PgConn().CopyFrom(ctx, data, statement)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if tag.RowsAffected() != table.Rows {
|
||||
return fmt.Errorf("写入 %d 行,备份清单记录 %d 行", tag.RowsAffected(), table.Rows)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// resetSequences moves every column-owned sequence past the restored maximum;
|
||||
// otherwise the next insert would collide with a restored primary key.
|
||||
func resetSequences(ctx context.Context, tx pgx.Tx) error {
|
||||
rows, err := tx.Query(ctx, `
|
||||
SELECT c.relname::text, a.attname::text, s.seq
|
||||
FROM pg_class c
|
||||
JOIN pg_namespace n ON n.oid = c.relnamespace
|
||||
JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
|
||||
CROSS JOIN LATERAL (SELECT pg_get_serial_sequence(format('%I.%I', n.nspname, c.relname), a.attname) AS seq) s
|
||||
WHERE n.nspname = current_schema() AND c.relkind = 'r' AND s.seq IS NOT NULL`)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
type serial struct{ table, column, sequence string }
|
||||
var serials []serial
|
||||
for rows.Next() {
|
||||
var item serial
|
||||
if err := rows.Scan(&item.table, &item.column, &item.sequence); err != nil {
|
||||
rows.Close()
|
||||
return err
|
||||
}
|
||||
serials = append(serials, item)
|
||||
}
|
||||
rows.Close()
|
||||
if err := rows.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, item := range serials {
|
||||
statement := fmt.Sprintf("SELECT setval($1, COALESCE((SELECT max(%s) FROM %s), 0) + 1, false)", ident(item.column), ident(item.table))
|
||||
if _, err := tx.Exec(ctx, statement, item.sequence); err != nil {
|
||||
return fmt.Errorf("重置序列 %s: %w", item.sequence, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -825,6 +825,11 @@ func (s *Server) Handler() http.Handler {
|
||||
mux.HandleFunc("POST /api/update/rollback", s.updateRollback)
|
||||
mux.HandleFunc("GET /api/update/stream", s.updateStream)
|
||||
|
||||
// 一键备份 / 恢复(迁移数据)。恢复会替换全部数据并重启,同样只对已登录管理员开放。
|
||||
mux.HandleFunc("GET /api/system/backup/status", s.backupStatus)
|
||||
mux.HandleFunc("GET /api/system/backup/export", s.backupExport)
|
||||
mux.HandleFunc("POST /api/system/backup/restore", s.backupRestore)
|
||||
|
||||
mux.HandleFunc("GET /api/tasks", s.listTasks)
|
||||
mux.HandleFunc("POST /api/tasks", s.createTask)
|
||||
mux.HandleFunc("GET /api/schedules", s.listSchedules)
|
||||
|
||||
@@ -0,0 +1,855 @@
|
||||
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/<table>.copy PostgreSQL 各表的 COPY 文本数据(大表按分片追加 .000001…)
|
||||
// files/<rel> 数据目录(任务工作区、会话、流量、证据、归档包、MITM CA…)
|
||||
// skills/<name>/… skill 目录
|
||||
// manifest.json 最后写入:表结构、分片与行数、来源数据目录、顶层条目清单
|
||||
//
|
||||
// 恢复分两步:上传时只解包到 <data>/.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)
|
||||
}
|
||||
@@ -0,0 +1,429 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
pgdb "github.com/Autumn-27/artex/db"
|
||||
"io"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// scratchDSN points the configured server at a fresh database that is dropped
|
||||
// when the test ends, so restores never truncate the shared development DB.
|
||||
func scratchDSN(t *testing.T, base, name string) string {
|
||||
t.Helper()
|
||||
u, err := url.Parse(base)
|
||||
if err != nil {
|
||||
t.Skipf("unparseable DSN: %v", err)
|
||||
}
|
||||
u.Path = "/" + name
|
||||
admin := *u
|
||||
admin.Path = "/postgres"
|
||||
t.Cleanup(func() {
|
||||
conn, err := sql.Open("pgx", admin.String())
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer conn.Close()
|
||||
_, _ = conn.Exec(`DROP DATABASE IF EXISTS "` + name + `" WITH (FORCE)`)
|
||||
})
|
||||
return u.String()
|
||||
}
|
||||
|
||||
func writeTestFile(t *testing.T, path, body string) {
|
||||
t.Helper()
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackupExportRestoreRoundTrip(t *testing.T) {
|
||||
base, _, err := pgdb.DSN()
|
||||
if err != nil {
|
||||
t.Skipf("no database config (%v)", err)
|
||||
}
|
||||
suffix := fmt.Sprintf("%d", time.Now().UnixNano())
|
||||
sourceDSN := scratchDSN(t, base, "artex_backup_src_"+suffix)
|
||||
targetDSN := scratchDSN(t, base, "artex_backup_dst_"+suffix)
|
||||
|
||||
sourceDir, sourceSkills := t.TempDir(), t.TempDir()
|
||||
t.Setenv("ARTEX_PG_DSN", sourceDSN)
|
||||
source, err := NewManager(sourceDir, "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Skipf("postgres unavailable (%v)", err)
|
||||
}
|
||||
task, err := source.pg.CreateTask("backup source", "migrate me", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := source.pg.SetSetting("backup.marker", "from-source"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
archivePath := filepath.Join(sourceDir, "archives", "tasks", "task-1.tar.zst")
|
||||
if _, err := source.pg.Exec(`INSERT INTO task_archives(task_id, state, archive_path) VALUES ($1, 'ready', $2)`, task.ID, archivePath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
writeTestFile(t, filepath.Join(sourceDir, "tasks", fmt.Sprint(task.ID), "note.txt"), "task workspace")
|
||||
writeTestFile(t, archivePath, "archive package")
|
||||
writeTestFile(t, filepath.Join(sourceDir, ".restore-failed", "junk"), "never exported")
|
||||
writeTestFile(t, filepath.Join(sourceSkills, "custom-skill", "SKILL.md"), "---\nname: custom-skill\n---\n")
|
||||
writeTestFile(t, filepath.Join(sourceSkills, "shipped", "SKILL.md"), "old copy")
|
||||
|
||||
exporter := &Server{m: source, skillDir: sourceSkills}
|
||||
|
||||
// Exporting while an active (non-terminal, non-paused) task exists must be refused.
|
||||
for _, method := range []string{"HEAD", "GET"} {
|
||||
blocked := httptest.NewRecorder()
|
||||
exporter.backupExport(blocked, httptest.NewRequest(method, "/api/system/backup/export", nil))
|
||||
if blocked.Code != 409 || blocked.Header().Get("X-Artex-Error-Code") != "backup_active_tasks" {
|
||||
t.Fatalf("%s with active task: status=%d header=%q body=%s", method, blocked.Code, blocked.Header().Get("X-Artex-Error-Code"), blocked.Body.String())
|
||||
}
|
||||
}
|
||||
if _, err := source.pg.Exec(`UPDATE tasks SET paused=true, pause_reason='paused_by_user' WHERE id=$1`, task.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Force small chunk size so multi-part COPY streaming is exercised end-to-end.
|
||||
prevChunk := backupCopyChunkBytes
|
||||
backupCopyChunkBytes = 128
|
||||
t.Cleanup(func() { backupCopyChunkBytes = prevChunk })
|
||||
|
||||
exported := httptest.NewRecorder()
|
||||
exporter.backupExport(exported, httptest.NewRequest("GET", "/api/system/backup/export", nil))
|
||||
source.Close()
|
||||
if exported.Code != 200 || exported.Body.Len() == 0 {
|
||||
t.Fatalf("export status=%d size=%d", exported.Code, exported.Body.Len())
|
||||
}
|
||||
|
||||
targetDir, targetSkills := t.TempDir(), t.TempDir()
|
||||
t.Setenv("ARTEX_PG_DSN", targetDSN)
|
||||
target, err := NewManager(targetDir, "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := target.pg.SetSetting("backup.stale", "replaced"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
writeTestFile(t, filepath.Join(targetDir, "tasks", "999", "old.txt"), "stale workspace")
|
||||
writeTestFile(t, filepath.Join(targetSkills, "shipped", "SKILL.md"), "new copy")
|
||||
|
||||
restorer := &Server{m: target, skillDir: targetSkills}
|
||||
upload := httptest.NewRecorder()
|
||||
restorer.backupRestore(upload, httptest.NewRequest("POST", "/api/system/backup/restore", bytes.NewReader(exported.Body.Bytes())))
|
||||
if upload.Code != 202 {
|
||||
target.Close()
|
||||
t.Fatalf("restore upload status=%d body=%s", upload.Code, upload.Body.String())
|
||||
}
|
||||
var uploadResp struct {
|
||||
RestoreID string `json:"restore_id"`
|
||||
}
|
||||
if err := json.Unmarshal(upload.Body.Bytes(), &uploadResp); err != nil || uploadResp.RestoreID == "" {
|
||||
target.Close()
|
||||
t.Fatalf("missing restore_id in 202 response: %s (err=%v)", upload.Body.String(), err)
|
||||
}
|
||||
|
||||
// A failed subsequent upload must leave the already-staged pending backup intact.
|
||||
badUpload := httptest.NewRecorder()
|
||||
restorer.backupRestore(badUpload, httptest.NewRequest("POST", "/api/system/backup/restore", strings.NewReader("corrupt")))
|
||||
if badUpload.Code != 400 {
|
||||
target.Close()
|
||||
t.Fatalf("corrupt upload status=%d body=%s", badUpload.Code, badUpload.Body.String())
|
||||
}
|
||||
if rawID, err := os.ReadFile(filepath.Join(targetDir, backupPendingDir, backupRestoreIDFile)); err != nil || strings.TrimSpace(string(rawID)) != uploadResp.RestoreID {
|
||||
target.Close()
|
||||
t.Fatalf("corrupt upload clobbered pending restore_id: got=%q err=%v want=%q", string(rawID), err, uploadResp.RestoreID)
|
||||
}
|
||||
|
||||
// Uploading a second valid backup atomically replaces pending without leaving -old dirs.
|
||||
upload2 := httptest.NewRecorder()
|
||||
restorer.backupRestore(upload2, httptest.NewRequest("POST", "/api/system/backup/restore", bytes.NewReader(exported.Body.Bytes())))
|
||||
target.Close()
|
||||
if upload2.Code != 202 {
|
||||
t.Fatalf("second upload status=%d body=%s", upload2.Code, upload2.Body.String())
|
||||
}
|
||||
var uploadResp2 struct {
|
||||
RestoreID string `json:"restore_id"`
|
||||
}
|
||||
if err := json.Unmarshal(upload2.Body.Bytes(), &uploadResp2); err != nil || uploadResp2.RestoreID == "" || uploadResp2.RestoreID == uploadResp.RestoreID {
|
||||
t.Fatalf("unexpected second restore_id: %s (first=%q err=%v)", upload2.Body.String(), uploadResp.RestoreID, err)
|
||||
}
|
||||
if entries, err := os.ReadDir(targetDir); err == nil {
|
||||
for _, entry := range entries {
|
||||
if strings.HasPrefix(entry.Name(), backupUploadPrefix) {
|
||||
t.Fatalf("staging left upload/old dir behind: %s", entry.Name())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result, err := ApplyPendingRestore(targetDir, targetSkills)
|
||||
if err != nil || result == nil || !result.Applied || result.ID != uploadResp2.RestoreID {
|
||||
t.Fatalf("restore not applied: result=%+v err=%v wantID=%q", result, err, uploadResp2.RestoreID)
|
||||
}
|
||||
if again, err := ApplyPendingRestore(targetDir, targetSkills); err != nil || again != nil {
|
||||
t.Fatalf("pending restore applied twice: result=%+v err=%v", again, err)
|
||||
}
|
||||
restored, err := pgdb.Open(targetDSN)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer restored.Close()
|
||||
if got, err := restored.GetTask(task.ID); err != nil || got == nil || got.Goal != "migrate me" {
|
||||
t.Fatalf("restored task=%+v err=%v", got, err)
|
||||
}
|
||||
if value, ok, _ := restored.GetSetting("backup.marker"); !ok || value != "from-source" {
|
||||
t.Fatalf("restored setting=%q ok=%v", value, ok)
|
||||
}
|
||||
if _, ok, _ := restored.GetSetting("backup.stale"); ok {
|
||||
t.Fatal("target-only setting survived the restore")
|
||||
}
|
||||
var restoredArchivePath string
|
||||
if err := restored.QueryRow(`SELECT archive_path FROM task_archives WHERE task_id=$1`, task.ID).Scan(&restoredArchivePath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if want := filepath.Join(targetDir, "archives", "tasks", "task-1.tar.zst"); restoredArchivePath != want {
|
||||
t.Fatalf("archive path=%q want %q", restoredArchivePath, want)
|
||||
}
|
||||
next, err := restored.CreateTask("after restore", "fresh id", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatalf("insert after restore (sequence not reset?): %v", err)
|
||||
}
|
||||
if next.ID <= task.ID {
|
||||
t.Fatalf("new task id %d does not follow restored id %d", next.ID, task.ID)
|
||||
}
|
||||
|
||||
for path, want := range map[string]string{
|
||||
filepath.Join(targetDir, "tasks", fmt.Sprint(task.ID), "note.txt"): "task workspace",
|
||||
filepath.Join(targetDir, "archives", "tasks", "task-1.tar.zst"): "archive package",
|
||||
filepath.Join(targetSkills, "custom-skill", "SKILL.md"): "---\nname: custom-skill\n---\n",
|
||||
filepath.Join(targetSkills, "shipped", "SKILL.md"): "new copy",
|
||||
} {
|
||||
if got, err := os.ReadFile(path); err != nil || string(got) != want {
|
||||
t.Fatalf("%s = %q, %v; want %q", path, got, err, want)
|
||||
}
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(targetDir, "traffic", "_index", "index.sqlite")); err != nil {
|
||||
t.Fatalf("traffic index snapshot not restored: %v", err)
|
||||
}
|
||||
for _, gone := range []string{
|
||||
filepath.Join(targetDir, "tasks", "999"),
|
||||
filepath.Join(targetDir, ".restore-failed"),
|
||||
filepath.Join(targetDir, backupPendingDir),
|
||||
filepath.Join(targetDir, backupPreviousDir),
|
||||
} {
|
||||
if _, err := os.Stat(gone); !os.IsNotExist(err) {
|
||||
t.Fatalf("%s should not exist after restore: %v", gone, err)
|
||||
}
|
||||
}
|
||||
|
||||
// A load that fails midway must leave the database exactly as it was.
|
||||
broken := []pgdb.RestoreTable{{
|
||||
BackupTable: pgdb.BackupTable{Name: "settings", Columns: []string{"key", "value"}, Rows: 2},
|
||||
Open: func() (io.ReadCloser, error) { return io.NopCloser(strings.NewReader("only\tone\n")), nil },
|
||||
}}
|
||||
if err := restored.RestoreTables(context.Background(), broken, pgdb.PathPrefixMove{}); err == nil {
|
||||
t.Fatal("row-count mismatch was accepted")
|
||||
}
|
||||
if got, err := restored.GetTask(task.ID); err != nil || got == nil {
|
||||
t.Fatalf("failed restore lost data: task=%+v err=%v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackupRestoreRejectsForeignPackage(t *testing.T) {
|
||||
if _, _, err := pgdb.DSN(); err != nil {
|
||||
t.Skipf("no database config (%v)", err)
|
||||
}
|
||||
dataDir := t.TempDir()
|
||||
m, err := NewManager(dataDir, "")
|
||||
if err != nil {
|
||||
t.Skipf("postgres unavailable (%v)", err)
|
||||
}
|
||||
defer m.Close()
|
||||
s := &Server{m: m}
|
||||
w := httptest.NewRecorder()
|
||||
s.backupRestore(w, httptest.NewRequest("POST", "/api/system/backup/restore", strings.NewReader("not a backup")))
|
||||
if w.Code != 400 {
|
||||
t.Fatalf("status=%d body=%s", w.Code, w.Body.String())
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(dataDir, backupPendingDir)); !os.IsNotExist(err) {
|
||||
t.Fatalf("invalid upload left a pending restore: %v", err)
|
||||
}
|
||||
entries, _ := os.ReadDir(dataDir)
|
||||
for _, entry := range entries {
|
||||
if strings.HasPrefix(entry.Name(), backupUploadPrefix) {
|
||||
t.Fatalf("invalid upload left staging dir %s", entry.Name())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackupRestoreWindowsPathsAndPausesUnpausedTasks(t *testing.T) {
|
||||
base, _, err := pgdb.DSN()
|
||||
if err != nil {
|
||||
t.Skipf("no database config (%v)", err)
|
||||
}
|
||||
suffix := fmt.Sprintf("%d", time.Now().UnixNano())
|
||||
srcDSN := scratchDSN(t, base, "artex_backup_win_src_"+suffix)
|
||||
dstDSN := scratchDSN(t, base, "artex_backup_win_dst_"+suffix)
|
||||
|
||||
src, err := pgdb.Open(srcDSN)
|
||||
if err != nil {
|
||||
t.Skipf("postgres unavailable (%v)", err)
|
||||
}
|
||||
defer src.Close()
|
||||
activeTask, err := src.CreateTask("active", "running goal", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := src.Exec(`UPDATE tasks SET status='running', paused=false, queued=true, schedule_paused=true WHERE id=$1`, activeTask.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
doneTask, err := src.CreateTask("done", "finished goal", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := src.Exec(`UPDATE tasks SET status='done', paused=false WHERE id=$1`, doneTask.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
otherTask, err := src.CreateTask("other", "linux path goal", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := src.Exec(`UPDATE tasks SET status='done', paused=false WHERE id=$1`, otherTask.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, row := range []struct {
|
||||
id int64
|
||||
path string
|
||||
}{
|
||||
{activeTask.ID, `C:\artex\data\archives\tasks\win-1.tar.zst`},
|
||||
{doneTask.ID, `C:\artex\data-old\archives\tasks\prefix-collision.tar.zst`},
|
||||
{otherTask.ID, `/app/data/archives/tasks/already-linux.tar.zst`},
|
||||
} {
|
||||
if _, err := src.Exec(`INSERT INTO task_archives(task_id, state, archive_path) VALUES ($1, 'ready', $2)`, row.id, row.path); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
var dumped []pgdb.RestoreTable
|
||||
err = src.DumpTables(context.Background(), func(table pgdb.BackupTable, copyTo func(io.Writer) (int64, error)) error {
|
||||
var buf bytes.Buffer
|
||||
rows, err := copyTo(&buf)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
table.Rows = rows
|
||||
raw := buf.Bytes()
|
||||
dumped = append(dumped, pgdb.RestoreTable{
|
||||
BackupTable: table,
|
||||
Open: func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(raw)), nil },
|
||||
})
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
dst, err := pgdb.Open(dstDSN)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer dst.Close()
|
||||
move := pgdb.PathPrefixMove{From: `C:\artex\data`, FromSeparator: `\`, To: `/app/data`, ToSeparator: `/`}
|
||||
if err := dst.RestoreTables(context.Background(), dumped, move); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var paused, queued, schedulePaused bool
|
||||
var pauseReason string
|
||||
if err := dst.QueryRow(`SELECT paused, pause_reason, queued, schedule_paused FROM tasks WHERE id=$1`, activeTask.ID).
|
||||
Scan(&paused, &pauseReason, &queued, &schedulePaused); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !paused || pauseReason != "paused_by_user" || queued || schedulePaused {
|
||||
t.Fatalf("restored active task not safely paused: paused=%v reason=%q queued=%v schedule_paused=%v", paused, pauseReason, queued, schedulePaused)
|
||||
}
|
||||
if err := dst.QueryRow(`SELECT paused FROM tasks WHERE id=$1`, doneTask.ID).Scan(&paused); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if paused {
|
||||
t.Fatal("terminal done task should not be flipped to paused")
|
||||
}
|
||||
for id, want := range map[int64]string{
|
||||
activeTask.ID: `/app/data/archives/tasks/win-1.tar.zst`,
|
||||
doneTask.ID: `C:\artex\data-old\archives\tasks\prefix-collision.tar.zst`,
|
||||
otherTask.ID: `/app/data/archives/tasks/already-linux.tar.zst`,
|
||||
} {
|
||||
var got string
|
||||
if err := dst.QueryRow(`SELECT archive_path FROM task_archives WHERE task_id=$1`, id).Scan(&got); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != want {
|
||||
t.Fatalf("task %d archive_path = %q, want %q", id, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyPendingRestoreFailsFastOnFileInstallError(t *testing.T) {
|
||||
dataDir := t.TempDir()
|
||||
pending := filepath.Join(dataDir, backupPendingDir)
|
||||
writeTestFile(t, filepath.Join(pending, backupDBDoneMarker), `{"at":"2026-11-20T00:00:00Z"}`)
|
||||
writeTestFile(t, filepath.Join(pending, backupRestoreIDFile), "rid-file-fail")
|
||||
writeTestFile(t, filepath.Join(pending, "db", "settings.copy"), "")
|
||||
writeTestFile(t, filepath.Join(pending, "files", "tasks", "1", "note.txt"), "restored note")
|
||||
writeTestFile(t, filepath.Join(pending, "skills", "custom-skill", "SKILL.md"), "skill body")
|
||||
manifest := backupManifest{
|
||||
Format: backupFormat,
|
||||
Version: "v0.3.30",
|
||||
CreatedAt: time.Now().UTC(),
|
||||
Tables: []backupTableEntry{{BackupTable: pgdb.BackupTable{Name: "settings", Columns: []string{"key", "value"}}}},
|
||||
Entries: []string{"tasks"},
|
||||
Skills: []string{"custom-skill"},
|
||||
}
|
||||
raw, err := json.Marshal(manifest)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
writeTestFile(t, filepath.Join(pending, backupManifestName), string(raw))
|
||||
|
||||
// A regular file where skillDir should be forces installBackupFiles to fail after DB commit.
|
||||
blockingSkillPath := filepath.Join(t.TempDir(), "not-a-dir")
|
||||
writeTestFile(t, blockingSkillPath, "blocker")
|
||||
|
||||
res, err := ApplyPendingRestore(dataDir, blockingSkillPath)
|
||||
if err == nil {
|
||||
t.Fatalf("expected error on file install failure, got result=%+v", res)
|
||||
}
|
||||
if res == nil || res.Applied || res.ID != "rid-file-fail" {
|
||||
t.Fatalf("unexpected failure result: %+v", res)
|
||||
}
|
||||
if _, statErr := os.Stat(pending); statErr != nil {
|
||||
t.Fatalf("pending dir must stay for retry on next boot: %v", statErr)
|
||||
}
|
||||
|
||||
// Once the blocker is fixed, the next boot resumes and finishes cleanly.
|
||||
realSkillDir := t.TempDir()
|
||||
res, err = ApplyPendingRestore(dataDir, realSkillDir)
|
||||
if err != nil || res == nil || !res.Applied || res.ID != "rid-file-fail" {
|
||||
t.Fatalf("resume after file install failure failed: result=%+v err=%v", res, err)
|
||||
}
|
||||
if got, err := os.ReadFile(filepath.Join(dataDir, "tasks", "1", "note.txt")); err != nil || string(got) != "restored note" {
|
||||
t.Fatalf("tasks note=%q err=%v", got, err)
|
||||
}
|
||||
if got, err := os.ReadFile(filepath.Join(realSkillDir, "custom-skill", "SKILL.md")); err != nil || string(got) != "skill body" {
|
||||
t.Fatalf("skill=%q err=%v", got, err)
|
||||
}
|
||||
if _, statErr := os.Stat(pending); !os.IsNotExist(statErr) {
|
||||
t.Fatalf("pending dir should be removed after completion: %v", statErr)
|
||||
}
|
||||
}
|
||||
@@ -656,7 +656,13 @@ func extractTaskArchivePackage(path, expectedSHA, destination string) error {
|
||||
return err
|
||||
}
|
||||
}
|
||||
decoder, err := zstd.NewReader(file)
|
||||
return extractTarZst(file, destination, maxArchiveFiles)
|
||||
}
|
||||
|
||||
// extractTarZst unpacks a zstd-compressed tar stream of plain files and
|
||||
// directories into destination, refusing entries that would escape it.
|
||||
func extractTarZst(input io.Reader, destination string, maxFiles int) error {
|
||||
decoder, err := zstd.NewReader(input)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -676,17 +682,17 @@ func extractTaskArchivePackage(path, expectedSHA, destination string) error {
|
||||
return err
|
||||
}
|
||||
entries++
|
||||
if entries > maxArchiveFiles || header.Size < 0 || total+header.Size > maxArchiveBytes {
|
||||
return errors.New("task archive exceeds extraction safety limits")
|
||||
if entries > maxFiles || header.Size < 0 || total+header.Size > maxArchiveBytes {
|
||||
return errors.New("archive exceeds extraction safety limits")
|
||||
}
|
||||
total += header.Size
|
||||
clean := filepath.Clean(filepath.FromSlash(header.Name))
|
||||
if clean == "." || filepath.IsAbs(clean) || clean == ".." || strings.HasPrefix(clean, ".."+string(filepath.Separator)) {
|
||||
return fmt.Errorf("unsafe task archive path %q", header.Name)
|
||||
return fmt.Errorf("unsafe archive path %q", header.Name)
|
||||
}
|
||||
target := filepath.Join(destination, clean)
|
||||
if relative, err := filepath.Rel(destination, target); err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
|
||||
return fmt.Errorf("unsafe task archive target %q", header.Name)
|
||||
return fmt.Errorf("unsafe archive target %q", header.Name)
|
||||
}
|
||||
switch header.Typeflag {
|
||||
case tar.TypeDir:
|
||||
@@ -707,7 +713,7 @@ func extractTaskArchivePackage(path, expectedSHA, destination string) error {
|
||||
return err
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("unsupported task archive entry type %d", header.Typeflag)
|
||||
return fmt.Errorf("unsupported archive entry type %d", header.Typeflag)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
||||
@@ -378,6 +378,14 @@ func (t *Traffic) CACertPath() string {
|
||||
return filepath.Join(t.dir, "_ca", "mitmproxy-ca-cert.pem")
|
||||
}
|
||||
|
||||
// SnapshotIndex writes a transactionally consistent copy of the live SQLite
|
||||
// index to dest (which must not exist). Copying index.sqlite directly would miss
|
||||
// pages still in the WAL and could capture a half-applied write.
|
||||
func (t *Traffic) SnapshotIndex(dest string) error {
|
||||
_, err := t.db.Exec(`VACUUM INTO ?`, dest)
|
||||
return err
|
||||
}
|
||||
|
||||
// Start runs the proxy (blocking); run in a goroutine.
|
||||
func (t *Traffic) Start() error { return t.proxy.Start() }
|
||||
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
"use client";
|
||||
|
||||
import * as React from "react";
|
||||
|
||||
import { ArchiveRestoreIcon, DatabaseBackupIcon, DownloadIcon } from "lucide-react";
|
||||
import { toast } from "sonner";
|
||||
|
||||
import {
|
||||
AlertDialog,
|
||||
AlertDialogAction,
|
||||
AlertDialogCancel,
|
||||
AlertDialogContent,
|
||||
AlertDialogDescription,
|
||||
AlertDialogFooter,
|
||||
AlertDialogHeader,
|
||||
AlertDialogTitle,
|
||||
} from "@/components/ui/alert-dialog";
|
||||
import { Button } from "@/components/ui/button";
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
|
||||
import { Progress } from "@/components/ui/progress";
|
||||
import { localizedError } from "@/i18n/errors";
|
||||
import { useLiveTranslation } from "@/i18n/use-live-translation";
|
||||
import { api, type BackupStatus } from "@/lib/api";
|
||||
|
||||
/** 恢复要先完成数据库整体替换和文件换装,再走一次正常启动;数据量大时比升级慢得多。 */
|
||||
const RESTORE_TIMEOUT_MS = 15 * 60_000;
|
||||
|
||||
export function BackupCard() {
|
||||
const { t, liveT } = useLiveTranslation();
|
||||
const [status, setStatus] = React.useState<BackupStatus | null>(null);
|
||||
const [file, setFile] = React.useState<File | null>(null);
|
||||
const [uploading, setUploading] = React.useState(false);
|
||||
const [restarting, setRestarting] = React.useState(false);
|
||||
const inputRef = React.useRef<HTMLInputElement>(null);
|
||||
|
||||
React.useEffect(() => {
|
||||
api
|
||||
.backupStatus()
|
||||
.then(setStatus)
|
||||
.catch(() => setStatus(null));
|
||||
}, []);
|
||||
|
||||
const download = async () => {
|
||||
try {
|
||||
await api.downloadBackup();
|
||||
toast.success(t("settings.backup.downloadStarted"));
|
||||
} catch (e) {
|
||||
toast.error(t("settings.backup.downloadFailedPrefix") + localizedError(e, t));
|
||||
}
|
||||
};
|
||||
|
||||
// 重启期间接口连不上是预期的;以"返回本次上传对应的 restore_id 结果"为准判断新进程已就绪。
|
||||
const waitForRestore = React.useCallback(
|
||||
async (restoreId: string) => {
|
||||
setRestarting(true);
|
||||
const deadline = Date.now() + RESTORE_TIMEOUT_MS;
|
||||
while (Date.now() < deadline) {
|
||||
const tick = Promise.withResolvers<void>();
|
||||
setTimeout(tick.resolve, 3000);
|
||||
await tick.promise;
|
||||
try {
|
||||
const next = await api.backupStatus();
|
||||
if (next.last_restore?.id === restoreId) {
|
||||
window.location.reload();
|
||||
return;
|
||||
}
|
||||
} catch {
|
||||
// 继续轮询。
|
||||
}
|
||||
}
|
||||
setRestarting(false);
|
||||
toast.error(liveT("settings.backup.restoreTimeout"));
|
||||
},
|
||||
[liveT],
|
||||
);
|
||||
|
||||
const restore = async () => {
|
||||
if (!file) return;
|
||||
const selected = file;
|
||||
setFile(null);
|
||||
setUploading(true);
|
||||
try {
|
||||
const res = await api.restoreBackup(selected);
|
||||
setUploading(false);
|
||||
await waitForRestore(res.restore_id);
|
||||
} catch (e) {
|
||||
setUploading(false);
|
||||
toast.error(t("settings.backup.restoreFailedPrefix") + localizedError(e, t));
|
||||
}
|
||||
};
|
||||
|
||||
const busy = uploading || restarting;
|
||||
const last = status?.last_restore;
|
||||
|
||||
return (
|
||||
<Card className="mb-4 break-inside-avoid md:mb-6">
|
||||
<CardHeader>
|
||||
<CardTitle className="flex items-center gap-2 text-base">
|
||||
<DatabaseBackupIcon className="size-4" />
|
||||
{t("settings.backup.title")}
|
||||
</CardTitle>
|
||||
<CardDescription>{t("settings.backup.help")}</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent className="flex flex-col gap-4">
|
||||
{last?.applied ? (
|
||||
<p className="text-xs text-muted-foreground">
|
||||
{t("settings.backup.lastRestoreOk", {
|
||||
time: new Date(last.at).toLocaleString(),
|
||||
version: last.source_version || "-",
|
||||
})}
|
||||
</p>
|
||||
) : null}
|
||||
{last && !last.applied && last.error ? (
|
||||
<p role="alert" className="text-xs text-destructive">
|
||||
{t("settings.backup.lastRestoreFailed", { message: last.error })}
|
||||
</p>
|
||||
) : null}
|
||||
{status?.pending && !busy ? (
|
||||
<p className="text-xs text-muted-foreground">{t("settings.backup.pending")}</p>
|
||||
) : null}
|
||||
|
||||
{busy ? (
|
||||
<div className="space-y-1.5">
|
||||
<Progress value={100} className="animate-pulse" />
|
||||
<p className="text-xs text-muted-foreground">
|
||||
{restarting ? t("settings.backup.restarting") : t("settings.backup.uploading")}
|
||||
</p>
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
<div className="flex flex-wrap gap-2">
|
||||
<Button size="sm" onClick={download} disabled={busy}>
|
||||
<DownloadIcon className="size-4" />
|
||||
{t("settings.backup.download")}
|
||||
</Button>
|
||||
<Button variant="outline" size="sm" onClick={() => inputRef.current?.click()} disabled={busy}>
|
||||
<ArchiveRestoreIcon className="size-4" />
|
||||
{t("settings.backup.restore")}
|
||||
</Button>
|
||||
<input
|
||||
ref={inputRef}
|
||||
type="file"
|
||||
accept=".zst,.tar.zst"
|
||||
className="hidden"
|
||||
onChange={(e) => {
|
||||
setFile(e.target.files?.[0] ?? null);
|
||||
e.target.value = "";
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
|
||||
<p className="text-xs text-muted-foreground">{t("settings.backup.note")}</p>
|
||||
</CardContent>
|
||||
|
||||
<AlertDialog open={file !== null} onOpenChange={(open) => (open ? null : setFile(null))}>
|
||||
<AlertDialogContent>
|
||||
<AlertDialogHeader>
|
||||
<AlertDialogTitle>{t("settings.backup.confirmTitle")}</AlertDialogTitle>
|
||||
<AlertDialogDescription>
|
||||
{t("settings.backup.confirmBody", { name: file?.name ?? "" })}
|
||||
</AlertDialogDescription>
|
||||
</AlertDialogHeader>
|
||||
<AlertDialogFooter>
|
||||
<AlertDialogCancel>{t("settings.backup.cancel")}</AlertDialogCancel>
|
||||
<AlertDialogAction variant="destructive" onClick={restore}>
|
||||
{t("settings.backup.confirm")}
|
||||
</AlertDialogAction>
|
||||
</AlertDialogFooter>
|
||||
</AlertDialogContent>
|
||||
</AlertDialog>
|
||||
</Card>
|
||||
);
|
||||
}
|
||||
@@ -30,6 +30,7 @@ import { CHAT_SEND_MODE_OPTIONS, type ChatSendMode, setChatSendMode, useChatSend
|
||||
import type { EgressReport, LLMProfile, ProxyPoolEntry, Settings, WorkerPool } from "@/lib/types";
|
||||
|
||||
import { useEgressIp } from "../../_components/egress-ip-banner";
|
||||
import { BackupCard } from "./_components/backup-card";
|
||||
import { BasicAuthCard } from "./_components/basic-auth-card";
|
||||
import { McpServerCard } from "./_components/mcp-server-card";
|
||||
import { UpdateCard } from "./_components/update-card";
|
||||
@@ -766,6 +767,7 @@ export default function SystemSettingsPage() {
|
||||
|
||||
<div className="flex flex-col divide-y rounded-xl border bg-card/30 px-3 [&>[data-slot=card]]:mb-0 [&>[data-slot=card]]:rounded-none [&>[data-slot=card]]:bg-transparent [&>[data-slot=card]]:py-4 [&>[data-slot=card]]:ring-0">
|
||||
{isSettingVisible("system", "settings.keywords.update") ? <UpdateCard /> : null}
|
||||
{isSettingVisible("system", "settings.keywords.backup") ? <BackupCard /> : null}
|
||||
{isSettingVisible("system", "settings.keywords.basicAuth") ? <BasicAuthCard /> : null}
|
||||
{isSettingVisible("system", "settings.keywords.mcpServer") ? <McpServerCard /> : null}
|
||||
|
||||
|
||||
@@ -3,6 +3,20 @@ export const errorMessages = {
|
||||
"情报数据响应不完整,请刷新后重试",
|
||||
"The intelligence response is incomplete. Refresh to try again.",
|
||||
],
|
||||
"error.backup_busy": ["已有备份或恢复正在进行", "A backup or restore is already in progress"],
|
||||
"error.backup_active_tasks": [
|
||||
"存在未暂停的运行中或排队中任务,请先暂停或等待任务完成后再下载备份",
|
||||
"Active or queued tasks are running. Pause them or wait for them to finish before downloading a backup.",
|
||||
],
|
||||
"error.backup_update_running": [
|
||||
"更新正在进行中,无法恢复备份",
|
||||
"An update is in progress. The backup cannot be restored now.",
|
||||
],
|
||||
"error.backup_invalid": ["备份包无效:{{message}}", "Invalid backup package: {{message}}"],
|
||||
"error.demo_backup_disabled": [
|
||||
"演示模式不支持备份与恢复,请在实际部署中使用",
|
||||
"Backup and restore are not available in the demo. Use them in a deployed instance.",
|
||||
],
|
||||
"error.basic_auth_required": ["请先完成 HTTP Basic Auth 验证", "Complete HTTP Basic Auth verification first"],
|
||||
"error.auth_session_failed": ["认证会话生成失败", "Unable to create an authentication session"],
|
||||
"error.basic_auth_username_invalid": [
|
||||
|
||||
@@ -138,6 +138,7 @@ test("migrated pages reference existing keys and contain no hardcoded Chinese di
|
||||
"components/approval-execution-focus.tsx",
|
||||
"hooks/use-side-questions.ts",
|
||||
"app/(main)/dashboard/page.tsx",
|
||||
"app/(main)/system/settings/_components/backup-card.tsx",
|
||||
"app/(main)/system/settings/_components/basic-auth-card.tsx",
|
||||
"app/(main)/system/settings/_components/update-card.tsx",
|
||||
"app/(main)/_components/egress-ip-banner.tsx",
|
||||
|
||||
@@ -110,6 +110,52 @@ export const settingsMessages = {
|
||||
"settings.matchingSettings": ["匹配“{{query}}”的设置项", "Settings matching “{{query}}”"],
|
||||
"settings.clearSearch": ["清除搜索", "Clear search"],
|
||||
"settings.keywords.update": ["更新 版本 升级", "update version upgrade"],
|
||||
"settings.keywords.backup": [
|
||||
"备份 恢复 迁移 导出 导入 数据 一键备份",
|
||||
"backup restore migrate migration export import data",
|
||||
],
|
||||
"settings.backup.title": ["备份与迁移", "Backup and migration"],
|
||||
"settings.backup.help": [
|
||||
"一键导出全部数据(数据库、任务工作区、会话、流量、证据、归档包、MITM 证书和 skills),在新机器上恢复即可完成迁移。",
|
||||
"Export all data (database, task workspaces, sessions, traffic, evidence, archive packages, MITM certificate and skills) in one file, then restore it on another machine to migrate.",
|
||||
],
|
||||
"settings.backup.download": ["下载备份", "Download backup"],
|
||||
"settings.backup.downloadStarted": [
|
||||
"备份已开始生成,浏览器会直接下载,数据较多时需要一些时间",
|
||||
"The backup is being generated and will download directly. Large installations take a while.",
|
||||
],
|
||||
"settings.backup.downloadFailedPrefix": ["下载备份失败:", "Could not download backup: "],
|
||||
"settings.backup.restore": ["从备份恢复", "Restore from backup"],
|
||||
"settings.backup.uploading": ["正在上传并校验备份…", "Uploading and verifying the backup…"],
|
||||
"settings.backup.restoreFailedPrefix": ["恢复失败:", "Restore failed: "],
|
||||
"settings.backup.confirmTitle": ["用备份替换当前全部数据?", "Replace all current data with this backup?"],
|
||||
"settings.backup.confirmBody": [
|
||||
"当前实例的任务、资产、漏洞、配置、文件和流量都会被「{{name}}」中的内容替换,且无法撤销。上传校验通过后程序会重启并停止当前运行中的任务;备份中未结束的任务在恢复后会保持暂停,不会自动继续执行。建议先下载一份当前数据的备份。",
|
||||
"Tasks, assets, findings, settings, files and traffic on this instance will be replaced by the contents of “{{name}}”. This cannot be undone. After the upload is verified, ARTEX restarts and stops tasks currently running here; any unfinished tasks from the backup start paused rather than resuming automatically. Download a backup of the current data first.",
|
||||
],
|
||||
"settings.backup.cancel": ["取消", "Cancel"],
|
||||
"settings.backup.confirm": ["替换并重启", "Replace and restart"],
|
||||
"settings.backup.restarting": [
|
||||
"备份已校验,正在重启并恢复数据,请稍候(页面会自动刷新)…",
|
||||
"Backup verified. Restarting to restore data. Please wait; the page will reload automatically…",
|
||||
],
|
||||
"settings.backup.restoreTimeout": [
|
||||
"等待服务重启超时(大备份的数据库恢复可能仍在进行)。请查看后端日志、稍后刷新页面,或确认 artex 是通过 start.sh / start.bat 启动的。",
|
||||
"Timed out waiting for the service to restart (a large backup may still be restoring on the server). Check the backend logs, refresh later, or confirm ARTEX was started with start.sh / start.bat.",
|
||||
],
|
||||
"settings.backup.lastRestoreOk": [
|
||||
"已于 {{time}} 从备份恢复(备份版本 {{version}})。",
|
||||
"Restored from a backup at {{time}} (backup version {{version}}).",
|
||||
],
|
||||
"settings.backup.lastRestoreFailed": ["上次恢复失败:{{message}}", "The last restore failed: {{message}}"],
|
||||
"settings.backup.pending": [
|
||||
"有一份已上传的备份等待重启后恢复。",
|
||||
"An uploaded backup will be restored at the next restart.",
|
||||
],
|
||||
"settings.backup.note": [
|
||||
"下载备份前需先暂停或等待所有运行中、排队中的任务结束。恢复需要相同或更新版本的 ARTEX;登录密码、Basic Auth 与 LLM 配置随数据库一起迁移,恢复后请使用原实例的密码登录;新机器上已有的同名 skill 保留本机版本。",
|
||||
"Pause or finish active and queued tasks before downloading a backup. Restoring requires the same or a newer ARTEX version. The sign-in password, Basic Auth and LLM settings move with the database, so sign in with the original instance's password afterwards. Skills that already exist on the new machine keep the local copy.",
|
||||
],
|
||||
"settings.keywords.basicAuth": [
|
||||
"基础认证 登录 用户名 密码",
|
||||
"basic auth authentication sign-in login username password",
|
||||
|
||||
@@ -163,6 +163,20 @@ export async function apiFetch(input: string, init?: RequestInit): Promise<Respo
|
||||
return response;
|
||||
}
|
||||
|
||||
export interface BackupStatus {
|
||||
// 已上传、等待重启时恢复的备份。
|
||||
pending: boolean;
|
||||
// 本次启动时执行的恢复结果;未执行恢复时为 null。
|
||||
last_restore: {
|
||||
id?: string;
|
||||
applied: boolean;
|
||||
error?: string;
|
||||
at: string;
|
||||
source_version?: string;
|
||||
backup_created_at?: string;
|
||||
} | null;
|
||||
}
|
||||
|
||||
export type McpServerScope = "read" | "task:create" | "task:control";
|
||||
|
||||
export interface McpServerSettings {
|
||||
@@ -416,6 +430,33 @@ export const api = {
|
||||
version: () => http<{ version: string }>("/version", { cache: "no-store" }),
|
||||
systemMetrics: () => get<SystemMetrics>("/system/metrics"),
|
||||
|
||||
// ---- 一键备份 / 恢复 ----
|
||||
backupStatus: () => get<BackupStatus>("/system/backup/status"),
|
||||
// 备份包可能有数 GB:与任务文件下载一样先 HEAD 校验登录,再交给浏览器直接落盘(cookie 鉴权),不读进内存。
|
||||
downloadBackup: async () => {
|
||||
if (MOCK) throw new ApiError("演示模式不支持备份与恢复", "demo_backup_disabled");
|
||||
const token = getToken();
|
||||
const response = await apiFetch("/api/system/backup/export", {
|
||||
method: "HEAD",
|
||||
headers: token ? { Authorization: `Bearer ${token}` } : {},
|
||||
});
|
||||
if (!response.ok) {
|
||||
const code = response.headers.get("X-Artex-Error-Code") ?? (response.status === 409 ? "backup_busy" : undefined);
|
||||
throw new ApiError(`HEAD /system/backup/export: ${response.status}`, code);
|
||||
}
|
||||
const a = document.createElement("a");
|
||||
a.href = "/api/system/backup/export";
|
||||
document.body.appendChild(a);
|
||||
a.click();
|
||||
a.remove();
|
||||
},
|
||||
restoreBackup: (file: File) =>
|
||||
http<{ ok: boolean; restore_id: string; version: string; created_at: string }>("/system/backup/restore", {
|
||||
method: "POST",
|
||||
body: file,
|
||||
headers: { "Content-Type": "application/octet-stream" },
|
||||
}),
|
||||
|
||||
// ---- auth ----
|
||||
authStatus: () => get<{ initialized: boolean }>("/auth/status"),
|
||||
login: (username: string, password: string) => post<{ token: string }>("/auth/login", { username, password }),
|
||||
|
||||
@@ -2470,6 +2470,9 @@ function route(m: string, path: string, seg: string[], q: URLSearchParams, b: Re
|
||||
throw Object.assign(new Error("演示模式不支持修改 HTTP Basic Auth,请在实际部署中配置"), {
|
||||
code: "demo_basic_auth_disabled",
|
||||
});
|
||||
if (path === "/system/backup/status") return { pending: false, last_restore: null };
|
||||
if (path === "/system/backup/restore")
|
||||
throw Object.assign(new Error("演示模式不支持备份与恢复,请在实际部署中使用"), { code: "demo_backup_disabled" });
|
||||
if (path === "/settings/web-search/test") return { ok: true, count: 5, backend: D.settings.web_search_backend };
|
||||
if (path === "/settings/proxy/test")
|
||||
return {
|
||||
|
||||
Reference in new issue
Block a user