1520 lines
44 KiB
JavaScript
1520 lines
44 KiB
JavaScript
/**
|
|
* 数据备份与恢复工具模块
|
|
* 支持完整备份所有数据库表和上传文件
|
|
*/
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const crypto = require('crypto');
|
|
const zlib = require('zlib');
|
|
const { pipeline } = require('stream/promises');
|
|
const { sequelize, dbDialect } = require('../db');
|
|
const logger = require('./logger').module('Backup');
|
|
const { enableMaintenanceMode, disableMaintenanceMode } = require('./maintenanceMode');
|
|
|
|
const BACKUP_VERSION = '2.0.0';
|
|
|
|
const BATCH_SIZE = 500;
|
|
|
|
/**
|
|
* 还原点管理
|
|
* 恢复前自动创建当前数据的临时备份，用于中断或失败时回滚
|
|
*/
|
|
const SNAPSHOT_DIR = path.join(__dirname, '..', 'backups', '.snapshots');
|
|
|
|
/**
|
|
* 确保还原点目录存在
|
|
*/
|
|
function ensureSnapshotDir() {
|
|
if (!fs.existsSync(SNAPSHOT_DIR)) {
|
|
fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
|
|
}
|
|
return SNAPSHOT_DIR;
|
|
}
|
|
|
|
/**
|
|
* 生成还原点文件名
|
|
*/
|
|
function getSnapshotFileName(snapshotId) {
|
|
return path.join(SNAPSHOT_DIR, `snapshot_${snapshotId}.json.gz`);
|
|
}
|
|
|
|
/**
|
|
* 创建还原点（恢复前自动调用）
|
|
* 备份当前数据库所有表的数据
|
|
* @returns {Promise<string|null>} 还原点ID，失败返回null
|
|
*/
|
|
async function createSnapshot() {
|
|
try {
|
|
ensureSnapshotDir();
|
|
const snapshotId = `pre_restore_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
|
|
const snapshotPath = getSnapshotFileName(snapshotId);
|
|
|
|
logger.info('创建还原点...', { snapshotId });
|
|
|
|
// 收集当前所有表的数据
|
|
const snapshotData = {
|
|
version: BACKUP_VERSION,
|
|
timestamp: new Date().toISOString(),
|
|
type: 'snapshot',
|
|
data: {},
|
|
files: null,
|
|
};
|
|
|
|
for (const config of BACKUP_MODELS_CONFIG) {
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
const records = await Model.findAll({ raw: true });
|
|
if (records.length > 0) {
|
|
snapshotData.data[config.name] = records;
|
|
}
|
|
} catch (error) {
|
|
logger.warn(`创建还原点时跳过表 ${config.name}`, { error: error.message });
|
|
}
|
|
}
|
|
|
|
// 压缩并保存
|
|
const jsonStr = JSON.stringify(snapshotData);
|
|
const compressed = zlib.gzipSync(Buffer.from(jsonStr, 'utf8'));
|
|
fs.writeFileSync(snapshotPath, compressed);
|
|
|
|
logger.info('还原点创建成功', { snapshotId, path: snapshotPath, tables: Object.keys(snapshotData.data).length });
|
|
return snapshotId;
|
|
} catch (error) {
|
|
logger.error('创建还原点失败', { error: error.message, stack: error.stack });
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 从还原点恢复数据
|
|
* 当恢复过程被中断或失败时调用，回滚到恢复前的状态
|
|
* @param {string} snapshotId - 还原点ID
|
|
* @returns {Promise<boolean>} 是否成功回滚
|
|
*/
|
|
async function restoreFromSnapshot(snapshotId) {
|
|
const snapshotPath = getSnapshotFileName(snapshotId);
|
|
|
|
if (!fs.existsSync(snapshotPath)) {
|
|
logger.error('还原点不存在，无法回滚', { snapshotId });
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
logger.info('开始从还原点回滚数据...', { snapshotId });
|
|
|
|
// 读取还原点数据
|
|
const compressed = fs.readFileSync(snapshotPath);
|
|
const decompressed = zlib.gunzipSync(compressed);
|
|
const snapshotData = JSON.parse(decompressed.toString('utf8'));
|
|
|
|
if (!snapshotData.data) {
|
|
logger.error('还原点数据无效');
|
|
return false;
|
|
}
|
|
|
|
await disableForeignKeyChecks();
|
|
|
|
try {
|
|
// 清空所有表（按恢复顺序的逆序，避免外键冲突）
|
|
const clearOrder = [...RESTORE_ORDER].reverse();
|
|
for (const tableName of clearOrder) {
|
|
const config = BACKUP_MODELS_CONFIG.find(c => c.name === tableName);
|
|
if (!config) continue;
|
|
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
await Model.destroy({ where: {}, truncate: true });
|
|
} catch (error) {
|
|
logger.warn(`回滚时清空表 ${tableName} 失败`, { error: error.message });
|
|
}
|
|
}
|
|
|
|
// 从还原点恢复数据
|
|
let restoredCount = 0;
|
|
for (const tableName of RESTORE_ORDER) {
|
|
const tableData = snapshotData.data[tableName];
|
|
if (!tableData || tableData.length === 0) continue;
|
|
|
|
const config = BACKUP_MODELS_CONFIG.find(c => c.name === tableName);
|
|
if (!config) continue;
|
|
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
|
|
for (let i = 0; i < tableData.length; i += BATCH_SIZE) {
|
|
const batch = tableData.slice(i, i + BATCH_SIZE);
|
|
try {
|
|
await Model.bulkCreate(batch, {
|
|
validate: false,
|
|
individualHooks: false,
|
|
logging: false,
|
|
});
|
|
restoredCount += batch.length;
|
|
} catch (bulkError) {
|
|
for (const record of batch) {
|
|
try {
|
|
await Model.create(record, { validate: false, silent: true });
|
|
restoredCount++;
|
|
} catch (insertError) {
|
|
logger.warn(`回滚时插入 ${tableName} 记录失败`, { error: insertError.message });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logger.error(`回滚表 ${tableName} 失败`, { error: error.message });
|
|
}
|
|
}
|
|
|
|
logger.info('还原点回滚完成', { restoredCount });
|
|
return true;
|
|
} finally {
|
|
await enableForeignKeyChecks();
|
|
}
|
|
} catch (error) {
|
|
logger.error('从还原点回滚失败', { error: error.message, stack: error.stack });
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 删除还原点
|
|
* @param {string} snapshotId - 还原点ID
|
|
*/
|
|
function deleteSnapshot(snapshotId) {
|
|
const snapshotPath = getSnapshotFileName(snapshotId);
|
|
if (fs.existsSync(snapshotPath)) {
|
|
try {
|
|
fs.unlinkSync(snapshotPath);
|
|
logger.info('还原点已删除', { snapshotId });
|
|
} catch (error) {
|
|
logger.warn('删除还原点失败', { snapshotId, error: error.message });
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 清理过期的还原点（保留最近7天）
|
|
*/
|
|
function cleanupOldSnapshots() {
|
|
try {
|
|
if (!fs.existsSync(SNAPSHOT_DIR)) return;
|
|
|
|
const now = Date.now();
|
|
const maxAgeMs = 7 * 24 * 60 * 60 * 1000; // 7天
|
|
|
|
const files = fs.readdirSync(SNAPSHOT_DIR);
|
|
let deletedCount = 0;
|
|
|
|
for (const file of files) {
|
|
if (!file.startsWith('snapshot_pre_restore_')) continue;
|
|
|
|
const filePath = path.join(SNAPSHOT_DIR, file);
|
|
const stat = fs.statSync(filePath);
|
|
const age = now - stat.mtimeMs;
|
|
|
|
if (age > maxAgeMs) {
|
|
fs.unlinkSync(filePath);
|
|
deletedCount++;
|
|
}
|
|
}
|
|
|
|
if (deletedCount > 0) {
|
|
logger.info('清理过期还原点', { deletedCount });
|
|
}
|
|
} catch (error) {
|
|
logger.warn('清理过期还原点失败', { error: error.message });
|
|
}
|
|
}
|
|
|
|
async function disableForeignKeyChecks() {
|
|
if (dbDialect === 'sqlite') {
|
|
await sequelize.query('PRAGMA foreign_keys = OFF');
|
|
} else if (dbDialect === 'mysql') {
|
|
await sequelize.query('SET FOREIGN_KEY_CHECKS = 0');
|
|
}
|
|
}
|
|
|
|
async function enableForeignKeyChecks() {
|
|
if (dbDialect === 'sqlite') {
|
|
await sequelize.query('PRAGMA foreign_keys = ON');
|
|
} else if (dbDialect === 'mysql') {
|
|
await sequelize.query('SET FOREIGN_KEY_CHECKS = 1');
|
|
}
|
|
}
|
|
|
|
// 数据表名称中英文映射
|
|
const TABLE_NAME_MAPPING = {
|
|
User: '用户',
|
|
Role: '角色',
|
|
UserRole: '用户角色关联',
|
|
Permission: '权限',
|
|
Room: '机房',
|
|
Rack: '机柜',
|
|
Device: '设备',
|
|
DeviceField: '设备自定义字段',
|
|
DevicePort: '设备端口',
|
|
NetworkCard: '网卡',
|
|
Cable: '线缆',
|
|
PendingDevice: '待入库设备',
|
|
FaultCategory: '故障分类',
|
|
Ticket: '工单',
|
|
TicketField: '工单自定义字段',
|
|
TicketOperationRecord: '工单操作记录',
|
|
ConsumableCategory: '耗材分类',
|
|
Consumable: '耗材',
|
|
ConsumableRecord: '耗材记录',
|
|
ConsumableLog: '耗材操作日志',
|
|
ConsumableLogArchive: '耗材操作日志归档',
|
|
InventoryPlan: '盘点计划',
|
|
InventoryTask: '盘点任务',
|
|
InventoryRecord: '盘点记录',
|
|
SystemSetting: '系统设置',
|
|
};
|
|
|
|
// 增量备份配置
|
|
const INCREMENTAL_BACKUP_CONFIG = {
|
|
// 哪些表支持增量备份（需要有 updatedAt 或 createdAt 字段）
|
|
supportedTables: [
|
|
'Device',
|
|
'Ticket',
|
|
'TicketOperationRecord',
|
|
'Consumable',
|
|
'ConsumableRecord',
|
|
'ConsumableLog',
|
|
'InventoryTask',
|
|
'InventoryRecord',
|
|
],
|
|
// 必须全量备份的表
|
|
fullBackupTables: [
|
|
'User',
|
|
'Role',
|
|
'UserRole',
|
|
'Permission',
|
|
'Room',
|
|
'Rack',
|
|
'DeviceField',
|
|
'DevicePort',
|
|
'NetworkCard',
|
|
'Cable',
|
|
'PendingDevice',
|
|
'FaultCategory',
|
|
'TicketField',
|
|
'ConsumableCategory',
|
|
'ConsumableLogArchive',
|
|
'InventoryPlan',
|
|
'SystemSetting',
|
|
],
|
|
};
|
|
|
|
const BACKUP_MODELS_CONFIG = [
|
|
{ name: 'User', modelPath: '../models/User' },
|
|
{ name: 'Role', modelPath: '../models/Role' },
|
|
{ name: 'UserRole', modelPath: '../models/UserRole' },
|
|
{ name: 'Permission', modelPath: '../models/Permission' },
|
|
{ name: 'Room', modelPath: '../models/Room' },
|
|
{ name: 'Rack', modelPath: '../models/Rack' },
|
|
{ name: 'Device', modelPath: '../models/Device' },
|
|
{ name: 'DeviceField', modelPath: '../models/DeviceField' },
|
|
{ name: 'DevicePort', modelPath: '../models/DevicePort' },
|
|
{ name: 'NetworkCard', modelPath: '../models/NetworkCard' },
|
|
{ name: 'Cable', modelPath: '../models/Cable' },
|
|
{ name: 'PendingDevice', modelPath: '../models/PendingDevice' },
|
|
{ name: 'FaultCategory', modelPath: '../models/FaultCategory' },
|
|
{ name: 'Ticket', modelPath: '../models/Ticket' },
|
|
{ name: 'TicketField', modelPath: '../models/TicketField' },
|
|
{ name: 'TicketOperationRecord', modelPath: '../models/TicketOperationRecord' },
|
|
{ name: 'ConsumableCategory', modelPath: '../models/ConsumableCategory' },
|
|
{ name: 'Consumable', modelPath: '../models/Consumable' },
|
|
{ name: 'ConsumableRecord', modelPath: '../models/ConsumableRecord' },
|
|
{ name: 'ConsumableLog', modelPath: '../models/ConsumableLog' },
|
|
{ name: 'ConsumableLogArchive', modelPath: '../models/ConsumableLogArchive' },
|
|
{ name: 'InventoryPlan', modelPath: '../models/InventoryPlan' },
|
|
{ name: 'InventoryTask', modelPath: '../models/InventoryTask' },
|
|
{ name: 'InventoryRecord', modelPath: '../models/InventoryRecord' },
|
|
{ name: 'SystemSetting', modelPath: '../models/SystemSetting' },
|
|
];
|
|
|
|
const RESTORE_ORDER = [
|
|
'SystemSetting',
|
|
'Role',
|
|
'User',
|
|
'UserRole',
|
|
'Permission',
|
|
'Room',
|
|
'Rack',
|
|
'DeviceField',
|
|
'Device',
|
|
'DevicePort',
|
|
'NetworkCard',
|
|
'Cable',
|
|
'PendingDevice',
|
|
'FaultCategory',
|
|
'TicketField',
|
|
'Ticket',
|
|
'TicketOperationRecord',
|
|
'ConsumableCategory',
|
|
'Consumable',
|
|
'ConsumableRecord',
|
|
'ConsumableLog',
|
|
'ConsumableLogArchive',
|
|
'InventoryPlan',
|
|
'InventoryTask',
|
|
'InventoryRecord',
|
|
];
|
|
|
|
function getBackupPath() {
|
|
const backupDir = path.join(__dirname, '..', 'backups');
|
|
if (!fs.existsSync(backupDir)) {
|
|
fs.mkdirSync(backupDir, { recursive: true });
|
|
}
|
|
return backupDir;
|
|
}
|
|
|
|
/**
|
|
* 获取上次备份的时间
|
|
*/
|
|
function getLastBackupTime() {
|
|
const backupDir = getBackupPath();
|
|
const files = fs
|
|
.readdirSync(backupDir)
|
|
.filter(
|
|
f =>
|
|
(f.startsWith('backup_') || f.startsWith('incremental_')) &&
|
|
(f.endsWith('.json') || f.endsWith('.json.gz'))
|
|
)
|
|
.map(f => {
|
|
const filePath = path.join(backupDir, f);
|
|
return {
|
|
filename: f,
|
|
createdAt: fs.statSync(filePath).birthtime,
|
|
};
|
|
})
|
|
.sort((a, b) => b.createdAt - a.createdAt);
|
|
|
|
if (files.length > 0) {
|
|
return files[0].createdAt;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* 收集增量数据（只收集自上次备份以来变化的数据）
|
|
*/
|
|
async function collectIncrementalData(lastBackupTime) {
|
|
const incrementalData = {};
|
|
let totalNewRecords = 0;
|
|
let totalUpdatedRecords = 0;
|
|
|
|
for (const config of BACKUP_MODELS_CONFIG) {
|
|
if (!INCREMENTAL_BACKUP_CONFIG.supportedTables.includes(config.name)) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
|
|
// 查询自上次备份以来新增或更新的记录
|
|
const newRecords = await Model.findAll({
|
|
where: {
|
|
createdAt: {
|
|
[require('sequelize').Op.gt]: lastBackupTime,
|
|
},
|
|
},
|
|
});
|
|
|
|
const updatedRecords = await Model.findAll({
|
|
where: {
|
|
updatedAt: {
|
|
[require('sequelize').Op.gt]: lastBackupTime,
|
|
},
|
|
createdAt: {
|
|
[require('sequelize').Op.lte]: lastBackupTime,
|
|
},
|
|
},
|
|
});
|
|
|
|
if (newRecords.length > 0 || updatedRecords.length > 0) {
|
|
incrementalData[config.name] = {
|
|
new: newRecords.map(r => r.toJSON()),
|
|
updated: updatedRecords.map(r => r.toJSON()),
|
|
deleted: [], // 删除的记录需要特殊处理，暂时不支持
|
|
};
|
|
totalNewRecords += newRecords.length;
|
|
totalUpdatedRecords += updatedRecords.length;
|
|
}
|
|
} catch (error) {
|
|
console.warn(`收集表 ${config.name} 的增量数据失败:`, error.message);
|
|
}
|
|
}
|
|
|
|
return {
|
|
data: incrementalData,
|
|
totalNewRecords,
|
|
totalUpdatedRecords,
|
|
totalChangedRecords: totalNewRecords + totalUpdatedRecords,
|
|
};
|
|
}
|
|
|
|
function ensureBackupDir(backupPath) {
|
|
if (!fs.existsSync(backupPath)) {
|
|
fs.mkdirSync(backupPath, { recursive: true });
|
|
}
|
|
}
|
|
|
|
async function collectAllData(tableNames = null) {
|
|
const data = {};
|
|
let totalRecords = 0;
|
|
|
|
const configsToProcess = tableNames
|
|
? BACKUP_MODELS_CONFIG.filter(c => tableNames.includes(c.name))
|
|
: BACKUP_MODELS_CONFIG;
|
|
|
|
for (const config of configsToProcess) {
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
const records = await Model.findAll({ raw: true });
|
|
data[config.name] = records;
|
|
totalRecords += records.length;
|
|
console.log(`收集 ${config.name}: ${records.length} 条记录`);
|
|
} catch (error) {
|
|
console.warn(`收集 ${config.name} 失败:`, error.message);
|
|
data[config.name] = [];
|
|
}
|
|
}
|
|
|
|
return { data, totalRecords };
|
|
}
|
|
|
|
async function collectFiles(uploadsDir) {
|
|
const files = {
|
|
avatars: [],
|
|
others: [],
|
|
};
|
|
|
|
const avatarsDir = path.join(uploadsDir, 'avatars');
|
|
if (fs.existsSync(avatarsDir)) {
|
|
const avatarFiles = fs.readdirSync(avatarsDir);
|
|
for (const filename of avatarFiles) {
|
|
const filePath = path.join(avatarsDir, filename);
|
|
const stat = fs.statSync(filePath);
|
|
if (stat.isFile()) {
|
|
const content = fs.readFileSync(filePath);
|
|
files.avatars.push({
|
|
filename,
|
|
path: 'uploads/avatars/',
|
|
content: content.toString('base64'),
|
|
size: stat.size,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fs.existsSync(uploadsDir)) {
|
|
const otherFiles = fs.readdirSync(uploadsDir).filter(f => {
|
|
const filePath = path.join(uploadsDir, f);
|
|
return fs.statSync(filePath).isFile();
|
|
});
|
|
|
|
for (const filename of otherFiles) {
|
|
const filePath = path.join(uploadsDir, filename);
|
|
const content = fs.readFileSync(filePath);
|
|
files.others.push({
|
|
filename,
|
|
path: 'uploads/',
|
|
content: content.toString('base64'),
|
|
size: content.length,
|
|
});
|
|
}
|
|
}
|
|
|
|
return files;
|
|
}
|
|
|
|
function calculateChecksum(data) {
|
|
const content = JSON.stringify(data);
|
|
return crypto.createHash('sha256').update(content).digest('hex');
|
|
}
|
|
|
|
async function createBackup(options = {}) {
|
|
const {
|
|
description = '',
|
|
includeFiles = true,
|
|
backupPath = null,
|
|
compress = true,
|
|
autoClean = true,
|
|
maxCount = 30,
|
|
maxAgeDays = 90,
|
|
} = options;
|
|
|
|
const finalBackupPath = backupPath || getBackupPath();
|
|
ensureBackupDir(finalBackupPath);
|
|
|
|
console.log('开始备份数据...');
|
|
const { data, totalRecords } = await collectAllData();
|
|
|
|
let files = { avatars: [], others: [] };
|
|
let fileCount = 0;
|
|
|
|
if (includeFiles) {
|
|
console.log('备份上传文件...');
|
|
const uploadsDir = path.join(__dirname, '..', 'uploads');
|
|
files = await collectFiles(uploadsDir);
|
|
fileCount = files.avatars.length + files.others.length;
|
|
}
|
|
|
|
const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
|
|
const ext = compress ? '.json.gz' : '.json';
|
|
const filename = `backup_${timestamp}${ext}`;
|
|
|
|
const backupData = {
|
|
version: BACKUP_VERSION,
|
|
backupType: 'full',
|
|
timestamp: new Date().toISOString(),
|
|
description,
|
|
compressed: compress,
|
|
systemInfo: {
|
|
nodeVersion: process.version,
|
|
platform: process.platform,
|
|
arch: process.arch,
|
|
dbType: process.env.DB_TYPE || 'sqlite',
|
|
},
|
|
metadata: {
|
|
tableCount: Object.keys(data).length,
|
|
totalRecords,
|
|
fileCount,
|
|
},
|
|
data,
|
|
files,
|
|
};
|
|
|
|
backupData.checksum = calculateChecksum(backupData);
|
|
|
|
const filePath = path.join(finalBackupPath, filename);
|
|
const jsonContent = JSON.stringify(backupData);
|
|
|
|
if (compress) {
|
|
const compressed = zlib.gzipSync(Buffer.from(jsonContent, 'utf8'));
|
|
fs.writeFileSync(filePath, compressed);
|
|
} else {
|
|
fs.writeFileSync(filePath, jsonContent, 'utf8');
|
|
}
|
|
|
|
const stat = fs.statSync(filePath);
|
|
|
|
console.log(`备份完成: ${filename}`);
|
|
console.log(`文件大小: ${(stat.size / 1024).toFixed(2)} KB`);
|
|
if (compress) {
|
|
const originalSize = Buffer.byteLength(jsonContent, 'utf8');
|
|
const ratio = ((1 - stat.size / originalSize) * 100).toFixed(1);
|
|
console.log(`压缩率: ${ratio}% (原始 ${(originalSize / 1024).toFixed(2)} KB)`);
|
|
}
|
|
console.log(`数据记录: ${totalRecords} 条`);
|
|
console.log(`文件数量: ${fileCount} 个`);
|
|
|
|
let cleanResult = null;
|
|
if (autoClean) {
|
|
console.log('\n检查旧备份文件...');
|
|
cleanResult = cleanOldBackups({ maxCount, maxAgeDays });
|
|
if (cleanResult.deletedCount > 0) {
|
|
console.log(
|
|
`已清理 ${cleanResult.deletedCount} 个旧备份，释放 ${cleanResult.freedSizeFormatted}`
|
|
);
|
|
} else {
|
|
console.log('无需清理旧备份');
|
|
}
|
|
}
|
|
|
|
return {
|
|
filename,
|
|
path: filePath,
|
|
size: stat.size,
|
|
recordCount: totalRecords,
|
|
fileCount,
|
|
compressed: compress,
|
|
createdAt: backupData.timestamp,
|
|
cleaned: cleanResult,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 创建增量备份
|
|
*/
|
|
async function createIncrementalBackup(options = {}) {
|
|
const {
|
|
description = '',
|
|
includeFiles = false,
|
|
backupPath = null,
|
|
compress = true,
|
|
autoClean = true,
|
|
maxCount = 30,
|
|
maxAgeDays = 90,
|
|
} = options;
|
|
|
|
const finalBackupPath = backupPath || getBackupPath();
|
|
ensureBackupDir(finalBackupPath);
|
|
|
|
// 获取上次备份时间
|
|
const lastBackupTime = getLastBackupTime();
|
|
if (!lastBackupTime) {
|
|
console.log('未找到上次备份，执行全量备份');
|
|
return await createBackup(options);
|
|
}
|
|
|
|
console.log(`开始增量备份（上次备份时间：${lastBackupTime.toISOString()})...`);
|
|
|
|
// 收集增量数据
|
|
const { data: incrementalData, totalChangedRecords } =
|
|
await collectIncrementalData(lastBackupTime);
|
|
|
|
if (totalChangedRecords === 0) {
|
|
console.log('自上次备份以来没有数据变化，跳过备份');
|
|
return null;
|
|
}
|
|
|
|
// 收集配置数据（总是全量备份）
|
|
console.log('备份配置数据...');
|
|
const { data: fullData } = await collectAllData(INCREMENTAL_BACKUP_CONFIG.fullBackupTables);
|
|
|
|
let files = { avatars: [], others: [] };
|
|
let fileCount = 0;
|
|
|
|
if (includeFiles) {
|
|
console.log('备份上传文件...');
|
|
const uploadsDir = path.join(__dirname, '..', 'uploads');
|
|
files = await collectFiles(uploadsDir);
|
|
fileCount = files.avatars.length + files.others.length;
|
|
}
|
|
|
|
const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
|
|
const ext = compress ? '.json.gz' : '.json';
|
|
const filename = `incremental_${timestamp}${ext}`;
|
|
|
|
const backupData = {
|
|
version: BACKUP_VERSION,
|
|
backupType: 'incremental',
|
|
timestamp: new Date().toISOString(),
|
|
description,
|
|
compressed: compress,
|
|
lastBackupTime: lastBackupTime.toISOString(),
|
|
systemInfo: {
|
|
nodeVersion: process.version,
|
|
platform: process.platform,
|
|
arch: process.arch,
|
|
dbType: process.env.DB_TYPE || 'sqlite',
|
|
},
|
|
metadata: {
|
|
fullBackupTables: Object.keys(fullData).length,
|
|
incrementalTables: Object.keys(incrementalData).length,
|
|
totalChangedRecords,
|
|
fileCount,
|
|
},
|
|
fullData,
|
|
incrementalData,
|
|
files,
|
|
};
|
|
|
|
backupData.checksum = calculateChecksum(backupData);
|
|
|
|
const filePath = path.join(finalBackupPath, filename);
|
|
const jsonContent = JSON.stringify(backupData);
|
|
|
|
if (compress) {
|
|
const compressed = zlib.gzipSync(Buffer.from(jsonContent, 'utf8'));
|
|
fs.writeFileSync(filePath, compressed);
|
|
} else {
|
|
fs.writeFileSync(filePath, jsonContent, 'utf8');
|
|
}
|
|
|
|
const stat = fs.statSync(filePath);
|
|
|
|
console.log(`增量备份完成：${filename}`);
|
|
console.log(`文件大小：${(stat.size / 1024).toFixed(2)} KB`);
|
|
if (compress) {
|
|
const originalSize = Buffer.byteLength(jsonContent, 'utf8');
|
|
const ratio = ((1 - stat.size / originalSize) * 100).toFixed(1);
|
|
console.log(`压缩率：${ratio}% (原始 ${(originalSize / 1024).toFixed(2)} KB)`);
|
|
}
|
|
console.log(`变化记录：${totalChangedRecords} 条`);
|
|
console.log(`文件数量：${fileCount} 个`);
|
|
|
|
let cleanResult = null;
|
|
if (autoClean) {
|
|
console.log('\n检查旧备份文件...');
|
|
cleanResult = cleanOldBackups({ maxCount, maxAgeDays });
|
|
if (cleanResult.deletedCount > 0) {
|
|
console.log(
|
|
`已清理 ${cleanResult.deletedCount} 个旧备份，释放 ${cleanResult.freedSizeFormatted}`
|
|
);
|
|
} else {
|
|
console.log('无需清理旧备份');
|
|
}
|
|
}
|
|
|
|
return {
|
|
filename,
|
|
path: filePath,
|
|
size: stat.size,
|
|
recordCount: totalChangedRecords,
|
|
fileCount,
|
|
compressed: compress,
|
|
createdAt: backupData.timestamp,
|
|
cleaned: cleanResult,
|
|
isIncremental: true,
|
|
};
|
|
}
|
|
|
|
async function validateBackupFile(filePath, options = {}) {
|
|
const { isCompressed: forceCompressed } = options;
|
|
|
|
if (!fs.existsSync(filePath)) {
|
|
return { valid: false, error: '备份文件不存在' };
|
|
}
|
|
|
|
let backupData;
|
|
try {
|
|
const buffer = fs.readFileSync(filePath);
|
|
const isCompressed = forceCompressed !== undefined ? forceCompressed : filePath.endsWith('.gz');
|
|
|
|
if (isCompressed) {
|
|
const decompressed = zlib.gunzipSync(buffer);
|
|
backupData = JSON.parse(decompressed.toString('utf8'));
|
|
} else {
|
|
backupData = JSON.parse(buffer.toString('utf8'));
|
|
}
|
|
} catch (error) {
|
|
console.error('备份文件解析失败:', error.message);
|
|
return { valid: false, error: `备份文件格式无效: ${error.message}` };
|
|
}
|
|
|
|
if (!backupData.version) {
|
|
return { valid: false, error: '备份文件缺少版本信息' };
|
|
}
|
|
|
|
const isIncremental = backupData.backupType === 'incremental';
|
|
const dataToValidate = isIncremental ? backupData.fullData : backupData.data;
|
|
|
|
if (!dataToValidate && !isIncremental) {
|
|
return { valid: false, error: '备份文件缺少数据内容' };
|
|
}
|
|
|
|
const savedChecksum = backupData.checksum;
|
|
if (savedChecksum) {
|
|
const dataToCheck = { ...backupData };
|
|
delete dataToCheck.checksum;
|
|
const calculatedChecksum = calculateChecksum(dataToCheck);
|
|
if (calculatedChecksum !== savedChecksum) {
|
|
return { valid: false, error: '备份文件校验和不匹配，文件可能已损坏' };
|
|
}
|
|
}
|
|
|
|
const tableDetails = {};
|
|
let totalRecords = 0;
|
|
|
|
if (isIncremental) {
|
|
if (backupData.fullData) {
|
|
for (const tableName of Object.keys(backupData.fullData)) {
|
|
if (Array.isArray(backupData.fullData[tableName])) {
|
|
const recordCount = backupData.fullData[tableName].length;
|
|
tableDetails[tableName] = {
|
|
recordCount,
|
|
hasData: recordCount > 0,
|
|
displayName: TABLE_NAME_MAPPING[tableName] || tableName,
|
|
type: 'full',
|
|
};
|
|
totalRecords += recordCount;
|
|
}
|
|
}
|
|
}
|
|
if (backupData.incrementalData) {
|
|
for (const tableName of Object.keys(backupData.incrementalData)) {
|
|
const inc = backupData.incrementalData[tableName];
|
|
const newCount = inc.new?.length || 0;
|
|
const updatedCount = inc.updated?.length || 0;
|
|
if (newCount > 0 || updatedCount > 0) {
|
|
tableDetails[tableName] = {
|
|
...tableDetails[tableName],
|
|
newCount,
|
|
updatedCount,
|
|
recordCount: (tableDetails[tableName]?.recordCount || 0) + newCount + updatedCount,
|
|
hasData: true,
|
|
displayName: TABLE_NAME_MAPPING[tableName] || tableName,
|
|
type: tableDetails[tableName] ? 'both' : 'incremental',
|
|
};
|
|
totalRecords += newCount + updatedCount;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (const tableName of Object.keys(backupData.data)) {
|
|
if (Array.isArray(backupData.data[tableName])) {
|
|
const recordCount = backupData.data[tableName].length;
|
|
tableDetails[tableName] = {
|
|
recordCount,
|
|
hasData: recordCount > 0,
|
|
displayName: TABLE_NAME_MAPPING[tableName] || tableName,
|
|
};
|
|
totalRecords += recordCount;
|
|
}
|
|
}
|
|
}
|
|
|
|
const fileDetails = {
|
|
avatars: backupData.files?.avatars?.length || 0,
|
|
others: backupData.files?.others?.length || 0,
|
|
total: (backupData.files?.avatars?.length || 0) + (backupData.files?.others?.length || 0),
|
|
avatarList:
|
|
backupData.files?.avatars?.map(f => ({
|
|
filename: f.filename,
|
|
size: f.size,
|
|
})) || [],
|
|
otherList:
|
|
backupData.files?.others?.map(f => ({
|
|
filename: f.filename,
|
|
size: f.size,
|
|
})) || [],
|
|
};
|
|
|
|
const metadata = isIncremental
|
|
? {
|
|
tableCount: Object.keys(backupData.fullData || {}).length,
|
|
incrementalTableCount: Object.keys(backupData.incrementalData || {}).length,
|
|
totalRecords,
|
|
totalChangedRecords: backupData.metadata?.totalChangedRecords || totalRecords,
|
|
fileCount: fileDetails.total,
|
|
lastBackupTime: backupData.lastBackupTime,
|
|
}
|
|
: {
|
|
tableCount: Object.keys(backupData.data).length,
|
|
totalRecords,
|
|
fileCount: fileDetails.total,
|
|
};
|
|
|
|
return {
|
|
valid: true,
|
|
version: backupData.version,
|
|
backupType: backupData.backupType,
|
|
timestamp: backupData.timestamp,
|
|
description: backupData.description,
|
|
compressed: backupData.compressed,
|
|
systemInfo: backupData.systemInfo,
|
|
metadata,
|
|
details: {
|
|
tables: tableDetails,
|
|
files: fileDetails,
|
|
systemInfo: backupData.systemInfo,
|
|
},
|
|
};
|
|
}
|
|
|
|
// 用户相关表定义
|
|
const USER_RELATED_TABLES = ['User', 'UserRole'];
|
|
|
|
async function restoreData(backupData, options = {}) {
|
|
const {
|
|
overwriteExisting = true,
|
|
skipTables = [],
|
|
skipUserData = false,
|
|
shouldStop = () => false,
|
|
onProgress = () => {}
|
|
} = options;
|
|
|
|
const results = {
|
|
tablesRestored: 0,
|
|
recordsRestored: 0,
|
|
errors: [],
|
|
skipped: [],
|
|
tableDetails: {},
|
|
stopped: false,
|
|
};
|
|
|
|
const isIncremental = backupData.backupType === 'incremental';
|
|
const dataToRestore = isIncremental ? backupData.fullData : backupData.data;
|
|
|
|
if (!dataToRestore) {
|
|
results.errors.push({ error: '备份数据为空' });
|
|
return results;
|
|
}
|
|
|
|
// 如果选择跳过用户数据，将用户相关表添加到跳过列表
|
|
const effectiveSkipTables = [...skipTables];
|
|
if (skipUserData) {
|
|
USER_RELATED_TABLES.forEach(table => {
|
|
if (!effectiveSkipTables.includes(table)) {
|
|
effectiveSkipTables.push(table);
|
|
}
|
|
});
|
|
console.log('已配置跳过用户相关表:', USER_RELATED_TABLES);
|
|
}
|
|
|
|
await disableForeignKeyChecks();
|
|
|
|
try {
|
|
for (const tableName of RESTORE_ORDER) {
|
|
// 检查是否请求停止
|
|
if (shouldStop()) {
|
|
results.stopped = true;
|
|
console.log('恢复操作被用户中断');
|
|
break;
|
|
}
|
|
|
|
if (effectiveSkipTables.includes(tableName)) {
|
|
results.skipped.push(tableName);
|
|
onProgress(tableName, 'skipped');
|
|
continue;
|
|
}
|
|
|
|
const tableData = dataToRestore[tableName];
|
|
if (!tableData || !Array.isArray(tableData) || tableData.length === 0) {
|
|
onProgress(tableName, 'empty');
|
|
continue;
|
|
}
|
|
|
|
const config = BACKUP_MODELS_CONFIG.find(c => c.name === tableName);
|
|
if (!config) {
|
|
results.errors.push({ table: tableName, error: '未找到模型配置' });
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
|
|
// 对于用户相关表，即使设置了 overwriteExisting 也不截断
|
|
if (overwriteExisting && !USER_RELATED_TABLES.includes(tableName)) {
|
|
await Model.destroy({ where: {}, truncate: true });
|
|
}
|
|
|
|
const processedRecords = tableData.map(record => {
|
|
const processed = { ...record };
|
|
|
|
if (
|
|
tableName === 'Device' &&
|
|
processed.customFields !== undefined &&
|
|
processed.customFields !== null
|
|
) {
|
|
if (typeof processed.customFields === 'string') {
|
|
try {
|
|
processed.customFields = JSON.parse(processed.customFields);
|
|
} catch (e) {
|
|
console.warn(
|
|
`解析 Device.customFields 失败：${processed.deviceId}, 错误：${e.message}`
|
|
);
|
|
processed.customFields = {};
|
|
}
|
|
}
|
|
}
|
|
|
|
return processed;
|
|
});
|
|
|
|
let insertedCount = 0;
|
|
|
|
for (let i = 0; i < processedRecords.length; i += BATCH_SIZE) {
|
|
if (shouldStop()) {
|
|
results.stopped = true;
|
|
logger.info('恢复操作在插入数据时被用户中断');
|
|
break;
|
|
}
|
|
|
|
const batch = processedRecords.slice(i, i + BATCH_SIZE);
|
|
|
|
try {
|
|
await Model.bulkCreate(batch, {
|
|
validate: false,
|
|
individualHooks: false,
|
|
logging: false,
|
|
});
|
|
insertedCount += batch.length;
|
|
} catch (bulkError) {
|
|
for (const record of batch) {
|
|
try {
|
|
await Model.create(record, { validate: false, silent: true });
|
|
insertedCount++;
|
|
} catch (insertError) {
|
|
if (insertError.name === 'SequelizeUniqueConstraintError') {
|
|
try {
|
|
await Model.upsert(record, { validate: false, silent: true });
|
|
insertedCount++;
|
|
} catch (upsertError) {
|
|
results.errors.push({
|
|
table: tableName,
|
|
record: record[Object.keys(record)[0]],
|
|
error: upsertError.message,
|
|
});
|
|
}
|
|
} else {
|
|
results.errors.push({
|
|
table: tableName,
|
|
record: record[Object.keys(record)[0]],
|
|
error: insertError.message,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 如果已停止，跳出外层循环
|
|
if (results.stopped) {
|
|
break;
|
|
}
|
|
|
|
results.tablesRestored++;
|
|
results.recordsRestored += insertedCount;
|
|
|
|
results.tableDetails[tableName] = {
|
|
recordCount: insertedCount,
|
|
displayName: TABLE_NAME_MAPPING[tableName] || tableName,
|
|
success: insertedCount > 0,
|
|
};
|
|
|
|
onProgress(tableName, 'restored', insertedCount);
|
|
} catch (error) {
|
|
results.errors.push({ table: tableName, error: error.message });
|
|
onProgress(tableName, 'error', error.message);
|
|
}
|
|
}
|
|
|
|
if (isIncremental && backupData.incrementalData) {
|
|
console.log('\n恢复增量数据...');
|
|
const incrementalResults = await restoreIncrementalData(backupData.incrementalData, options);
|
|
results.tablesRestored += incrementalResults.tablesRestored;
|
|
results.recordsRestored += incrementalResults.recordsRestored;
|
|
results.errors.push(...incrementalResults.errors);
|
|
Object.assign(results.tableDetails, incrementalResults.tableDetails);
|
|
}
|
|
} finally {
|
|
await enableForeignKeyChecks();
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
async function restoreIncrementalData(incrementalData, options = {}) {
|
|
const results = {
|
|
tablesRestored: 0,
|
|
recordsRestored: 0,
|
|
errors: [],
|
|
tableDetails: {},
|
|
};
|
|
|
|
for (const tableName of Object.keys(incrementalData)) {
|
|
const tableIncrement = incrementalData[tableName];
|
|
const config = BACKUP_MODELS_CONFIG.find(c => c.name === tableName);
|
|
|
|
if (!config) {
|
|
results.errors.push({ table: tableName, error: '未找到模型配置' });
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
const Model = require(config.modelPath);
|
|
let updatedCount = 0;
|
|
|
|
if (tableIncrement.new && tableIncrement.new.length > 0) {
|
|
for (let i = 0; i < tableIncrement.new.length; i += BATCH_SIZE) {
|
|
const batch = tableIncrement.new.slice(i, i + BATCH_SIZE);
|
|
try {
|
|
await Model.bulkCreate(batch, {
|
|
validate: false,
|
|
individualHooks: false,
|
|
logging: false,
|
|
});
|
|
updatedCount += batch.length;
|
|
} catch (bulkError) {
|
|
for (const record of batch) {
|
|
try {
|
|
await Model.create(record, { validate: false, silent: true });
|
|
updatedCount++;
|
|
} catch (insertError) {
|
|
if (insertError.name === 'SequelizeUniqueConstraintError') {
|
|
await Model.upsert(record, { validate: false, silent: true });
|
|
updatedCount++;
|
|
} else {
|
|
results.errors.push({
|
|
table: tableName,
|
|
record: record[Object.keys(record)[0]],
|
|
error: `新增失败: ${insertError.message}`,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tableIncrement.updated && tableIncrement.updated.length > 0) {
|
|
for (let i = 0; i < tableIncrement.updated.length; i += BATCH_SIZE) {
|
|
const batch = tableIncrement.updated.slice(i, i + BATCH_SIZE);
|
|
for (const record of batch) {
|
|
try {
|
|
await Model.upsert(record, { validate: false, silent: true });
|
|
updatedCount++;
|
|
} catch (updateError) {
|
|
results.errors.push({
|
|
table: tableName,
|
|
record: record[Object.keys(record)[0]],
|
|
error: `更新失败: ${updateError.message}`,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (updatedCount > 0) {
|
|
results.tablesRestored++;
|
|
results.recordsRestored += updatedCount;
|
|
results.tableDetails[tableName] = {
|
|
recordCount: updatedCount,
|
|
displayName: TABLE_NAME_MAPPING[tableName] || tableName,
|
|
success: true,
|
|
isIncremental: true,
|
|
};
|
|
}
|
|
} catch (error) {
|
|
results.errors.push({ table: tableName, error: error.message });
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
async function restoreFiles(files, uploadsDir) {
|
|
const results = {
|
|
filesRestored: 0,
|
|
errors: [],
|
|
};
|
|
|
|
if (!fs.existsSync(uploadsDir)) {
|
|
fs.mkdirSync(uploadsDir, { recursive: true });
|
|
}
|
|
|
|
const avatarsDir = path.join(uploadsDir, 'avatars');
|
|
if (!fs.existsSync(avatarsDir)) {
|
|
fs.mkdirSync(avatarsDir, { recursive: true });
|
|
}
|
|
|
|
if (files.avatars && Array.isArray(files.avatars)) {
|
|
for (const file of files.avatars) {
|
|
try {
|
|
const filePath = path.join(avatarsDir, file.filename);
|
|
const content = Buffer.from(file.content, 'base64');
|
|
fs.writeFileSync(filePath, content);
|
|
results.filesRestored++;
|
|
} catch (error) {
|
|
results.errors.push({ file: file.filename, error: error.message });
|
|
}
|
|
}
|
|
}
|
|
|
|
if (files.others && Array.isArray(files.others)) {
|
|
for (const file of files.others) {
|
|
try {
|
|
const filePath = path.join(uploadsDir, file.filename);
|
|
const content = Buffer.from(file.content, 'base64');
|
|
fs.writeFileSync(filePath, content);
|
|
results.filesRestored++;
|
|
} catch (error) {
|
|
results.errors.push({ file: file.filename, error: error.message });
|
|
}
|
|
}
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
async function restoreBackup(filePath, options = {}) {
|
|
const {
|
|
overwriteExisting = true,
|
|
skipTables = [],
|
|
skipFiles = false,
|
|
skipUserData = false,
|
|
shouldStop = () => false,
|
|
onProgress = () => {},
|
|
enableRollback = true,
|
|
} = options;
|
|
|
|
let snapshotId = null;
|
|
|
|
try {
|
|
logger.info('验证备份文件...');
|
|
const validation = await validateBackupFile(filePath);
|
|
if (!validation.valid) {
|
|
throw new Error(`备份文件验证失败: ${validation.error}`);
|
|
}
|
|
|
|
logger.info('备份文件信息', {
|
|
version: validation.version,
|
|
compressed: validation.compressed,
|
|
tableCount: validation.metadata.tableCount,
|
|
totalRecords: validation.metadata.totalRecords,
|
|
fileCount: validation.metadata.fileCount,
|
|
});
|
|
|
|
// 步骤1: 启用维护模式，防止并发操作导致数据不一致
|
|
logger.info('启用维护模式...');
|
|
enableMaintenanceMode('正在恢复备份数据');
|
|
onProgress('maintenance', 'enabled', 0);
|
|
|
|
try {
|
|
// 步骤2: 创建还原点（如果启用回滚保护）
|
|
if (enableRollback) {
|
|
logger.info('创建还原点...');
|
|
onProgress('snapshot', 'creating', 0);
|
|
snapshotId = await createSnapshot();
|
|
|
|
if (snapshotId) {
|
|
logger.info('还原点创建成功，开始恢复数据...');
|
|
onProgress('snapshot', 'created', 5);
|
|
} else {
|
|
logger.warn('还原点创建失败，继续恢复但无法回滚');
|
|
onProgress('snapshot', 'warning', 5);
|
|
}
|
|
}
|
|
|
|
// 步骤3: 读取备份数据
|
|
logger.info('读取备份数据...');
|
|
const buffer = fs.readFileSync(filePath);
|
|
const isCompressed = filePath.endsWith('.gz');
|
|
|
|
let backupData;
|
|
if (isCompressed) {
|
|
logger.info('解压备份文件...');
|
|
const decompressed = zlib.gunzipSync(buffer);
|
|
backupData = JSON.parse(decompressed.toString('utf8'));
|
|
} else {
|
|
backupData = JSON.parse(buffer.toString('utf8'));
|
|
}
|
|
|
|
// 步骤4: 恢复数据
|
|
logger.info('开始恢复数据...');
|
|
const dataResults = await restoreData(backupData, {
|
|
overwriteExisting,
|
|
skipTables,
|
|
skipUserData,
|
|
shouldStop,
|
|
onProgress,
|
|
});
|
|
|
|
// 步骤5: 恢复上传文件（仅在数据恢复未停止时）
|
|
let fileResults = { filesRestored: 0, errors: [] };
|
|
if (!skipFiles && backupData.files && !dataResults.stopped) {
|
|
logger.info('恢复上传文件...');
|
|
const uploadsDir = path.join(__dirname, '..', 'uploads');
|
|
fileResults = await restoreFiles(backupData.files, uploadsDir);
|
|
}
|
|
|
|
// 步骤6: 处理恢复结果
|
|
const stat = fs.statSync(filePath);
|
|
|
|
if (dataResults.stopped) {
|
|
// 用户中断恢复 - 自动回滚到还原点
|
|
logger.info('恢复被用户中断，准备回滚数据...');
|
|
|
|
if (snapshotId && enableRollback) {
|
|
onProgress('rollback', 'starting', 0);
|
|
const rollbackSuccess = await restoreFromSnapshot(snapshotId);
|
|
|
|
if (rollbackSuccess) {
|
|
logger.info('数据已成功回滚到恢复前的状态');
|
|
onProgress('rollback', 'completed', 100);
|
|
} else {
|
|
logger.error('数据回滚失败！数据可能处于不一致状态');
|
|
onProgress('rollback', 'failed', 0);
|
|
}
|
|
} else {
|
|
logger.warn('无法回滚：没有可用的还原点');
|
|
}
|
|
|
|
// 清理还原点
|
|
if (snapshotId) {
|
|
deleteSnapshot(snapshotId);
|
|
}
|
|
|
|
return {
|
|
restoredAt: new Date().toISOString(),
|
|
tablesRestored: dataResults.tablesRestored,
|
|
recordsRestored: dataResults.recordsRestored,
|
|
filesRestored: fileResults.filesRestored,
|
|
errors: dataResults.errors,
|
|
skipped: dataResults.skipped || [],
|
|
stopped: true,
|
|
rolledBack: snapshotId ? true : false,
|
|
tableDetails: dataResults.tableDetails,
|
|
fileDetails: backupData.files
|
|
? {
|
|
avatars: backupData.files.avatars?.length || 0,
|
|
others: backupData.files.others?.length || 0,
|
|
}
|
|
: null,
|
|
};
|
|
}
|
|
|
|
// 恢复成功
|
|
logger.info('恢复完成!', {
|
|
fileSize: `${(stat.size / 1024 / 1024).toFixed(2)} MB`,
|
|
recordsRestored: dataResults.recordsRestored,
|
|
tablesRestored: dataResults.tablesRestored,
|
|
filesRestored: fileResults.filesRestored,
|
|
});
|
|
|
|
// 清理还原点（恢复成功，不再需要）
|
|
if (snapshotId) {
|
|
deleteSnapshot(snapshotId);
|
|
}
|
|
|
|
// 清理过期还原点
|
|
cleanupOldSnapshots();
|
|
|
|
if (dataResults.errors.length > 0) {
|
|
logger.warn('恢复过程中有错误', { errors: dataResults.errors });
|
|
}
|
|
|
|
return {
|
|
restoredAt: new Date().toISOString(),
|
|
tablesRestored: dataResults.tablesRestored,
|
|
recordsRestored: dataResults.recordsRestored,
|
|
filesRestored: fileResults.filesRestored,
|
|
errors: dataResults.errors,
|
|
skipped: dataResults.skipped || [],
|
|
stopped: false,
|
|
rolledBack: false,
|
|
tableDetails: dataResults.tableDetails,
|
|
fileDetails: backupData.files
|
|
? {
|
|
avatars: backupData.files.avatars?.length || 0,
|
|
others: backupData.files.others?.length || 0,
|
|
}
|
|
: null,
|
|
};
|
|
} finally {
|
|
// 无论成功或中断，都解除维护模式
|
|
disableMaintenanceMode();
|
|
onProgress('maintenance', 'disabled', 100);
|
|
}
|
|
} catch (error) {
|
|
// 恢复过程发生异常 - 尝试回滚
|
|
logger.error('恢复过程发生错误', { error: error.message, stack: error.stack });
|
|
|
|
if (snapshotId && enableRollback) {
|
|
logger.info('尝试回滚数据到恢复前的状态...');
|
|
const rollbackSuccess = await restoreFromSnapshot(snapshotId);
|
|
|
|
if (rollbackSuccess) {
|
|
logger.info('数据已成功回滚');
|
|
} else {
|
|
logger.error('数据回滚失败！数据可能处于不一致状态');
|
|
}
|
|
|
|
deleteSnapshot(snapshotId);
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
function cleanOldBackups(options = {}) {
|
|
const { maxCount = 30, maxAgeDays = 90, dryRun = false } = options;
|
|
|
|
const backupPath = getBackupPath();
|
|
|
|
if (!fs.existsSync(backupPath)) {
|
|
return { deleted: [], kept: [], totalSize: 0, freedSize: 0 };
|
|
}
|
|
|
|
const now = Date.now();
|
|
const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
|
|
|
|
const files = fs
|
|
.readdirSync(backupPath)
|
|
.filter(
|
|
f =>
|
|
(f.startsWith('backup_') || f.startsWith('uploaded_') || f.startsWith('incremental_')) &&
|
|
(f.endsWith('.json') || f.endsWith('.json.gz'))
|
|
)
|
|
.map(f => {
|
|
const filePath = path.join(backupPath, f);
|
|
const stats = fs.statSync(filePath);
|
|
return {
|
|
filename: f,
|
|
path: filePath,
|
|
size: stats.size,
|
|
createdAt: stats.birthtime,
|
|
createdMs: stats.birthtimeMs || stats.birthtime.getTime(),
|
|
age: now - (stats.birthtimeMs || stats.birthtime.getTime()),
|
|
};
|
|
})
|
|
.sort((a, b) => b.createdMs - a.createdMs);
|
|
|
|
const toDelete = [];
|
|
const toKeep = [];
|
|
let freedSize = 0;
|
|
|
|
files.forEach((file, index) => {
|
|
const tooOld = file.age > maxAgeMs;
|
|
const tooMany = index >= maxCount;
|
|
|
|
if (tooOld || tooMany) {
|
|
toDelete.push(file);
|
|
freedSize += file.size;
|
|
} else {
|
|
toKeep.push(file);
|
|
}
|
|
});
|
|
|
|
if (!dryRun) {
|
|
toDelete.forEach(file => {
|
|
try {
|
|
fs.unlinkSync(file.path);
|
|
console.log(`已删除旧备份: ${file.filename}`);
|
|
} catch (err) {
|
|
console.warn(`删除备份失败: ${file.filename}`, err.message);
|
|
}
|
|
});
|
|
}
|
|
|
|
return {
|
|
deleted: toDelete.map(f => f.filename),
|
|
kept: toKeep.map(f => f.filename),
|
|
deletedCount: toDelete.length,
|
|
keptCount: toKeep.length,
|
|
totalSize: files.reduce((sum, f) => sum + f.size, 0),
|
|
freedSize,
|
|
freedSizeFormatted: formatBytes(freedSize),
|
|
};
|
|
}
|
|
|
|
function formatBytes(bytes) {
|
|
if (bytes === 0) {
|
|
return '0 B';
|
|
}
|
|
const k = 1024;
|
|
const sizes = ['B', 'KB', 'MB', 'GB'];
|
|
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
|
return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
|
|
}
|
|
|
|
module.exports = {
|
|
BACKUP_VERSION,
|
|
BACKUP_MODELS_CONFIG,
|
|
RESTORE_ORDER,
|
|
INCREMENTAL_BACKUP_CONFIG,
|
|
getBackupPath,
|
|
ensureBackupDir,
|
|
createBackup,
|
|
createIncrementalBackup,
|
|
getLastBackupTime,
|
|
validateBackupFile,
|
|
restoreData,
|
|
restoreIncrementalData,
|
|
restoreFiles,
|
|
restoreBackup,
|
|
calculateChecksum,
|
|
cleanOldBackups,
|
|
createSnapshot,
|
|
restoreFromSnapshot,
|
|
deleteSnapshot,
|
|
cleanupOldSnapshots,
|
|
};
|