yangxiangyuan
1766 lines
64 KiB
JavaScript
1766 lines
64 KiB
JavaScript
const fs = require('fs')
|
|
const path = require('path')
|
|
const crypto = require('crypto')
|
|
const archiver = require('archiver')
|
|
const axios = require('axios')
|
|
const Database = require('better-sqlite3')
|
|
const unzipper = require('unzipper')
|
|
const { logJSON } = require('./logger')
|
|
require('./weekly')
|
|
const weeklyCore = require('./weekly_core')
|
|
const aiLib = require('./ai-lib')
|
|
|
|
const ROOT_DIR = process.cwd()
|
|
const CONFIG_PATH = path.join(ROOT_DIR, 'config', 'box_backup.config.json')
|
|
const DATA_DIR = path.join(ROOT_DIR, 'data')
|
|
const TEMP_DIR = path.join(ROOT_DIR, 'temp', 'box_backup')
|
|
const DB_PATH = path.join(DATA_DIR, 'box_backup.db')
|
|
|
|
const ensureDir = dir => {
|
|
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
|
|
}
|
|
|
|
const streamToBuffer = stream => new Promise((resolve, reject) => {
|
|
const chunks = []
|
|
stream.on('data', chunk => chunks.push(Buffer.from(chunk)))
|
|
stream.on('end', () => resolve(Buffer.concat(chunks)))
|
|
stream.on('error', reject)
|
|
})
|
|
|
|
ensureDir(DATA_DIR)
|
|
ensureDir(TEMP_DIR)
|
|
|
|
const db = new Database(DB_PATH)
|
|
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS backup_runs (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
run_key TEXT NOT NULL UNIQUE,
|
|
mode TEXT NOT NULL,
|
|
trigger_source TEXT NOT NULL,
|
|
status TEXT NOT NULL DEFAULT 'running',
|
|
stage TEXT NOT NULL DEFAULT '',
|
|
started_at TEXT DEFAULT (datetime('now','+8 hours')),
|
|
ended_at TEXT,
|
|
summary_json TEXT DEFAULT '',
|
|
error_text TEXT DEFAULT ''
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_backup_runs_mode_started ON backup_runs(mode, started_at DESC);
|
|
|
|
CREATE TABLE IF NOT EXISTS backup_run_events (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
run_id INTEGER NOT NULL,
|
|
level TEXT NOT NULL DEFAULT 'info',
|
|
event_type TEXT NOT NULL DEFAULT '',
|
|
message TEXT NOT NULL DEFAULT '',
|
|
detail_json TEXT DEFAULT '',
|
|
created_at TEXT DEFAULT (datetime('now','+8 hours'))
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_backup_run_events_run ON backup_run_events(run_id, id DESC);
|
|
CREATE INDEX IF NOT EXISTS idx_backup_run_events_type ON backup_run_events(event_type, created_at DESC);
|
|
|
|
CREATE TABLE IF NOT EXISTS backup_alerts (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
run_id INTEGER,
|
|
severity TEXT NOT NULL DEFAULT 'warning',
|
|
title TEXT NOT NULL DEFAULT '',
|
|
message TEXT NOT NULL DEFAULT '',
|
|
status TEXT NOT NULL DEFAULT 'open',
|
|
created_at TEXT DEFAULT (datetime('now','+8 hours'))
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_backup_alerts_created ON backup_alerts(created_at DESC);
|
|
|
|
CREATE TABLE IF NOT EXISTS backup_objects (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
backup_type TEXT NOT NULL,
|
|
relative_path TEXT NOT NULL,
|
|
source_path TEXT NOT NULL DEFAULT '',
|
|
oss_key TEXT NOT NULL DEFAULT '',
|
|
size_bytes INTEGER DEFAULT 0,
|
|
mtime_ms INTEGER DEFAULT 0,
|
|
sha256 TEXT DEFAULT '',
|
|
upload_status TEXT NOT NULL DEFAULT 'pending',
|
|
retry_count INTEGER DEFAULT 0,
|
|
last_error TEXT DEFAULT '',
|
|
last_uploaded_at TEXT,
|
|
is_deleted INTEGER DEFAULT 0,
|
|
deleted_at TEXT,
|
|
meta_json TEXT DEFAULT '',
|
|
UNIQUE(backup_type, relative_path)
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_backup_objects_type_status ON backup_objects(backup_type, upload_status, is_deleted);
|
|
|
|
CREATE TABLE IF NOT EXISTS backup_manual_records (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
record_type TEXT NOT NULL,
|
|
note TEXT DEFAULT '',
|
|
created_at TEXT DEFAULT (datetime('now','+8 hours'))
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_backup_manual_records_type ON backup_manual_records(record_type, created_at DESC);
|
|
|
|
CREATE TABLE IF NOT EXISTS backup_config_history (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
config_json TEXT NOT NULL,
|
|
created_at TEXT DEFAULT (datetime('now','+8 hours'))
|
|
);
|
|
`)
|
|
|
|
const insertRunStmt = db.prepare(`
|
|
INSERT INTO backup_runs (run_key, mode, trigger_source, status, stage, summary_json)
|
|
VALUES (@run_key, @mode, @trigger_source, @status, @stage, @summary_json)
|
|
`)
|
|
const updateRunStmt = db.prepare(`
|
|
UPDATE backup_runs
|
|
SET status=@status,
|
|
stage=@stage,
|
|
ended_at=@ended_at,
|
|
summary_json=@summary_json,
|
|
error_text=@error_text
|
|
WHERE id=@id
|
|
`)
|
|
const insertEventStmt = db.prepare(`
|
|
INSERT INTO backup_run_events (run_id, level, event_type, message, detail_json)
|
|
VALUES (@run_id, @level, @event_type, @message, @detail_json)
|
|
`)
|
|
const insertAlertStmt = db.prepare(`
|
|
INSERT INTO backup_alerts (run_id, severity, title, message, status)
|
|
VALUES (@run_id, @severity, @title, @message, 'open')
|
|
`)
|
|
const insertManualRecordStmt = db.prepare(`
|
|
INSERT INTO backup_manual_records (record_type, note)
|
|
VALUES (?, ?)
|
|
`)
|
|
const insertConfigHistoryStmt = db.prepare(`
|
|
INSERT INTO backup_config_history (config_json) VALUES (?)
|
|
`)
|
|
const getObjectStmt = db.prepare(`
|
|
SELECT * FROM backup_objects WHERE backup_type=? AND relative_path=?
|
|
`)
|
|
const upsertObjectInsertStmt = db.prepare(`
|
|
INSERT INTO backup_objects (
|
|
backup_type, relative_path, source_path, oss_key, size_bytes, mtime_ms, sha256,
|
|
upload_status, retry_count, last_error, last_uploaded_at, is_deleted, deleted_at, meta_json
|
|
) VALUES (
|
|
@backup_type, @relative_path, @source_path, @oss_key, @size_bytes, @mtime_ms, @sha256,
|
|
@upload_status, @retry_count, @last_error, @last_uploaded_at, @is_deleted, @deleted_at, @meta_json
|
|
)
|
|
`)
|
|
const upsertObjectUpdateStmt = db.prepare(`
|
|
UPDATE backup_objects
|
|
SET source_path=@source_path,
|
|
oss_key=@oss_key,
|
|
size_bytes=@size_bytes,
|
|
mtime_ms=@mtime_ms,
|
|
sha256=@sha256,
|
|
upload_status=@upload_status,
|
|
retry_count=@retry_count,
|
|
last_error=@last_error,
|
|
last_uploaded_at=@last_uploaded_at,
|
|
is_deleted=@is_deleted,
|
|
deleted_at=@deleted_at,
|
|
meta_json=@meta_json
|
|
WHERE id=@id
|
|
`)
|
|
|
|
const DEFAULT_CONFIG = {
|
|
version: 1,
|
|
scheduler: {
|
|
enabled: true,
|
|
poll_seconds: 30,
|
|
highfreq_cron: '5 1 * * 0',
|
|
lowfreq_cron: '35 1 * * 0'
|
|
},
|
|
paths: {
|
|
highfreq: {
|
|
code_paths: [
|
|
'src',
|
|
'scripts',
|
|
'config',
|
|
'service',
|
|
'deploy',
|
|
'tools',
|
|
'public/common',
|
|
'public/assets',
|
|
'public/lib',
|
|
'public/icons',
|
|
'winform/DocHelper',
|
|
'winform/auth_token_winform'
|
|
],
|
|
root_files: [
|
|
'package.json',
|
|
'package-lock.json',
|
|
'webpack.config.js',
|
|
'web.config',
|
|
'install_service_8977.bat',
|
|
'uninstall_service_8977.bat'
|
|
],
|
|
tool_root: 'public/tools',
|
|
tool_code_extensions: ['.html', '.js', '.css', '.json', '.svg', '.ico', '.txt'],
|
|
data_config_extensions: ['.json'],
|
|
db_dir: 'data',
|
|
db_extensions: ['.db'],
|
|
exclude_dirs: [
|
|
'node_modules',
|
|
'.git',
|
|
'Toolbox-Weekly-Backup',
|
|
'backups',
|
|
'temp',
|
|
'logs',
|
|
'public/images',
|
|
'public/download_files',
|
|
'public/home-bg',
|
|
'data/psc_chunks',
|
|
'data/psc_secrets',
|
|
'uploads',
|
|
'winform/CalendarReminder_winform'
|
|
]
|
|
},
|
|
lowfreq: {
|
|
include_paths: [
|
|
'uploads/cloud_notes',
|
|
'uploads/private_clipboard',
|
|
'uploads/plant_home',
|
|
'uploads/ai-lib',
|
|
'uploads/ccb_private_funds',
|
|
'uploads/doc_cloud_keeper',
|
|
'uploads/weekly',
|
|
'uploads/expense',
|
|
'uploads/cloud',
|
|
'public/images/korean_references',
|
|
'public/images/wave_references',
|
|
'public/images/x_fashion',
|
|
'public/images/style_check_images',
|
|
'public/download_files'
|
|
],
|
|
exclude_dirs: [
|
|
'node_modules',
|
|
'.git',
|
|
'Toolbox-Weekly-Backup',
|
|
'backups',
|
|
'temp'
|
|
],
|
|
keep_deleted_marker: true
|
|
}
|
|
},
|
|
oss: {
|
|
enabled: true,
|
|
credential_file_name: 'Toolbox_local_creds.env.local',
|
|
access_key_id_key: 'BOX_BACKUP_OSS_ACCESS_KEY_ID',
|
|
access_key_secret_key: 'BOX_BACKUP_OSS_ACCESS_KEY_SECRET',
|
|
endpoint_key: 'BOX_BACKUP_OSS_ENDPOINT',
|
|
bucket_key: 'BOX_BACKUP_OSS_BUCKET',
|
|
root_prefix_key: 'BOX_BACKUP_OSS_ROOT_PREFIX',
|
|
bucket: '',
|
|
endpoint: '',
|
|
root_prefix: '',
|
|
lowfreq_dir_name: 'DPWJ780-36C4-4811-BE92-47A86DF35E10'
|
|
},
|
|
retry: {
|
|
max_attempts: 3,
|
|
base_delay_ms: 2000
|
|
},
|
|
verification: {
|
|
head_check: true,
|
|
lowfreq_sample_size: 3,
|
|
restore_max_download_mb: 2048
|
|
},
|
|
notifications: {
|
|
enabled: false,
|
|
channels: []
|
|
}
|
|
}
|
|
|
|
const clone = value => JSON.parse(JSON.stringify(value))
|
|
|
|
const mergeDefaults = (base, extra) => {
|
|
if (!extra || typeof extra !== 'object' || Array.isArray(extra)) return clone(base)
|
|
const out = Array.isArray(base) ? [] : {}
|
|
const keys = new Set([...Object.keys(base || {}), ...Object.keys(extra || {})])
|
|
keys.forEach(key => {
|
|
const left = base ? base[key] : undefined
|
|
const right = extra ? extra[key] : undefined
|
|
if (Array.isArray(left)) out[key] = Array.isArray(right) ? right.slice() : left.slice()
|
|
else if (left && typeof left === 'object') out[key] = mergeDefaults(left, right)
|
|
else out[key] = right === undefined ? left : right
|
|
})
|
|
return out
|
|
}
|
|
|
|
const ensureConfigFile = () => {
|
|
ensureDir(path.dirname(CONFIG_PATH))
|
|
if (!fs.existsSync(CONFIG_PATH)) {
|
|
fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2))
|
|
}
|
|
}
|
|
|
|
const sanitizeStringArray = list => {
|
|
const raw = Array.isArray(list) ? list : []
|
|
return raw
|
|
.map(item => String(item || '').trim().replace(/\\/g, '/'))
|
|
.filter(Boolean)
|
|
}
|
|
|
|
const sanitizeConfig = input => {
|
|
const merged = mergeDefaults(DEFAULT_CONFIG, input || {})
|
|
merged.scheduler.enabled = merged.scheduler.enabled !== false
|
|
merged.scheduler.poll_seconds = Math.max(10, parseInt(String(merged.scheduler.poll_seconds || '30'), 10) || 30)
|
|
merged.scheduler.highfreq_cron = String(merged.scheduler.highfreq_cron || DEFAULT_CONFIG.scheduler.highfreq_cron).trim()
|
|
merged.scheduler.lowfreq_cron = String(merged.scheduler.lowfreq_cron || DEFAULT_CONFIG.scheduler.lowfreq_cron).trim()
|
|
merged.paths.highfreq.code_paths = sanitizeStringArray(merged.paths.highfreq.code_paths)
|
|
merged.paths.highfreq.root_files = sanitizeStringArray(merged.paths.highfreq.root_files)
|
|
merged.paths.highfreq.tool_code_extensions = sanitizeStringArray(merged.paths.highfreq.tool_code_extensions).map(x => x.startsWith('.') ? x.toLowerCase() : `.${x.toLowerCase()}`)
|
|
merged.paths.highfreq.data_config_extensions = sanitizeStringArray(merged.paths.highfreq.data_config_extensions).map(x => x.startsWith('.') ? x.toLowerCase() : `.${x.toLowerCase()}`)
|
|
merged.paths.highfreq.db_extensions = sanitizeStringArray(merged.paths.highfreq.db_extensions).map(x => x.startsWith('.') ? x.toLowerCase() : `.${x.toLowerCase()}`)
|
|
merged.paths.highfreq.exclude_dirs = sanitizeStringArray(merged.paths.highfreq.exclude_dirs)
|
|
merged.paths.highfreq.tool_root = String(merged.paths.highfreq.tool_root || 'public/tools').trim().replace(/\\/g, '/')
|
|
merged.paths.highfreq.db_dir = String(merged.paths.highfreq.db_dir || 'data').trim().replace(/\\/g, '/')
|
|
merged.paths.lowfreq.include_paths = sanitizeStringArray(merged.paths.lowfreq.include_paths)
|
|
merged.paths.lowfreq.exclude_dirs = sanitizeStringArray(merged.paths.lowfreq.exclude_dirs)
|
|
merged.paths.lowfreq.keep_deleted_marker = merged.paths.lowfreq.keep_deleted_marker !== false
|
|
merged.oss.enabled = merged.oss.enabled !== false
|
|
;['credential_file_name', 'access_key_id_key', 'access_key_secret_key', 'endpoint_key', 'bucket_key', 'root_prefix_key', 'bucket', 'endpoint', 'root_prefix', 'lowfreq_dir_name'].forEach(key => {
|
|
merged.oss[key] = String(merged.oss[key] || '').trim()
|
|
})
|
|
merged.retry.max_attempts = Math.max(1, parseInt(String(merged.retry.max_attempts || '3'), 10) || 3)
|
|
merged.retry.base_delay_ms = Math.max(500, parseInt(String(merged.retry.base_delay_ms || '2000'), 10) || 2000)
|
|
merged.verification.head_check = merged.verification.head_check !== false
|
|
merged.verification.lowfreq_sample_size = Math.max(1, parseInt(String(merged.verification.lowfreq_sample_size || '3'), 10) || 3)
|
|
merged.verification.restore_max_download_mb = Math.max(128, parseInt(String(merged.verification.restore_max_download_mb || '2048'), 10) || 2048)
|
|
merged.notifications.enabled = !!merged.notifications.enabled
|
|
if (!Array.isArray(merged.notifications.channels)) merged.notifications.channels = []
|
|
return merged
|
|
}
|
|
|
|
ensureConfigFile()
|
|
let runtimeConfig = sanitizeConfig(JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')))
|
|
|
|
const beijingParts = date => {
|
|
const parts = new Intl.DateTimeFormat('sv-SE', {
|
|
timeZone: 'Asia/Shanghai',
|
|
hour12: false,
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
hour: '2-digit',
|
|
minute: '2-digit',
|
|
second: '2-digit'
|
|
}).formatToParts(date || new Date())
|
|
const map = {}
|
|
parts.forEach(part => {
|
|
if (part.type && part.type !== 'literal') map[part.type] = part.value
|
|
})
|
|
return map
|
|
}
|
|
|
|
const formatBeijingDateTime = date => {
|
|
const p = beijingParts(date || new Date())
|
|
return `${p.year}-${p.month}-${p.day} ${p.hour}:${p.minute}:${p.second}`
|
|
}
|
|
|
|
const formatCompactStamp = date => {
|
|
const p = beijingParts(date || new Date())
|
|
return `${p.year}${p.month}${p.day}-${p.hour}${p.minute}${p.second}`
|
|
}
|
|
|
|
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
|
|
|
|
const makeGuid = () => crypto.randomUUID().toUpperCase()
|
|
const makeRunKey = mode => `${String(mode || 'run')}-${formatCompactStamp(new Date())}-${crypto.randomBytes(4).toString('hex')}`
|
|
|
|
const parseCronField = (field, min, max) => {
|
|
const value = String(field || '').trim()
|
|
if (!value || value === '*') return null
|
|
const set = new Set()
|
|
value.split(',').forEach(part => {
|
|
const token = String(part || '').trim()
|
|
if (!token) return
|
|
if (/^\d+$/.test(token)) {
|
|
const n = parseInt(token, 10)
|
|
if (n >= min && n <= max) set.add(n)
|
|
return
|
|
}
|
|
const stepMatch = token.match(/^\*\/(\d+)$/)
|
|
if (stepMatch) {
|
|
const step = Math.max(1, parseInt(stepMatch[1], 10) || 1)
|
|
for (let n = min; n <= max; n += step) set.add(n)
|
|
return
|
|
}
|
|
const rangeMatch = token.match(/^(\d+)-(\d+)$/)
|
|
if (rangeMatch) {
|
|
const start = parseInt(rangeMatch[1], 10)
|
|
const end = parseInt(rangeMatch[2], 10)
|
|
for (let n = start; n <= end; n += 1) {
|
|
if (n >= min && n <= max) set.add(n)
|
|
}
|
|
}
|
|
})
|
|
return set
|
|
}
|
|
|
|
const cronMatches = (expr, date) => {
|
|
const parts = String(expr || '').trim().split(/\s+/)
|
|
if (parts.length !== 5) return false
|
|
const minuteSet = parseCronField(parts[0], 0, 59)
|
|
const hourSet = parseCronField(parts[1], 0, 23)
|
|
const domSet = parseCronField(parts[2], 1, 31)
|
|
const monthSet = parseCronField(parts[3], 1, 12)
|
|
const dowSet = parseCronField(parts[4], 0, 6)
|
|
const p = beijingParts(date)
|
|
const target = new Date(`${p.year}-${p.month}-${p.day}T${p.hour}:${p.minute}:${p.second}+08:00`)
|
|
const minute = Number(p.minute)
|
|
const hour = Number(p.hour)
|
|
const dom = Number(p.day)
|
|
const month = Number(p.month)
|
|
const dow = target.getUTCDay()
|
|
if (minuteSet && !minuteSet.has(minute)) return false
|
|
if (hourSet && !hourSet.has(hour)) return false
|
|
if (domSet && !domSet.has(dom)) return false
|
|
if (monthSet && !monthSet.has(month)) return false
|
|
if (dowSet && !dowSet.has(dow)) return false
|
|
return true
|
|
}
|
|
|
|
const getNextCronTime = (expr, fromDate = new Date()) => {
|
|
const base = new Date(fromDate.getTime())
|
|
base.setSeconds(0, 0)
|
|
for (let i = 1; i <= 60 * 24 * 21; i += 1) {
|
|
const next = new Date(base.getTime() + i * 60 * 1000)
|
|
if (cronMatches(expr, next)) return formatBeijingDateTime(next)
|
|
}
|
|
return ''
|
|
}
|
|
|
|
const readLocalCreds = cfg => {
|
|
try {
|
|
const os = require('os')
|
|
const userProfile = process.env.USERPROFILE || process.env.HOME || os.homedir()
|
|
const fileName = ((cfg || {}).oss || {}).credential_file_name || 'Toolbox_local_creds.env.local'
|
|
const candidates = [path.join(userProfile, fileName)]
|
|
const usersRoot = path.join(path.parse(userProfile).root, 'Users')
|
|
try {
|
|
if (fs.existsSync(usersRoot)) {
|
|
fs.readdirSync(usersRoot).forEach(name => {
|
|
const dir = path.join(usersRoot, name)
|
|
if (dir !== userProfile && fs.existsSync(dir)) {
|
|
candidates.push(path.join(dir, fileName))
|
|
}
|
|
})
|
|
}
|
|
} catch {}
|
|
for (const candidate of candidates) {
|
|
if (!fs.existsSync(candidate)) continue
|
|
const text = fs.readFileSync(candidate, 'utf-8')
|
|
const out = { __file: candidate }
|
|
text.split(/\r?\n/).forEach(line => {
|
|
const trimmed = line.trim()
|
|
if (!trimmed || trimmed.startsWith('#')) return
|
|
const idx = trimmed.indexOf('=')
|
|
if (idx <= 0) return
|
|
out[trimmed.slice(0, idx).trim()] = trimmed.slice(idx + 1).trim()
|
|
})
|
|
return out
|
|
}
|
|
} catch {}
|
|
return {}
|
|
}
|
|
|
|
const resolveOssSettings = cfg => {
|
|
const local = readLocalCreds(cfg)
|
|
const bucket = String(cfg.oss.bucket || local[cfg.oss.bucket_key] || '').trim()
|
|
const endpoint = String(cfg.oss.endpoint || local[cfg.oss.endpoint_key] || '').trim()
|
|
const accessKeyId = String(local[cfg.oss.access_key_id_key] || '').trim()
|
|
const accessKeySecret = String(local[cfg.oss.access_key_secret_key] || '').trim()
|
|
const rootPrefix = String(cfg.oss.root_prefix || local[cfg.oss.root_prefix_key] || '').trim().replace(/^\/+|\/+$/g, '')
|
|
const lowfreqDirName = String(cfg.oss.lowfreq_dir_name || 'DPWJ780-36C4-4811-BE92-47A86DF35E10').trim().replace(/^\/+|\/+$/g, '')
|
|
return {
|
|
credential_file: local.__file || '',
|
|
bucket,
|
|
endpoint,
|
|
access_key_id: accessKeyId,
|
|
access_key_secret: accessKeySecret,
|
|
root_prefix: rootPrefix,
|
|
lowfreq_dir_name: lowfreqDirName,
|
|
ready: !!(bucket && endpoint && accessKeyId && accessKeySecret && rootPrefix && lowfreqDirName)
|
|
}
|
|
}
|
|
|
|
const currentRunState = {
|
|
run_id: 0,
|
|
run_key: '',
|
|
mode: '',
|
|
trigger_source: '',
|
|
status: 'idle',
|
|
stage: '',
|
|
message: '',
|
|
percent: 0,
|
|
started_at: '',
|
|
updated_at: '',
|
|
stats: {}
|
|
}
|
|
|
|
let currentRunPromise = null
|
|
let schedulerTimer = null
|
|
let lastSchedulerMinute = ''
|
|
|
|
const setCurrentRun = patch => {
|
|
Object.assign(currentRunState, patch || {})
|
|
currentRunState.updated_at = formatBeijingDateTime(new Date())
|
|
}
|
|
|
|
const resetCurrentRun = () => {
|
|
setCurrentRun({
|
|
run_id: 0,
|
|
run_key: '',
|
|
mode: '',
|
|
trigger_source: '',
|
|
status: 'idle',
|
|
stage: '',
|
|
message: '',
|
|
percent: 0,
|
|
started_at: '',
|
|
stats: {}
|
|
})
|
|
}
|
|
|
|
resetCurrentRun()
|
|
|
|
const recoverInterruptedRuns = () => {
|
|
try {
|
|
db.prepare(`
|
|
UPDATE backup_runs
|
|
SET status='failed',
|
|
stage='interrupted',
|
|
ended_at=?,
|
|
error_text=CASE
|
|
WHEN error_text IS NULL OR error_text='' THEN '进程中断，任务未正常结束'
|
|
ELSE error_text
|
|
END
|
|
WHERE status='running'
|
|
`).run(formatBeijingDateTime(new Date()))
|
|
} catch {}
|
|
}
|
|
recoverInterruptedRuns()
|
|
|
|
const runSummaryBase = () => ({
|
|
highfreq: {
|
|
run_guid: '',
|
|
archive_path: '',
|
|
zip_size_bytes: 0,
|
|
file_count: 0,
|
|
uploaded: false,
|
|
oss_key: '',
|
|
meta_oss_key: '',
|
|
sha256: '',
|
|
verification_ok: false
|
|
},
|
|
lowfreq: {
|
|
scanned: 0,
|
|
changed: 0,
|
|
uploaded: 0,
|
|
skipped: 0,
|
|
failed: 0,
|
|
deleted_marked: 0
|
|
},
|
|
verify: {
|
|
highfreq_head_ok: false,
|
|
sampled: 0,
|
|
passed: 0,
|
|
failed: 0,
|
|
samples: []
|
|
},
|
|
restore: {
|
|
source_run_id: 0,
|
|
source_oss_key: '',
|
|
downloaded_bytes: 0,
|
|
sha256_match: false,
|
|
manifest_present: false,
|
|
extracted_entries: [],
|
|
restore_dir: ''
|
|
}
|
|
})
|
|
|
|
const addEvent = (runId, level, eventType, message, detail) => {
|
|
const payload = {
|
|
run_id: runId,
|
|
level: String(level || 'info'),
|
|
event_type: String(eventType || ''),
|
|
message: String(message || ''),
|
|
detail_json: detail ? JSON.stringify(detail) : ''
|
|
}
|
|
insertEventStmt.run(payload)
|
|
try { logJSON(`box_backup.${eventType || 'event'}`, { run_id: runId, level, message, detail: detail || null }, 'box_backup') } catch {}
|
|
}
|
|
|
|
const addAlert = (runId, severity, title, message) => {
|
|
insertAlertStmt.run({
|
|
run_id: runId || null,
|
|
severity: String(severity || 'warning'),
|
|
title: String(title || ''),
|
|
message: String(message || '')
|
|
})
|
|
}
|
|
|
|
const relativeFromRoot = fullPath => path.relative(ROOT_DIR, fullPath).replace(/\\/g, '/')
|
|
const sanitizeOssName = value => String(value || '').trim().replace(/[^A-Za-z0-9._-]/g, '_')
|
|
const parseObjectMeta = row => {
|
|
try { return row && row.meta_json ? JSON.parse(row.meta_json) : {} } catch { return {} }
|
|
}
|
|
const getEncryptedFileInfo = row => {
|
|
const rel = String((row && row.relative_path) || '').replace(/\\/g, '/')
|
|
const sourcePath = String((row && row.source_path) || '')
|
|
if (rel.startsWith('uploads/weekly/attachments/')) {
|
|
return {
|
|
encrypted: true,
|
|
provider: 'weekly',
|
|
label: 'weekly加密附件',
|
|
encrypted_path: sourcePath || path.join(ROOT_DIR, rel)
|
|
}
|
|
}
|
|
if (rel.startsWith('uploads/ai-lib/attachments/')) {
|
|
return {
|
|
encrypted: true,
|
|
provider: 'ai-lib',
|
|
label: 'ai-lib加密附件',
|
|
encrypted_path: sourcePath || path.join(ROOT_DIR, rel)
|
|
}
|
|
}
|
|
return {
|
|
encrypted: false,
|
|
provider: '',
|
|
label: '',
|
|
encrypted_path: sourcePath || path.join(ROOT_DIR, rel)
|
|
}
|
|
}
|
|
const getLowfreqStoredName = (existing, file) => {
|
|
const meta = parseObjectMeta(existing)
|
|
const current = sanitizeOssName(meta.stored_name || '')
|
|
if (current) return current
|
|
const ext = path.extname(String(file.relativePath || file.fullPath || '')).toLowerCase()
|
|
return `${makeGuid()}${ext}`
|
|
}
|
|
const buildLowfreqOssKey = (oss, storedName) => `${oss.root_prefix}/${oss.lowfreq_dir_name}/lowfreq/${sanitizeOssName(storedName)}`
|
|
|
|
const isInsideAnyExcluded = (relPath, excludeDirs) => {
|
|
const clean = String(relPath || '').replace(/\\/g, '/')
|
|
return (excludeDirs || []).some(dir => {
|
|
const prefix = String(dir || '').trim().replace(/\\/g, '/').replace(/\/+$/, '')
|
|
return prefix && (clean === prefix || clean.startsWith(`${prefix}/`))
|
|
})
|
|
}
|
|
|
|
const walkFiles = (rootPath, options = {}) => {
|
|
const out = []
|
|
const base = path.resolve(ROOT_DIR, rootPath)
|
|
if (!fs.existsSync(base)) return out
|
|
const excludeDirs = options.excludeDirs || []
|
|
const allowedExts = options.allowedExts ? new Set(options.allowedExts.map(x => String(x).toLowerCase())) : null
|
|
const stack = [base]
|
|
while (stack.length) {
|
|
const cur = stack.pop()
|
|
let entries = []
|
|
try { entries = fs.readdirSync(cur, { withFileTypes: true }) } catch { continue }
|
|
for (const entry of entries) {
|
|
const full = path.join(cur, entry.name)
|
|
const rel = relativeFromRoot(full)
|
|
if (entry.isDirectory()) {
|
|
if (isInsideAnyExcluded(rel, excludeDirs)) continue
|
|
stack.push(full)
|
|
continue
|
|
}
|
|
if (!entry.isFile()) continue
|
|
if (isInsideAnyExcluded(rel, excludeDirs)) continue
|
|
const ext = path.extname(entry.name || '').toLowerCase()
|
|
if (allowedExts && !allowedExts.has(ext)) continue
|
|
out.push({ fullPath: full, relativePath: rel })
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
const collectHighfreqFiles = async (cfg, runId, tempRunDir) => {
|
|
const items = []
|
|
const seen = new Set()
|
|
const addFile = (fullPath, archivePath) => {
|
|
const resolved = path.resolve(fullPath)
|
|
const archiveName = String(archivePath || relativeFromRoot(fullPath)).replace(/\\/g, '/')
|
|
const key = `${resolved}>>${archiveName}`
|
|
if (seen.has(key)) return
|
|
seen.add(key)
|
|
items.push({ fullPath: resolved, archivePath: archiveName })
|
|
}
|
|
|
|
for (const relFile of cfg.paths.highfreq.root_files) {
|
|
const full = path.join(ROOT_DIR, relFile)
|
|
if (fs.existsSync(full) && fs.statSync(full).isFile()) addFile(full, relFile)
|
|
}
|
|
|
|
for (const relDir of cfg.paths.highfreq.code_paths) {
|
|
const files = walkFiles(relDir, { excludeDirs: cfg.paths.highfreq.exclude_dirs })
|
|
files.forEach(file => addFile(file.fullPath, file.relativePath))
|
|
}
|
|
|
|
const toolFiles = walkFiles(cfg.paths.highfreq.tool_root, {
|
|
excludeDirs: cfg.paths.highfreq.exclude_dirs,
|
|
allowedExts: cfg.paths.highfreq.tool_code_extensions
|
|
})
|
|
toolFiles.forEach(file => addFile(file.fullPath, file.relativePath))
|
|
|
|
const dataDir = path.join(ROOT_DIR, cfg.paths.highfreq.db_dir)
|
|
if (fs.existsSync(dataDir)) {
|
|
const topEntries = fs.readdirSync(dataDir, { withFileTypes: true })
|
|
for (const entry of topEntries) {
|
|
const full = path.join(dataDir, entry.name)
|
|
if (!entry.isFile()) continue
|
|
const ext = path.extname(entry.name || '').toLowerCase()
|
|
if (cfg.paths.highfreq.data_config_extensions.includes(ext)) addFile(full, relativeFromRoot(full))
|
|
if (!cfg.paths.highfreq.db_extensions.includes(ext)) continue
|
|
const snapshotDir = path.join(tempRunDir, 'db_snapshots')
|
|
ensureDir(snapshotDir)
|
|
const target = path.join(snapshotDir, entry.name)
|
|
try {
|
|
const sourceDb = new Database(full, { readonly: true, fileMustExist: true })
|
|
try {
|
|
await sourceDb.backup(target)
|
|
} finally {
|
|
sourceDb.close()
|
|
}
|
|
addFile(target, `data_snapshots/${entry.name}`)
|
|
addEvent(runId, 'info', 'db_snapshot', `数据库快照完成: ${entry.name}`)
|
|
} catch (error) {
|
|
addEvent(runId, 'error', 'db_snapshot_failed', `数据库快照失败: ${entry.name}`, { error: String(error && error.message ? error.message : error) })
|
|
throw error
|
|
}
|
|
}
|
|
}
|
|
|
|
return items.sort((a, b) => a.archivePath.localeCompare(b.archivePath))
|
|
}
|
|
|
|
const sha256File = filePath => new Promise((resolve, reject) => {
|
|
const hash = crypto.createHash('sha256')
|
|
const stream = fs.createReadStream(filePath)
|
|
stream.on('data', chunk => hash.update(chunk))
|
|
stream.on('error', reject)
|
|
stream.on('end', () => resolve(hash.digest('hex')))
|
|
})
|
|
|
|
const createHighfreqArchive = async (cfg, runId, tempRunDir) => {
|
|
const files = await collectHighfreqFiles(cfg, runId, tempRunDir)
|
|
const archiveName = `toolbox-highfreq-${formatCompactStamp(new Date())}.zip`
|
|
const archivePath = path.join(tempRunDir, archiveName)
|
|
const manifest = {
|
|
generated_at: formatBeijingDateTime(new Date()),
|
|
mode: 'highfreq',
|
|
files: []
|
|
}
|
|
for (const file of files) {
|
|
let stat = null
|
|
try { stat = fs.statSync(file.fullPath) } catch {}
|
|
manifest.files.push({
|
|
archive_path: file.archivePath,
|
|
source_path: relativeFromRoot(file.fullPath),
|
|
size_bytes: stat ? stat.size : 0,
|
|
mtime_ms: stat ? stat.mtimeMs : 0
|
|
})
|
|
}
|
|
await new Promise((resolve, reject) => {
|
|
const output = fs.createWriteStream(archivePath)
|
|
const archive = archiver('zip', { zlib: { level: 9 } })
|
|
output.on('close', resolve)
|
|
output.on('error', reject)
|
|
archive.on('error', reject)
|
|
archive.pipe(output)
|
|
files.forEach(file => archive.file(file.fullPath, { name: file.archivePath }))
|
|
archive.append(JSON.stringify(manifest, null, 2), { name: 'manifest.json' })
|
|
archive.finalize()
|
|
})
|
|
const sha256 = await sha256File(archivePath)
|
|
const stat = fs.statSync(archivePath)
|
|
return {
|
|
archivePath,
|
|
archiveName,
|
|
fileCount: files.length,
|
|
sizeBytes: stat.size,
|
|
sha256
|
|
}
|
|
}
|
|
|
|
const encodeOssKey = key => String(key || '').split('/').map(part => encodeURIComponent(part)).join('/')
|
|
const ossObjectUrl = (bucket, endpoint, key) => `https://${bucket}.${endpoint}/${encodeOssKey(key)}`
|
|
const ossObjectResource = (bucket, key) => `/${bucket}/${String(key || '').replace(/^\/+/, '')}`
|
|
|
|
const signOssRequest = ({ accessKeySecret, method, contentMd5 = '', contentType = '', date, resource, headers = {} }) => {
|
|
const canonicalHeaders = Object.keys(headers)
|
|
.filter(key => String(key || '').toLowerCase().startsWith('x-oss-'))
|
|
.sort((a, b) => a.localeCompare(b))
|
|
.map(key => `${String(key).toLowerCase()}:${String(headers[key] || '').trim()}\n`)
|
|
.join('')
|
|
const stringToSign = [
|
|
String(method || 'GET').toUpperCase(),
|
|
contentMd5,
|
|
contentType,
|
|
date,
|
|
`${canonicalHeaders}${resource}`
|
|
].join('\n')
|
|
return crypto.createHmac('sha1', accessKeySecret).update(stringToSign).digest('base64')
|
|
}
|
|
|
|
const headObject = async (oss, key) => {
|
|
const date = new Date().toUTCString()
|
|
const resource = ossObjectResource(oss.bucket, key)
|
|
const authorization = `OSS ${oss.access_key_id}:${signOssRequest({ accessKeySecret: oss.access_key_secret, method: 'HEAD', date, resource })}`
|
|
const response = await axios({
|
|
method: 'HEAD',
|
|
url: ossObjectUrl(oss.bucket, oss.endpoint, key),
|
|
headers: { Date: date, Authorization: authorization },
|
|
timeout: 60000,
|
|
validateStatus: status => status >= 200 && status < 300
|
|
})
|
|
return response.headers || {}
|
|
}
|
|
|
|
const uploadFileToOss = async ({ oss, localPath, ossKey, contentType }) => {
|
|
const stat = fs.statSync(localPath)
|
|
const date = new Date().toUTCString()
|
|
const resource = ossObjectResource(oss.bucket, ossKey)
|
|
const authorization = `OSS ${oss.access_key_id}:${signOssRequest({
|
|
accessKeySecret: oss.access_key_secret,
|
|
method: 'PUT',
|
|
contentType,
|
|
date,
|
|
resource
|
|
})}`
|
|
await axios({
|
|
method: 'PUT',
|
|
url: ossObjectUrl(oss.bucket, oss.endpoint, ossKey),
|
|
headers: {
|
|
Date: date,
|
|
Authorization: authorization,
|
|
'Content-Type': contentType,
|
|
'Content-Length': stat.size
|
|
},
|
|
data: fs.createReadStream(localPath),
|
|
maxBodyLength: Infinity,
|
|
maxContentLength: Infinity,
|
|
timeout: 10 * 60 * 1000,
|
|
validateStatus: status => status >= 200 && status < 300
|
|
})
|
|
return stat.size
|
|
}
|
|
|
|
const downloadObjectToFile = async ({ oss, ossKey, targetPath }) => {
|
|
ensureDir(path.dirname(targetPath))
|
|
const date = new Date().toUTCString()
|
|
const resource = ossObjectResource(oss.bucket, ossKey)
|
|
const authorization = `OSS ${oss.access_key_id}:${signOssRequest({
|
|
accessKeySecret: oss.access_key_secret,
|
|
method: 'GET',
|
|
date,
|
|
resource
|
|
})}`
|
|
const response = await axios({
|
|
method: 'GET',
|
|
url: ossObjectUrl(oss.bucket, oss.endpoint, ossKey),
|
|
headers: {
|
|
Date: date,
|
|
Authorization: authorization
|
|
},
|
|
responseType: 'stream',
|
|
timeout: 10 * 60 * 1000,
|
|
validateStatus: status => status >= 200 && status < 300
|
|
})
|
|
await new Promise((resolve, reject) => {
|
|
const stream = fs.createWriteStream(targetPath)
|
|
response.data.pipe(stream)
|
|
response.data.on('error', reject)
|
|
stream.on('error', reject)
|
|
stream.on('finish', resolve)
|
|
})
|
|
return fs.statSync(targetPath).size
|
|
}
|
|
|
|
const createOssDownloadStream = async ({ oss, ossKey }) => {
|
|
const date = new Date().toUTCString()
|
|
const resource = ossObjectResource(oss.bucket, ossKey)
|
|
const authorization = `OSS ${oss.access_key_id}:${signOssRequest({
|
|
accessKeySecret: oss.access_key_secret,
|
|
method: 'GET',
|
|
date,
|
|
resource
|
|
})}`
|
|
const response = await axios({
|
|
method: 'GET',
|
|
url: ossObjectUrl(oss.bucket, oss.endpoint, ossKey),
|
|
headers: {
|
|
Date: date,
|
|
Authorization: authorization
|
|
},
|
|
responseType: 'stream',
|
|
timeout: 10 * 60 * 1000,
|
|
validateStatus: status => status >= 200 && status < 300
|
|
})
|
|
return {
|
|
stream: response.data,
|
|
headers: response.headers || {}
|
|
}
|
|
}
|
|
|
|
const retryWrap = async (cfg, runId, type, message, workFn) => {
|
|
const maxAttempts = cfg.retry.max_attempts
|
|
const baseDelayMs = cfg.retry.base_delay_ms
|
|
let lastError = null
|
|
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
|
|
try {
|
|
if (attempt > 1) addEvent(runId, 'warning', 'retry', `${message}，第 ${attempt} 次尝试`)
|
|
return await workFn(attempt)
|
|
} catch (error) {
|
|
lastError = error
|
|
addEvent(runId, 'error', type, `${message}失败`, { attempt, error: String(error && error.message ? error.message : error) })
|
|
if (attempt < maxAttempts) await sleep(baseDelayMs * attempt)
|
|
}
|
|
}
|
|
throw lastError || new Error(`${message}失败`)
|
|
}
|
|
|
|
const upsertObjectRecord = payload => {
|
|
const data = {
|
|
backup_type: String(payload.backup_type || ''),
|
|
relative_path: String(payload.relative_path || ''),
|
|
source_path: String(payload.source_path || ''),
|
|
oss_key: String(payload.oss_key || ''),
|
|
size_bytes: parseInt(String(payload.size_bytes || '0'), 10) || 0,
|
|
mtime_ms: Math.floor(Number(payload.mtime_ms || 0)) || 0,
|
|
sha256: String(payload.sha256 || ''),
|
|
upload_status: String(payload.upload_status || 'pending'),
|
|
retry_count: parseInt(String(payload.retry_count || '0'), 10) || 0,
|
|
last_error: String(payload.last_error || ''),
|
|
last_uploaded_at: payload.last_uploaded_at ? String(payload.last_uploaded_at) : null,
|
|
is_deleted: payload.is_deleted ? 1 : 0,
|
|
deleted_at: payload.deleted_at ? String(payload.deleted_at) : null,
|
|
meta_json: payload.meta_json ? JSON.stringify(payload.meta_json) : ''
|
|
}
|
|
const existing = getObjectStmt.get(data.backup_type, data.relative_path)
|
|
if (!existing) {
|
|
upsertObjectInsertStmt.run(data)
|
|
return
|
|
}
|
|
upsertObjectUpdateStmt.run({ id: existing.id, ...data })
|
|
}
|
|
|
|
const buildLowfreqFileList = cfg => {
|
|
const files = []
|
|
const seen = new Set()
|
|
for (const relDir of cfg.paths.lowfreq.include_paths) {
|
|
walkFiles(relDir, { excludeDirs: cfg.paths.lowfreq.exclude_dirs }).forEach(file => {
|
|
const rel = file.relativePath
|
|
if (seen.has(rel)) return
|
|
seen.add(rel)
|
|
files.push(file)
|
|
})
|
|
}
|
|
return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
|
|
}
|
|
|
|
const markDeletedLowfreqObjects = (cfg, runId, liveRelativePaths) => {
|
|
const rows = db.prepare(`SELECT * FROM backup_objects WHERE backup_type='lowfreq' AND is_deleted=0`).all()
|
|
let count = 0
|
|
rows.forEach(row => {
|
|
const tracked = String(row.relative_path || '')
|
|
if (!tracked) return
|
|
const covered = cfg.paths.lowfreq.include_paths.some(prefix => tracked === prefix || tracked.startsWith(`${prefix}/`))
|
|
if (!covered) return
|
|
if (liveRelativePaths.has(tracked)) return
|
|
count += 1
|
|
upsertObjectRecord({
|
|
backup_type: 'lowfreq',
|
|
relative_path: tracked,
|
|
source_path: row.source_path || '',
|
|
oss_key: row.oss_key || '',
|
|
size_bytes: row.size_bytes || 0,
|
|
mtime_ms: row.mtime_ms || 0,
|
|
sha256: row.sha256 || '',
|
|
upload_status: row.upload_status || 'uploaded',
|
|
retry_count: row.retry_count || 0,
|
|
last_error: row.last_error || '',
|
|
last_uploaded_at: row.last_uploaded_at || null,
|
|
is_deleted: 1,
|
|
deleted_at: formatBeijingDateTime(new Date()),
|
|
meta_json: Object.assign({}, parseObjectMeta(row), { deleted_marker: true })
|
|
})
|
|
addEvent(runId, 'warning', 'deleted_marker', `本地已删除，OSS保留并标记：${tracked}`)
|
|
})
|
|
return count
|
|
}
|
|
|
|
const uploadLowfreqFile = async (cfg, oss, runId, file) => {
|
|
const stat = fs.statSync(file.fullPath)
|
|
const existing = getObjectStmt.get('lowfreq', file.relativePath)
|
|
const storedName = getLowfreqStoredName(existing, file)
|
|
const ossKey = buildLowfreqOssKey(oss, storedName)
|
|
const layoutChanged = existing && String(existing.oss_key || '') !== ossKey
|
|
const unchanged = existing &&
|
|
!layoutChanged &&
|
|
Number(existing.is_deleted || 0) === 0 &&
|
|
Number(existing.size_bytes || 0) === Number(stat.size || 0) &&
|
|
Number(existing.mtime_ms || 0) === Math.floor(Number(stat.mtimeMs || 0)) &&
|
|
String(existing.upload_status || '') === 'uploaded'
|
|
if (unchanged) {
|
|
return { changed: false, skipped: true }
|
|
}
|
|
const sha256 = await sha256File(file.fullPath)
|
|
if (existing &&
|
|
!layoutChanged &&
|
|
Number(existing.is_deleted || 0) === 0 &&
|
|
String(existing.sha256 || '') === sha256 &&
|
|
String(existing.upload_status || '') === 'uploaded') {
|
|
upsertObjectRecord({
|
|
backup_type: 'lowfreq',
|
|
relative_path: file.relativePath,
|
|
source_path: file.fullPath,
|
|
oss_key: existing.oss_key || ossKey,
|
|
size_bytes: stat.size,
|
|
mtime_ms: stat.mtimeMs,
|
|
sha256,
|
|
upload_status: 'uploaded',
|
|
retry_count: existing.retry_count || 0,
|
|
last_error: '',
|
|
last_uploaded_at: existing.last_uploaded_at || null,
|
|
is_deleted: 0,
|
|
deleted_at: null,
|
|
meta_json: {
|
|
stored_name: storedName,
|
|
storage_layout: 'guid-lowfreq-v1',
|
|
verified: false
|
|
}
|
|
})
|
|
return { changed: false, skipped: true }
|
|
}
|
|
|
|
try {
|
|
await retryWrap(cfg, runId, 'lowfreq_upload_failed', `低频对象上传 ${file.relativePath}`, async () => {
|
|
await uploadFileToOss({ oss, localPath: file.fullPath, ossKey, contentType: 'application/octet-stream' })
|
|
if (cfg.verification.head_check) {
|
|
const headers = await headObject(oss, ossKey)
|
|
const remoteSize = parseInt(String(headers['content-length'] || '0'), 10) || 0
|
|
if (remoteSize !== stat.size) throw new Error(`HEAD 校验大小不一致: ${remoteSize} != ${stat.size}`)
|
|
}
|
|
})
|
|
upsertObjectRecord({
|
|
backup_type: 'lowfreq',
|
|
relative_path: file.relativePath,
|
|
source_path: file.fullPath,
|
|
oss_key: ossKey,
|
|
size_bytes: stat.size,
|
|
mtime_ms: stat.mtimeMs,
|
|
sha256,
|
|
upload_status: 'uploaded',
|
|
retry_count: 0,
|
|
last_error: '',
|
|
last_uploaded_at: formatBeijingDateTime(new Date()),
|
|
is_deleted: 0,
|
|
deleted_at: null,
|
|
meta_json: {
|
|
stored_name: storedName,
|
|
storage_layout: 'guid-lowfreq-v1',
|
|
verified: !!cfg.verification.head_check
|
|
}
|
|
})
|
|
return { changed: true, uploaded: true }
|
|
} catch (error) {
|
|
upsertObjectRecord({
|
|
backup_type: 'lowfreq',
|
|
relative_path: file.relativePath,
|
|
source_path: file.fullPath,
|
|
oss_key: ossKey,
|
|
size_bytes: stat.size,
|
|
mtime_ms: stat.mtimeMs,
|
|
sha256,
|
|
upload_status: 'failed',
|
|
retry_count: cfg.retry.max_attempts,
|
|
last_error: String(error && error.message ? error.message : error),
|
|
last_uploaded_at: existing && existing.last_uploaded_at ? existing.last_uploaded_at : null,
|
|
is_deleted: 0,
|
|
deleted_at: null,
|
|
meta_json: {
|
|
stored_name: storedName,
|
|
storage_layout: 'guid-lowfreq-v1',
|
|
verified: false
|
|
}
|
|
})
|
|
addAlert(runId, 'warning', '低频增量备份失败', `${file.relativePath} 上传失败：${String(error && error.message ? error.message : error)}`)
|
|
return { changed: true, failed: true }
|
|
}
|
|
}
|
|
|
|
const runHighfreq = async (cfg, oss, runId, tempRunDir, summary) => {
|
|
setCurrentRun({ stage: 'highfreq_prepare', message: '正在准备高频备份', percent: 5 })
|
|
addEvent(runId, 'info', 'stage', '开始执行高频备份')
|
|
const archive = await createHighfreqArchive(cfg, runId, tempRunDir)
|
|
const runGuid = makeGuid()
|
|
const highfreqBaseKey = `${oss.root_prefix}/${runGuid}/highfreq`
|
|
const ossKey = `${highfreqBaseKey}/archive.zip`
|
|
const metaOssKey = `${highfreqBaseKey}/run_meta.json`
|
|
const metaPath = path.join(tempRunDir, 'run_meta.json')
|
|
summary.highfreq.archive_path = archive.archivePath
|
|
summary.highfreq.run_guid = runGuid
|
|
summary.highfreq.zip_size_bytes = archive.sizeBytes
|
|
summary.highfreq.file_count = archive.fileCount
|
|
summary.highfreq.sha256 = archive.sha256
|
|
addEvent(runId, 'info', 'archive_created', `高频归档完成，共 ${archive.fileCount} 个文件`)
|
|
fs.writeFileSync(metaPath, JSON.stringify({
|
|
run_guid: runGuid,
|
|
created_at: formatBeijingDateTime(new Date()),
|
|
archive_oss_key: ossKey,
|
|
archive_sha256: archive.sha256,
|
|
zip_size_bytes: archive.sizeBytes,
|
|
file_count: archive.fileCount,
|
|
source_run_id: runId,
|
|
storage_layout: 'guid-highfreq-v1'
|
|
}, null, 2))
|
|
setCurrentRun({ stage: 'highfreq_upload', message: '正在上传高频 ZIP 到 OSS', percent: 35 })
|
|
await retryWrap(cfg, runId, 'highfreq_upload_failed', '高频 ZIP 上传', async () => {
|
|
await uploadFileToOss({ oss, localPath: archive.archivePath, ossKey, contentType: 'application/zip' })
|
|
await uploadFileToOss({ oss, localPath: metaPath, ossKey: metaOssKey, contentType: 'application/json; charset=utf-8' })
|
|
if (cfg.verification.head_check) {
|
|
const headers = await headObject(oss, ossKey)
|
|
const remoteSize = parseInt(String(headers['content-length'] || '0'), 10) || 0
|
|
if (remoteSize !== archive.sizeBytes) throw new Error(`HEAD 校验大小不一致: ${remoteSize} != ${archive.sizeBytes}`)
|
|
summary.highfreq.verification_ok = true
|
|
}
|
|
})
|
|
summary.highfreq.uploaded = true
|
|
summary.highfreq.oss_key = ossKey
|
|
summary.highfreq.meta_oss_key = metaOssKey
|
|
addEvent(runId, 'info', 'highfreq_uploaded', `高频备份上传完成：${ossKey}`, { size_bytes: archive.sizeBytes, sha256: archive.sha256, run_guid: runGuid, meta_oss_key: metaOssKey })
|
|
}
|
|
|
|
const runLowfreq = async (cfg, oss, runId, summary) => {
|
|
setCurrentRun({ stage: 'lowfreq_scan', message: '正在扫描低频目录', percent: 50 })
|
|
addEvent(runId, 'info', 'stage', '开始执行低频增量备份')
|
|
const files = buildLowfreqFileList(cfg)
|
|
const liveSet = new Set(files.map(file => file.relativePath))
|
|
summary.lowfreq.scanned = files.length
|
|
let uploaded = 0
|
|
let skipped = 0
|
|
let changed = 0
|
|
let failed = 0
|
|
for (let i = 0; i < files.length; i += 1) {
|
|
const file = files[i]
|
|
const result = await uploadLowfreqFile(cfg, oss, runId, file)
|
|
if (result.changed) changed += 1
|
|
if (result.uploaded) uploaded += 1
|
|
if (result.skipped) skipped += 1
|
|
if (result.failed) failed += 1
|
|
if ((i + 1) % 10 === 0 || i === files.length - 1) {
|
|
setCurrentRun({
|
|
stage: 'lowfreq_upload',
|
|
message: `正在处理低频文件 ${i + 1}/${files.length}`,
|
|
percent: files.length ? Math.min(95, 55 + Math.floor(((i + 1) / files.length) * 40)) : 95,
|
|
stats: Object.assign({}, currentRunState.stats, {
|
|
lowfreq_total: files.length,
|
|
lowfreq_done: i + 1,
|
|
lowfreq_uploaded: uploaded,
|
|
lowfreq_skipped: skipped,
|
|
lowfreq_failed: failed
|
|
})
|
|
})
|
|
}
|
|
}
|
|
const deletedMarked = cfg.paths.lowfreq.keep_deleted_marker ? markDeletedLowfreqObjects(cfg, runId, liveSet) : 0
|
|
summary.lowfreq.changed = changed
|
|
summary.lowfreq.uploaded = uploaded
|
|
summary.lowfreq.skipped = skipped
|
|
summary.lowfreq.failed = failed
|
|
summary.lowfreq.deleted_marked = deletedMarked
|
|
addEvent(runId, failed > 0 ? 'warning' : 'info', 'lowfreq_done', `低频增量完成：上传 ${uploaded}，跳过 ${skipped}，失败 ${failed}，标记删除 ${deletedMarked}`)
|
|
}
|
|
|
|
const parseRunSummary = row => {
|
|
try { return row && row.summary_json ? JSON.parse(row.summary_json) : {} } catch { return {} }
|
|
}
|
|
|
|
const latestRunByExactMode = mode => db.prepare(`
|
|
SELECT * FROM backup_runs
|
|
WHERE mode=?
|
|
AND status <> 'running'
|
|
ORDER BY id DESC LIMIT 1
|
|
`).get(mode)
|
|
|
|
const latestSuccessfulHighfreqRun = () => {
|
|
const rows = db.prepare(`
|
|
SELECT * FROM backup_runs
|
|
WHERE mode IN ('high','all')
|
|
AND status IN ('success','partial_success')
|
|
ORDER BY id DESC
|
|
LIMIT 20
|
|
`).all()
|
|
for (const row of rows) {
|
|
const summary = parseRunSummary(row)
|
|
if (summary && summary.highfreq && summary.highfreq.uploaded && summary.highfreq.oss_key) {
|
|
return { row, summary }
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
const listLowfreqSampleCandidates = limit => db.prepare(`
|
|
SELECT * FROM backup_objects
|
|
WHERE backup_type='lowfreq'
|
|
AND upload_status='uploaded'
|
|
AND is_deleted=0
|
|
AND oss_key <> ''
|
|
ORDER BY last_uploaded_at DESC, id DESC
|
|
LIMIT ?
|
|
`).all(Math.max(1, parseInt(String(limit || '3'), 10) || 3))
|
|
|
|
const runVerify = async (cfg, oss, runId, tempRunDir, summary) => {
|
|
setCurrentRun({ stage: 'verify_prepare', message: '正在准备回读抽检', percent: 8 })
|
|
addEvent(runId, 'info', 'stage', '开始执行回读抽检')
|
|
const latestHigh = latestSuccessfulHighfreqRun()
|
|
if (latestHigh && latestHigh.summary && latestHigh.summary.highfreq && latestHigh.summary.highfreq.oss_key) {
|
|
setCurrentRun({ stage: 'verify_highfreq_head', message: '正在校验最近一次高频归档', percent: 20 })
|
|
const headers = await headObject(oss, latestHigh.summary.highfreq.oss_key)
|
|
const remoteSize = parseInt(String(headers['content-length'] || '0'), 10) || 0
|
|
const expectedSize = parseInt(String(latestHigh.summary.highfreq.zip_size_bytes || '0'), 10) || 0
|
|
if (expectedSize > 0 && remoteSize !== expectedSize) {
|
|
throw new Error(`最近高频归档 HEAD 校验失败：${remoteSize} != ${expectedSize}`)
|
|
}
|
|
summary.verify.highfreq_head_ok = true
|
|
addEvent(runId, 'info', 'verify_highfreq_head_ok', '最近一次高频归档 HEAD 校验通过', { oss_key: latestHigh.summary.highfreq.oss_key, remote_size: remoteSize })
|
|
}
|
|
|
|
const samples = listLowfreqSampleCandidates(cfg.verification.lowfreq_sample_size)
|
|
summary.verify.sampled = samples.length
|
|
for (let i = 0; i < samples.length; i += 1) {
|
|
const row = samples[i]
|
|
setCurrentRun({
|
|
stage: 'verify_lowfreq_sample',
|
|
message: `正在抽检低频对象 ${i + 1}/${samples.length}`,
|
|
percent: samples.length ? 35 + Math.floor(((i + 1) / samples.length) * 55) : 90
|
|
})
|
|
const target = path.join(tempRunDir, 'verify_samples', `${i + 1}-${path.basename(String(row.relative_path || 'sample.bin'))}`)
|
|
try {
|
|
const downloadedBytes = await retryWrap(cfg, runId, 'verify_sample_download_failed', `抽检对象下载 ${row.relative_path}`, async () => {
|
|
return await downloadObjectToFile({ oss, ossKey: row.oss_key, targetPath: target })
|
|
})
|
|
const actualHash = await sha256File(target)
|
|
const passed = !row.sha256 || actualHash === row.sha256
|
|
summary.verify.samples.push({
|
|
relative_path: row.relative_path,
|
|
oss_key: row.oss_key,
|
|
downloaded_bytes: downloadedBytes,
|
|
expected_sha256: row.sha256 || '',
|
|
actual_sha256: actualHash,
|
|
ok: passed
|
|
})
|
|
if (!passed) {
|
|
summary.verify.failed += 1
|
|
addEvent(runId, 'error', 'verify_sample_hash_mismatch', `抽检对象 hash 不一致：${row.relative_path}`)
|
|
} else {
|
|
summary.verify.passed += 1
|
|
addEvent(runId, 'info', 'verify_sample_ok', `抽检通过：${row.relative_path}`)
|
|
}
|
|
} catch (error) {
|
|
summary.verify.failed += 1
|
|
summary.verify.samples.push({
|
|
relative_path: row.relative_path,
|
|
oss_key: row.oss_key,
|
|
ok: false,
|
|
error: String(error && error.message ? error.message : error)
|
|
})
|
|
addEvent(runId, 'error', 'verify_sample_failed', `抽检失败：${row.relative_path}`, { error: String(error && error.message ? error.message : error) })
|
|
}
|
|
}
|
|
}
|
|
|
|
const runRestoreRehearsal = async (cfg, oss, runId, tempRunDir, summary) => {
|
|
setCurrentRun({ stage: 'restore_prepare', message: '正在准备恢复演练', percent: 8 })
|
|
addEvent(runId, 'info', 'stage', '开始执行恢复演练')
|
|
const latestHigh = latestSuccessfulHighfreqRun()
|
|
if (!latestHigh) throw new Error('没有可用于恢复演练的高频归档')
|
|
const high = latestHigh.summary.highfreq || {}
|
|
const expectedBytes = parseInt(String(high.zip_size_bytes || '0'), 10) || 0
|
|
const maxBytes = (parseInt(String(cfg.verification.restore_max_download_mb || '2048'), 10) || 2048) * 1024 * 1024
|
|
if (expectedBytes > maxBytes) {
|
|
throw new Error(`最近高频归档过大，超过恢复演练限制：${expectedBytes} > ${maxBytes}`)
|
|
}
|
|
|
|
summary.restore.source_run_id = latestHigh.row.id
|
|
summary.restore.source_oss_key = String(high.oss_key || '')
|
|
const downloadPath = path.join(tempRunDir, 'restore_rehearsal', path.basename(String(high.oss_key || 'archive.zip')) || 'archive.zip')
|
|
setCurrentRun({ stage: 'restore_download', message: '正在回读高频 ZIP', percent: 35 })
|
|
summary.restore.downloaded_bytes = await retryWrap(cfg, runId, 'restore_download_failed', '恢复演练回读 ZIP', async () => {
|
|
return await downloadObjectToFile({ oss, ossKey: String(high.oss_key || ''), targetPath: downloadPath })
|
|
})
|
|
setCurrentRun({ stage: 'restore_verify_hash', message: '正在校验归档 hash', percent: 65 })
|
|
const hash = await sha256File(downloadPath)
|
|
summary.restore.sha256_match = !high.sha256 || hash === high.sha256
|
|
if (!summary.restore.sha256_match) throw new Error('恢复演练失败：下载归档 hash 与原备份记录不一致')
|
|
|
|
setCurrentRun({ stage: 'restore_open_zip', message: '正在检查归档内容', percent: 82 })
|
|
const directory = await unzipper.Open.file(downloadPath)
|
|
const files = Array.isArray(directory.files) ? directory.files : []
|
|
const manifestEntry = files.find(file => String(file.path || '') === 'manifest.json')
|
|
summary.restore.manifest_present = !!manifestEntry
|
|
if (!manifestEntry) throw new Error('恢复演练失败：归档缺少 manifest.json')
|
|
|
|
const restoreDir = path.join(tempRunDir, 'restore_rehearsal', 'extracted')
|
|
ensureDir(restoreDir)
|
|
summary.restore.restore_dir = restoreDir
|
|
const sampleEntries = files.filter(file => file.type !== 'Directory').slice(0, 3)
|
|
for (const entry of sampleEntries) {
|
|
const outPath = path.join(restoreDir, String(entry.path || '').replace(/\//g, path.sep))
|
|
ensureDir(path.dirname(outPath))
|
|
await new Promise((resolve, reject) => {
|
|
entry.stream()
|
|
.pipe(fs.createWriteStream(outPath))
|
|
.on('finish', resolve)
|
|
.on('error', reject)
|
|
})
|
|
}
|
|
summary.restore.extracted_entries = sampleEntries.map(entry => String(entry.path || ''))
|
|
addEvent(runId, 'info', 'restore_rehearsal_ok', '恢复演练完成', {
|
|
source_run_id: latestHigh.row.id,
|
|
extracted_entries: summary.restore.extracted_entries
|
|
})
|
|
}
|
|
|
|
const createRun = (mode, triggerSource) => {
|
|
const runKey = makeRunKey(mode)
|
|
const info = insertRunStmt.run({
|
|
run_key: runKey,
|
|
mode,
|
|
trigger_source: triggerSource,
|
|
status: 'running',
|
|
stage: 'init',
|
|
summary_json: JSON.stringify(runSummaryBase())
|
|
})
|
|
return { id: Number(info.lastInsertRowid || 0), runKey }
|
|
}
|
|
|
|
const finishRun = (runId, status, stage, summary, errorText) => {
|
|
updateRunStmt.run({
|
|
id: runId,
|
|
status: String(status || 'done'),
|
|
stage: String(stage || ''),
|
|
ended_at: formatBeijingDateTime(new Date()),
|
|
summary_json: JSON.stringify(summary || runSummaryBase()),
|
|
error_text: errorText ? String(errorText) : ''
|
|
})
|
|
}
|
|
|
|
const cleanupTempDir = dir => {
|
|
try { fs.rmSync(dir, { recursive: true, force: true }) } catch {}
|
|
}
|
|
|
|
const executeRun = async (mode, triggerSource) => {
|
|
const run = createRun(mode, triggerSource)
|
|
const summary = runSummaryBase()
|
|
const tempRunDir = path.join(TEMP_DIR, run.runKey)
|
|
ensureDir(tempRunDir)
|
|
setCurrentRun({
|
|
run_id: run.id,
|
|
run_key: run.runKey,
|
|
mode,
|
|
trigger_source: triggerSource,
|
|
status: 'running',
|
|
stage: 'init',
|
|
message: '任务已启动',
|
|
percent: 1,
|
|
started_at: formatBeijingDateTime(new Date()),
|
|
stats: {}
|
|
})
|
|
addEvent(run.id, 'info', 'run_start', `开始执行备份：${mode} (${triggerSource})`)
|
|
try {
|
|
const cfg = runtimeConfig
|
|
const oss = resolveOssSettings(cfg)
|
|
if (!cfg.oss.enabled) throw new Error('OSS 备份未启用')
|
|
if (!oss.ready) throw new Error('OSS 凭证未就绪，请检查本地凭证文件与配置')
|
|
|
|
if (mode === 'high' || mode === 'all') await runHighfreq(cfg, oss, run.id, tempRunDir, summary)
|
|
if (mode === 'low' || mode === 'all') await runLowfreq(cfg, oss, run.id, summary)
|
|
if (mode === 'verify') await runVerify(cfg, oss, run.id, tempRunDir, summary)
|
|
if (mode === 'restore') await runRestoreRehearsal(cfg, oss, run.id, tempRunDir, summary)
|
|
|
|
let finalStatus = 'success'
|
|
if (mode === 'high' || mode === 'low' || mode === 'all') {
|
|
finalStatus = summary.lowfreq.failed > 0 ? 'partial_success' : 'success'
|
|
} else if (mode === 'verify') {
|
|
finalStatus = summary.verify.failed > 0 ? 'failed' : 'success'
|
|
} else if (mode === 'restore') {
|
|
finalStatus = (summary.restore.sha256_match && summary.restore.manifest_present) ? 'success' : 'failed'
|
|
}
|
|
finishRun(run.id, finalStatus, 'done', summary, '')
|
|
setCurrentRun({
|
|
status: finalStatus,
|
|
stage: 'done',
|
|
message: finalStatus === 'success'
|
|
? (mode === 'verify' ? '回读抽检完成' : (mode === 'restore' ? '恢复演练完成' : '备份完成'))
|
|
: (mode === 'all' || mode === 'low' || mode === 'high' ? '备份完成，存在部分失败' : '任务失败'),
|
|
percent: 100,
|
|
stats: summary
|
|
})
|
|
addEvent(run.id, finalStatus === 'success' ? 'info' : 'warning', 'run_done', `备份执行完成：${finalStatus}`)
|
|
} catch (error) {
|
|
const errText = String(error && error.message ? error.message : error)
|
|
finishRun(run.id, 'failed', 'failed', summary, errText)
|
|
setCurrentRun({
|
|
status: 'failed',
|
|
stage: 'failed',
|
|
message: errText,
|
|
percent: currentRunState.percent || 0,
|
|
stats: summary
|
|
})
|
|
addEvent(run.id, 'error', 'run_failed', `备份执行失败：${errText}`)
|
|
addAlert(run.id, 'critical', 'BOX容灾备份失败', errText)
|
|
} finally {
|
|
cleanupTempDir(tempRunDir)
|
|
setTimeout(() => {
|
|
if (currentRunState.run_id === run.id && currentRunState.status !== 'running') resetCurrentRun()
|
|
}, 15000)
|
|
}
|
|
}
|
|
|
|
const triggerRun = async (mode, triggerSource = 'manual') => {
|
|
const normalized = ['high', 'low', 'all', 'verify', 'restore'].includes(String(mode || '')) ? mode : 'all'
|
|
if (currentRunPromise) {
|
|
return {
|
|
ok: false,
|
|
busy: true,
|
|
current_run: {
|
|
run_id: currentRunState.run_id,
|
|
mode: currentRunState.mode,
|
|
stage: currentRunState.stage,
|
|
status: currentRunState.status
|
|
}
|
|
}
|
|
}
|
|
currentRunPromise = executeRun(normalized, triggerSource)
|
|
currentRunPromise.finally(() => { currentRunPromise = null })
|
|
return {
|
|
ok: true,
|
|
started: true,
|
|
mode: normalized,
|
|
run_id: currentRunState.run_id,
|
|
run_key: currentRunState.run_key
|
|
}
|
|
}
|
|
|
|
const latestRunByMode = mode => db.prepare(`
|
|
SELECT * FROM backup_runs
|
|
WHERE mode IN (${mode === 'high' ? `'high','all'` : `'low','all'`})
|
|
AND status <> 'running'
|
|
ORDER BY id DESC LIMIT 1
|
|
`).get()
|
|
|
|
const latestRunStatus = mode => {
|
|
const row = latestRunByExactMode(mode)
|
|
if (!row) return null
|
|
return {
|
|
last_run_at: row.ended_at || row.started_at || '',
|
|
last_status: row.status,
|
|
stage: row.stage || '',
|
|
error_text: row.error_text || '',
|
|
summary: parseRunSummary(row)
|
|
}
|
|
}
|
|
|
|
const latestManualRecord = type => db.prepare(`
|
|
SELECT * FROM backup_manual_records WHERE record_type=? ORDER BY id DESC LIMIT 1
|
|
`).get(type)
|
|
|
|
const getOverview = () => {
|
|
const cfg = runtimeConfig
|
|
const oss = resolveOssSettings(cfg)
|
|
const high = latestRunByMode('high')
|
|
const low = latestRunByMode('low')
|
|
const verify = latestRunStatus('verify')
|
|
const restore = latestRunStatus('restore')
|
|
const manual = latestManualRecord('baidu_manual')
|
|
return {
|
|
ok: true,
|
|
current_run: clone(currentRunState),
|
|
scheduler: {
|
|
enabled: !!cfg.scheduler.enabled,
|
|
highfreq_cron: cfg.scheduler.highfreq_cron,
|
|
lowfreq_cron: cfg.scheduler.lowfreq_cron,
|
|
next_highfreq_at: getNextCronTime(cfg.scheduler.highfreq_cron),
|
|
next_lowfreq_at: getNextCronTime(cfg.scheduler.lowfreq_cron)
|
|
},
|
|
highfreq: high ? {
|
|
last_run_at: high.ended_at || high.started_at || '',
|
|
last_status: high.status,
|
|
stage: high.stage || '',
|
|
error_text: high.error_text || ''
|
|
} : null,
|
|
lowfreq: low ? {
|
|
last_run_at: low.ended_at || low.started_at || '',
|
|
last_status: low.status,
|
|
stage: low.stage || '',
|
|
error_text: low.error_text || ''
|
|
} : null,
|
|
verify,
|
|
restore,
|
|
manual_baidu_backup: manual ? {
|
|
last_recorded_at: manual.created_at || '',
|
|
note: manual.note || ''
|
|
} : null,
|
|
alerts_open_count: db.prepare(`SELECT COUNT(1) AS c FROM backup_alerts WHERE status='open'`).get().c || 0,
|
|
oss_ready: oss.ready,
|
|
credential_file: oss.credential_file || ''
|
|
}
|
|
}
|
|
|
|
const listRuns = limit => {
|
|
const rows = db.prepare(`
|
|
SELECT id, run_key, mode, trigger_source, status, stage, started_at, ended_at, error_text, summary_json
|
|
FROM backup_runs
|
|
ORDER BY id DESC
|
|
LIMIT ?
|
|
`).all(Math.max(1, parseInt(String(limit || '50'), 10) || 50))
|
|
return rows.map(row => ({
|
|
...row,
|
|
summary: (() => {
|
|
try { return row.summary_json ? JSON.parse(row.summary_json) : {} } catch { return {} }
|
|
})()
|
|
}))
|
|
}
|
|
|
|
const listEvents = ({ limit = 200, failuresOnly = false } = {}) => {
|
|
let sql = `
|
|
SELECT e.id, e.run_id, e.level, e.event_type, e.message, e.detail_json, e.created_at,
|
|
r.mode, r.trigger_source
|
|
FROM backup_run_events e
|
|
LEFT JOIN backup_runs r ON r.id = e.run_id
|
|
`
|
|
const args = []
|
|
if (failuresOnly) sql += ` WHERE e.level='error' OR e.event_type IN ('retry','run_failed','highfreq_upload_failed','lowfreq_upload_failed') `
|
|
sql += ` ORDER BY e.id DESC LIMIT ? `
|
|
args.push(Math.max(1, parseInt(String(limit || '200'), 10) || 200))
|
|
return db.prepare(sql).all(...args).map(row => ({
|
|
...row,
|
|
detail: (() => {
|
|
try { return row.detail_json ? JSON.parse(row.detail_json) : null } catch { return null }
|
|
})()
|
|
}))
|
|
}
|
|
|
|
const listAlerts = limit => db.prepare(`
|
|
SELECT id, run_id, severity, title, message, status, created_at
|
|
FROM backup_alerts
|
|
ORDER BY id DESC
|
|
LIMIT ?
|
|
`).all(Math.max(1, parseInt(String(limit || '100'), 10) || 100))
|
|
|
|
const listLowfreqObjects = ({ limit = 200, status = '' } = {}) => {
|
|
let sql = `
|
|
SELECT id, backup_type, relative_path, source_path, oss_key, size_bytes, mtime_ms, sha256,
|
|
upload_status, retry_count, last_error, last_uploaded_at, is_deleted, deleted_at, meta_json
|
|
FROM backup_objects
|
|
WHERE backup_type='lowfreq'
|
|
`
|
|
const args = []
|
|
const normalizedStatus = String(status || '').trim()
|
|
if (normalizedStatus) {
|
|
sql += ` AND upload_status=? `
|
|
args.push(normalizedStatus)
|
|
}
|
|
sql += ` ORDER BY id DESC LIMIT ? `
|
|
args.push(Math.max(1, parseInt(String(limit || '200'), 10) || 200))
|
|
return db.prepare(sql).all(...args).map(row => ({
|
|
...row,
|
|
meta: parseObjectMeta(row),
|
|
encryption: getEncryptedFileInfo(row)
|
|
}))
|
|
}
|
|
|
|
const listHighfreqCatalog = limit => {
|
|
const rows = db.prepare(`
|
|
SELECT id, run_key, mode, trigger_source, status, stage, started_at, ended_at, error_text, summary_json
|
|
FROM backup_runs
|
|
WHERE mode IN ('high', 'all')
|
|
ORDER BY id DESC
|
|
LIMIT ?
|
|
`).all(Math.max(1, parseInt(String(limit || '50'), 10) || 50))
|
|
return rows
|
|
.map(row => ({ row, summary: parseRunSummary(row) }))
|
|
.filter(item => item.summary && item.summary.highfreq && item.summary.highfreq.oss_key)
|
|
.map(item => ({
|
|
id: item.row.id,
|
|
run_key: item.row.run_key,
|
|
mode: item.row.mode,
|
|
trigger_source: item.row.trigger_source,
|
|
status: item.row.status,
|
|
stage: item.row.stage,
|
|
started_at: item.row.started_at,
|
|
ended_at: item.row.ended_at,
|
|
error_text: item.row.error_text || '',
|
|
highfreq: item.summary.highfreq || {}
|
|
}))
|
|
}
|
|
|
|
const getBackupCatalog = ({ runLimit = 30, objectLimit = 200, status = '' } = {}) => ({
|
|
ok: true,
|
|
highfreq_runs: listHighfreqCatalog(runLimit),
|
|
lowfreq_objects: listLowfreqObjects({ limit: objectLimit, status })
|
|
})
|
|
|
|
const createHighfreqDownload = async runId => {
|
|
const row = db.prepare(`SELECT * FROM backup_runs WHERE id=?`).get(parseInt(String(runId || '0'), 10) || 0)
|
|
if (!row) throw new Error('not_found')
|
|
const summary = parseRunSummary(row)
|
|
const high = summary.highfreq || {}
|
|
const ossKey = String(high.oss_key || '').trim()
|
|
if (!ossKey) throw new Error('highfreq_missing')
|
|
const oss = resolveOssSettings(runtimeConfig)
|
|
if (!oss.ready) throw new Error('oss_not_ready')
|
|
const streamResult = await createOssDownloadStream({ oss, ossKey })
|
|
const baseName = sanitizeOssName(`box_backup_highfreq_${high.run_guid || row.id}.zip`) || `box_backup_highfreq_${row.id}.zip`
|
|
return {
|
|
file_name: baseName,
|
|
content_type: 'application/zip',
|
|
content_length: streamResult.headers['content-length'] || '',
|
|
oss_key: ossKey,
|
|
stream: streamResult.stream
|
|
}
|
|
}
|
|
|
|
const createLowfreqDownload = async objectId => {
|
|
const row = db.prepare(`SELECT * FROM backup_objects WHERE id=? AND backup_type='lowfreq'`).get(parseInt(String(objectId || '0'), 10) || 0)
|
|
if (!row) throw new Error('not_found')
|
|
if (String(row.upload_status || '') !== 'uploaded') throw new Error('lowfreq_not_ready')
|
|
const ossKey = String(row.oss_key || '').trim()
|
|
if (!ossKey) throw new Error('lowfreq_missing')
|
|
const oss = resolveOssSettings(runtimeConfig)
|
|
if (!oss.ready) throw new Error('oss_not_ready')
|
|
const streamResult = await createOssDownloadStream({ oss, ossKey })
|
|
const meta = parseObjectMeta(row)
|
|
const originalName = path.basename(String(row.relative_path || 'backup.bin')) || 'backup.bin'
|
|
const fallbackName = sanitizeOssName(meta.stored_name || originalName) || 'backup.bin'
|
|
return {
|
|
file_name: originalName || fallbackName,
|
|
content_type: streamResult.headers['content-type'] || 'application/octet-stream',
|
|
content_length: streamResult.headers['content-length'] || '',
|
|
oss_key: ossKey,
|
|
stream: streamResult.stream
|
|
}
|
|
}
|
|
|
|
const createLowfreqDecryptedDownload = async objectId => {
|
|
const row = db.prepare(`SELECT * FROM backup_objects WHERE id=? AND backup_type='lowfreq'`).get(parseInt(String(objectId || '0'), 10) || 0)
|
|
if (!row) throw new Error('not_found')
|
|
const encryption = getEncryptedFileInfo(row)
|
|
if (!encryption.encrypted) throw new Error('decrypt_not_supported')
|
|
if (String(row.upload_status || '') !== 'uploaded') throw new Error('lowfreq_not_ready')
|
|
const ossKey = String(row.oss_key || '').trim()
|
|
if (!ossKey) throw new Error('lowfreq_missing')
|
|
const oss = resolveOssSettings(runtimeConfig)
|
|
if (!oss.ready) throw new Error('oss_not_ready')
|
|
const streamResult = await createOssDownloadStream({ oss, ossKey })
|
|
const encryptedBuffer = await streamToBuffer(streamResult.stream)
|
|
let payload = null
|
|
if (encryption.provider === 'weekly') {
|
|
payload = weeklyCore.getAttachmentDataByStoredPath(encryption.encrypted_path, encryptedBuffer)
|
|
} else if (encryption.provider === 'ai-lib') {
|
|
payload = aiLib.getAttachmentDataByStoredPath(encryption.encrypted_path, encryptedBuffer)
|
|
}
|
|
if (!payload || !payload.data) throw new Error('decrypt_source_not_found')
|
|
return {
|
|
file_name: String(payload.filename || path.basename(String(row.relative_path || 'file.bin')) || 'file.bin'),
|
|
content_type: String(payload.mime || 'application/octet-stream'),
|
|
content_length: Buffer.byteLength(payload.data),
|
|
data: payload.data,
|
|
provider: encryption.provider,
|
|
encrypted_label: encryption.label
|
|
}
|
|
}
|
|
|
|
const getConfig = () => {
|
|
const oss = resolveOssSettings(runtimeConfig)
|
|
return {
|
|
ok: true,
|
|
config: clone(runtimeConfig),
|
|
credential_status: {
|
|
ready: oss.ready,
|
|
credential_file: oss.credential_file || '',
|
|
bucket: oss.bucket || '',
|
|
endpoint: oss.endpoint || '',
|
|
root_prefix: oss.root_prefix || '',
|
|
lowfreq_dir_name: oss.lowfreq_dir_name || ''
|
|
}
|
|
}
|
|
}
|
|
|
|
const saveConfig = nextConfig => {
|
|
const sanitized = sanitizeConfig(nextConfig)
|
|
const resolvedOss = resolveOssSettings(sanitized)
|
|
if (!sanitized.scheduler.highfreq_cron || !sanitized.scheduler.lowfreq_cron) throw new Error('cron 不能为空')
|
|
if (!resolvedOss.root_prefix) throw new Error('OSS 根目录不能为空')
|
|
if (!resolvedOss.lowfreq_dir_name) throw new Error('低频固定目录不能为空')
|
|
fs.writeFileSync(CONFIG_PATH, JSON.stringify(sanitized, null, 2))
|
|
runtimeConfig = sanitized
|
|
insertConfigHistoryStmt.run(JSON.stringify(sanitized))
|
|
restartScheduler()
|
|
return getConfig()
|
|
}
|
|
|
|
const recordManualBaiduBackup = note => {
|
|
insertManualRecordStmt.run('baidu_manual', String(note || '').trim())
|
|
return latestManualRecord('baidu_manual')
|
|
}
|
|
|
|
const getCurrentRun = () => ({
|
|
ok: true,
|
|
run: clone(currentRunState)
|
|
})
|
|
|
|
const schedulerTick = async () => {
|
|
if (!runtimeConfig.scheduler.enabled) return
|
|
if (currentRunPromise) return
|
|
const now = new Date()
|
|
const p = beijingParts(now)
|
|
const minuteKey = `${p.year}-${p.month}-${p.day} ${p.hour}:${p.minute}`
|
|
if (minuteKey === lastSchedulerMinute) return
|
|
lastSchedulerMinute = minuteKey
|
|
const dueHigh = cronMatches(runtimeConfig.scheduler.highfreq_cron, now)
|
|
const dueLow = cronMatches(runtimeConfig.scheduler.lowfreq_cron, now)
|
|
if (!dueHigh && !dueLow) return
|
|
const mode = dueHigh && dueLow ? 'all' : (dueHigh ? 'high' : 'low')
|
|
await triggerRun(mode, 'cron')
|
|
}
|
|
|
|
function restartScheduler () {
|
|
if (schedulerTimer) {
|
|
clearInterval(schedulerTimer)
|
|
schedulerTimer = null
|
|
}
|
|
if (String(process.env.PORT || '') !== '8977') return
|
|
const pollMs = Math.max(10000, runtimeConfig.scheduler.poll_seconds * 1000)
|
|
schedulerTimer = setInterval(() => {
|
|
schedulerTick().catch(error => {
|
|
try { logJSON('box_backup.scheduler.error', { error: String(error && error.message ? error.message : error) }, 'box_backup') } catch {}
|
|
})
|
|
}, pollMs)
|
|
setTimeout(() => {
|
|
schedulerTick().catch(() => {})
|
|
}, 3000)
|
|
}
|
|
|
|
restartScheduler()
|
|
|
|
module.exports = {
|
|
getOverview,
|
|
getCurrentRun,
|
|
getConfig,
|
|
saveConfig,
|
|
listRuns,
|
|
listEvents,
|
|
listAlerts,
|
|
getBackupCatalog,
|
|
createHighfreqDownload,
|
|
createLowfreqDownload,
|
|
createLowfreqDecryptedDownload,
|
|
triggerRun,
|
|
recordManualBaiduBackup
|
|
}
|