feat: implement comprehensive backup and restore system with S3 support
- Add S3/MinIO storage adapter with multipart upload support - Implement database backup service for SQLite and PostgreSQL - Create backup manifest generator for tracking backup contents - Enhance backup service with S3 integration and incremental backups - Add restore service with safety measures and rollback capability - Create comprehensive test suite for all backup functionality - Add admin API endpoints for backup/restore management - Implement frontend UI with dashboard, configuration, and restore wizard - Add roadmap section to README with implemented backup feature This implementation provides: - Multiple backup destinations (local, rsync, S3/MinIO) - Intelligent change detection to minimize backup frequency - Full database backups with compression - Manifest-based restore with integrity validation - Pre-restore safety backups with rollback - Comprehensive error handling and monitoring - User-friendly admin interface 🤖 Generated with Claude Code Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
@@ -11,6 +11,8 @@ const photosRoutes = require('./adminPhotos');
|
||||
const categoriesRoutes = require('./adminCategories');
|
||||
const cmsRoutes = require('./adminCMS');
|
||||
const notificationsRoutes = require('./adminNotifications');
|
||||
const backupRoutes = require('./adminBackup');
|
||||
const restoreRoutes = require('./adminRestore');
|
||||
|
||||
// Mount sub-routers
|
||||
router.use('/dashboard', dashboardRoutes);
|
||||
@@ -22,5 +24,7 @@ router.use('/events', photosRoutes);
|
||||
router.use('/categories', categoriesRoutes);
|
||||
router.use('/cms', cmsRoutes);
|
||||
router.use('/notifications', notificationsRoutes);
|
||||
router.use('/backup', backupRoutes);
|
||||
router.use('/restore', restoreRoutes);
|
||||
|
||||
module.exports = router;
|
||||
@@ -0,0 +1,956 @@
|
||||
const express = require('express');
|
||||
const { db } = require('../database/db');
|
||||
const { adminAuth } = require('../middleware/auth');
|
||||
const { triggerManualBackup, getBackupStatus, cleanupOldBackupRuns, getBackupManifest, validateBackupManifest } = require('../services/backupService');
|
||||
const logger = require('../utils/logger');
|
||||
const fs = require('fs').promises;
|
||||
const path = require('path');
|
||||
const crypto = require('crypto');
|
||||
const archiver = require('archiver');
|
||||
const S3StorageAdapter = require('../services/storage/s3Storage');
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
// Get backup configuration
|
||||
router.get('/config', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const settings = await db('app_settings')
|
||||
.where('setting_type', 'backup')
|
||||
.select('setting_key', 'setting_value');
|
||||
|
||||
const config = {};
|
||||
settings.forEach(setting => {
|
||||
try {
|
||||
config[setting.setting_key] = JSON.parse(setting.setting_value);
|
||||
} catch (e) {
|
||||
config[setting.setting_key] = setting.setting_value;
|
||||
}
|
||||
});
|
||||
|
||||
res.json(config);
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup configuration:', error);
|
||||
res.status(500).json({ error: 'Failed to get backup configuration' });
|
||||
}
|
||||
});
|
||||
|
||||
// Update backup configuration
|
||||
router.put('/config', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const updates = req.body;
|
||||
|
||||
// Validate required fields based on destination type
|
||||
if (updates.backup_destination_type) {
|
||||
switch (updates.backup_destination_type) {
|
||||
case 'local':
|
||||
if (!updates.backup_destination_path) {
|
||||
return res.status(400).json({ error: 'Local backup requires destination path' });
|
||||
}
|
||||
break;
|
||||
case 'rsync':
|
||||
if (!updates.backup_rsync_host || !updates.backup_rsync_path) {
|
||||
return res.status(400).json({ error: 'Rsync backup requires host and path' });
|
||||
}
|
||||
break;
|
||||
case 's3':
|
||||
if (!updates.backup_s3_endpoint || !updates.backup_s3_bucket ||
|
||||
!updates.backup_s3_access_key || !updates.backup_s3_secret_key) {
|
||||
return res.status(400).json({ error: 'S3 backup requires endpoint, bucket, and credentials' });
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Update settings
|
||||
for (const [key, value] of Object.entries(updates)) {
|
||||
if (key.startsWith('backup_')) {
|
||||
await db('app_settings')
|
||||
.insert({
|
||||
setting_key: key,
|
||||
setting_value: JSON.stringify(value),
|
||||
setting_type: 'backup',
|
||||
updated_at: new Date()
|
||||
})
|
||||
.onConflict('setting_key')
|
||||
.merge({
|
||||
setting_value: JSON.stringify(value),
|
||||
updated_at: new Date()
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Restart backup service if enabled status changed
|
||||
if ('backup_enabled' in updates) {
|
||||
const { startBackupService, stopBackupService } = require('../services/backupService');
|
||||
if (updates.backup_enabled) {
|
||||
await startBackupService();
|
||||
} else {
|
||||
stopBackupService();
|
||||
}
|
||||
}
|
||||
|
||||
res.json({ success: true, message: 'Backup configuration updated' });
|
||||
} catch (error) {
|
||||
logger.error('Failed to update backup configuration:', error);
|
||||
res.status(500).json({ error: 'Failed to update backup configuration' });
|
||||
}
|
||||
});
|
||||
|
||||
// Get backup status and history
|
||||
router.get('/status', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const limit = parseInt(req.query.limit) || 10;
|
||||
const status = await getBackupStatus(limit);
|
||||
|
||||
res.json(status);
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup status:', error);
|
||||
res.status(500).json({ error: 'Failed to get backup status' });
|
||||
}
|
||||
});
|
||||
|
||||
// Trigger manual backup
|
||||
router.post('/run', adminAuth, async (req, res) => {
|
||||
try {
|
||||
// Check if backup is already running
|
||||
const status = await getBackupStatus();
|
||||
if (status.isRunning) {
|
||||
return res.status(409).json({ error: 'Backup is already running' });
|
||||
}
|
||||
|
||||
// Start backup in background
|
||||
triggerManualBackup().catch(error => {
|
||||
logger.error('Manual backup failed:', error);
|
||||
});
|
||||
|
||||
res.json({ success: true, message: 'Backup started' });
|
||||
} catch (error) {
|
||||
logger.error('Failed to trigger manual backup:', error);
|
||||
res.status(500).json({ error: 'Failed to trigger backup' });
|
||||
}
|
||||
});
|
||||
|
||||
// Get backup run details
|
||||
router.get('/runs/:id', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { id } = req.params;
|
||||
|
||||
const run = await db('backup_runs')
|
||||
.where('id', id)
|
||||
.first();
|
||||
|
||||
if (!run) {
|
||||
return res.status(404).json({ error: 'Backup run not found' });
|
||||
}
|
||||
|
||||
// Parse JSON fields
|
||||
if (run.statistics) {
|
||||
try {
|
||||
run.statistics = JSON.parse(run.statistics);
|
||||
} catch (e) {
|
||||
// Keep as string if parsing fails
|
||||
}
|
||||
}
|
||||
|
||||
res.json(run);
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup run details:', error);
|
||||
res.status(500).json({ error: 'Failed to get backup run details' });
|
||||
}
|
||||
});
|
||||
|
||||
// Get file states (for debugging/monitoring)
|
||||
router.get('/files', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { page = 1, limit = 50, search = '' } = req.query;
|
||||
const offset = (page - 1) * limit;
|
||||
|
||||
let query = db('backup_file_states');
|
||||
|
||||
if (search) {
|
||||
query = query.where('file_path', 'like', `%${search}%`);
|
||||
}
|
||||
|
||||
const [files, totalCount] = await Promise.all([
|
||||
query
|
||||
.orderBy('last_backed_up', 'desc')
|
||||
.limit(limit)
|
||||
.offset(offset),
|
||||
db('backup_file_states').count('* as count').first()
|
||||
]);
|
||||
|
||||
res.json({
|
||||
files,
|
||||
pagination: {
|
||||
page: parseInt(page),
|
||||
limit: parseInt(limit),
|
||||
total: totalCount.count,
|
||||
pages: Math.ceil(totalCount.count / limit)
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup file states:', error);
|
||||
res.status(500).json({ error: 'Failed to get file states' });
|
||||
}
|
||||
});
|
||||
|
||||
// Clean up old backup runs
|
||||
router.delete('/cleanup', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { days = 30 } = req.body;
|
||||
|
||||
await cleanupOldBackupRuns(days);
|
||||
|
||||
res.json({ success: true, message: `Cleaned up backup runs older than ${days} days` });
|
||||
} catch (error) {
|
||||
logger.error('Failed to cleanup old backup runs:', error);
|
||||
res.status(500).json({ error: 'Failed to cleanup backup runs' });
|
||||
}
|
||||
});
|
||||
|
||||
// Test backup destination connectivity
|
||||
router.post('/test-connection', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { destination_type, ...config } = req.body;
|
||||
|
||||
switch (destination_type) {
|
||||
case 'local':
|
||||
// Test local path access
|
||||
const fs = require('fs').promises;
|
||||
try {
|
||||
await fs.access(config.path, fs.constants.W_OK);
|
||||
res.json({ success: true, message: 'Local path is writable' });
|
||||
} catch (error) {
|
||||
res.json({ success: false, message: 'Cannot write to local path: ' + error.message });
|
||||
}
|
||||
break;
|
||||
|
||||
case 'rsync':
|
||||
// Test rsync connection
|
||||
const { exec } = require('child_process');
|
||||
const { promisify } = require('util');
|
||||
const execAsync = promisify(exec);
|
||||
|
||||
const sshCommand = config.ssh_key
|
||||
? `ssh -i ${config.ssh_key} -o StrictHostKeyChecking=no -o ConnectTimeout=10`
|
||||
: 'ssh -o StrictHostKeyChecking=no -o ConnectTimeout=10';
|
||||
|
||||
const testCommand = config.user
|
||||
? `${sshCommand} ${config.user}@${config.host} "echo 'Connection successful'"`
|
||||
: `${sshCommand} ${config.host} "echo 'Connection successful'"`;
|
||||
|
||||
try {
|
||||
const { stdout } = await execAsync(testCommand);
|
||||
res.json({ success: true, message: 'Rsync connection successful' });
|
||||
} catch (error) {
|
||||
res.json({ success: false, message: 'Rsync connection failed: ' + error.message });
|
||||
}
|
||||
break;
|
||||
|
||||
case 's3':
|
||||
// Test S3 connection (would need AWS SDK)
|
||||
res.json({ success: false, message: 'S3 testing not implemented yet' });
|
||||
break;
|
||||
|
||||
default:
|
||||
res.status(400).json({ error: 'Invalid destination type' });
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('Failed to test backup connection:', error);
|
||||
res.status(500).json({ error: 'Failed to test connection' });
|
||||
}
|
||||
});
|
||||
|
||||
// Get backup manifest for a specific backup run
|
||||
router.get('/manifest/:backupRunId', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { backupRunId } = req.params;
|
||||
const result = await getBackupManifest(backupRunId);
|
||||
|
||||
res.json({
|
||||
backupRunId,
|
||||
manifest: result.manifest,
|
||||
summary: result.summary
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup manifest:', error);
|
||||
res.status(404).json({ error: error.message || 'Backup manifest not found' });
|
||||
}
|
||||
});
|
||||
|
||||
// Validate a backup manifest
|
||||
router.post('/manifest/validate', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { manifestPath } = req.body;
|
||||
|
||||
if (!manifestPath) {
|
||||
return res.status(400).json({ error: 'manifestPath is required' });
|
||||
}
|
||||
|
||||
const result = await validateBackupManifest(manifestPath);
|
||||
|
||||
res.json({
|
||||
valid: result.valid,
|
||||
error: result.error,
|
||||
manifestPath
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to validate manifest:', error);
|
||||
res.status(500).json({ error: 'Failed to validate manifest' });
|
||||
}
|
||||
});
|
||||
|
||||
// Download backup manifest
|
||||
router.get('/manifest/:backupRunId/download', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { backupRunId } = req.params;
|
||||
const { format = 'json' } = req.query;
|
||||
|
||||
const result = await getBackupManifest(backupRunId);
|
||||
|
||||
// Set appropriate headers
|
||||
const filename = `backup-manifest-${backupRunId}.${format}`;
|
||||
res.setHeader('Content-Type', format === 'yaml' ? 'text/yaml' : 'application/json');
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
|
||||
|
||||
// Send the manifest in requested format
|
||||
if (format === 'yaml') {
|
||||
const yaml = require('js-yaml');
|
||||
res.send(yaml.dump(result.manifest, {
|
||||
indent: 2,
|
||||
lineWidth: -1,
|
||||
noRefs: true,
|
||||
sortKeys: true
|
||||
}));
|
||||
} else {
|
||||
res.json(result.manifest);
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('Failed to download backup manifest:', error);
|
||||
res.status(404).json({ error: error.message || 'Backup manifest not found' });
|
||||
}
|
||||
});
|
||||
|
||||
// Get manifest for specific backup
|
||||
router.get('/manifests/:backupId', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { backupId } = req.params;
|
||||
const result = await getBackupManifest(backupId);
|
||||
|
||||
res.json({
|
||||
backupId,
|
||||
manifest: result.manifest,
|
||||
summary: result.summary
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup manifest:', error);
|
||||
res.status(404).json({ error: error.message || 'Backup manifest not found' });
|
||||
}
|
||||
});
|
||||
|
||||
// Download manifest file
|
||||
router.get('/manifests/:backupId/download', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { backupId } = req.params;
|
||||
const { format = 'json' } = req.query;
|
||||
|
||||
const result = await getBackupManifest(backupId);
|
||||
|
||||
// Set appropriate headers
|
||||
const filename = `backup-manifest-${backupId}.${format}`;
|
||||
res.setHeader('Content-Type', format === 'yaml' ? 'text/yaml' : 'application/json');
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
|
||||
|
||||
// Send the manifest in requested format
|
||||
if (format === 'yaml') {
|
||||
const yaml = require('js-yaml');
|
||||
res.send(yaml.dump(result.manifest, {
|
||||
indent: 2,
|
||||
lineWidth: -1,
|
||||
noRefs: true,
|
||||
sortKeys: true
|
||||
}));
|
||||
} else {
|
||||
res.json(result.manifest);
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('Failed to download backup manifest:', error);
|
||||
res.status(404).json({ error: error.message || 'Backup manifest not found' });
|
||||
}
|
||||
});
|
||||
|
||||
// Validate a manifest
|
||||
router.post('/manifests/validate', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { manifestPath, manifestData } = req.body;
|
||||
|
||||
if (!manifestPath && !manifestData) {
|
||||
return res.status(400).json({ error: 'Either manifestPath or manifestData is required' });
|
||||
}
|
||||
|
||||
if (manifestData) {
|
||||
// Validate provided manifest data directly
|
||||
const validationResult = await validateManifestData(manifestData);
|
||||
return res.json(validationResult);
|
||||
}
|
||||
|
||||
// Use existing validation function for path
|
||||
const result = await validateBackupManifest(manifestPath);
|
||||
|
||||
res.json({
|
||||
valid: result.valid,
|
||||
error: result.error,
|
||||
manifestPath
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to validate manifest:', error);
|
||||
res.status(500).json({ error: 'Failed to validate manifest' });
|
||||
}
|
||||
});
|
||||
|
||||
// List S3 buckets
|
||||
router.get('/s3/buckets', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const config = await getBackupConfig();
|
||||
|
||||
if (config.backup_destination_type !== 's3') {
|
||||
return res.status(400).json({ error: 'S3 backup not configured' });
|
||||
}
|
||||
|
||||
const s3Adapter = new S3StorageAdapter({
|
||||
endpoint: config.backup_s3_endpoint,
|
||||
bucket: config.backup_s3_bucket,
|
||||
accessKeyId: config.backup_s3_access_key,
|
||||
secretAccessKey: config.backup_s3_secret_key,
|
||||
region: config.backup_s3_region || 'us-east-1',
|
||||
forcePathStyle: config.backup_s3_force_path_style || false
|
||||
});
|
||||
|
||||
// List buckets using the S3 client
|
||||
const { ListBucketsCommand } = require('@aws-sdk/client-s3');
|
||||
const result = await s3Adapter.s3Client.send(new ListBucketsCommand({}));
|
||||
|
||||
res.json({
|
||||
buckets: result.Buckets || [],
|
||||
owner: result.Owner || null
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to list S3 buckets:', error);
|
||||
res.status(500).json({ error: 'Failed to list S3 buckets: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// List files in S3 backup location
|
||||
router.get('/s3/files', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { prefix = '', maxKeys = 100, continuationToken } = req.query;
|
||||
const config = await getBackupConfig();
|
||||
|
||||
if (config.backup_destination_type !== 's3') {
|
||||
return res.status(400).json({ error: 'S3 backup not configured' });
|
||||
}
|
||||
|
||||
const s3Adapter = new S3StorageAdapter({
|
||||
endpoint: config.backup_s3_endpoint,
|
||||
bucket: config.backup_s3_bucket,
|
||||
accessKeyId: config.backup_s3_access_key,
|
||||
secretAccessKey: config.backup_s3_secret_key,
|
||||
region: config.backup_s3_region || 'us-east-1',
|
||||
forcePathStyle: config.backup_s3_force_path_style || false
|
||||
});
|
||||
|
||||
const result = await s3Adapter.list(prefix, {
|
||||
maxKeys: parseInt(maxKeys),
|
||||
continuationToken
|
||||
});
|
||||
|
||||
res.json({
|
||||
files: result.objects || [],
|
||||
directories: result.directories || [],
|
||||
isTruncated: result.isTruncated,
|
||||
nextContinuationToken: result.nextContinuationToken,
|
||||
prefix: prefix
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to list S3 files:', error);
|
||||
res.status(500).json({ error: 'Failed to list S3 files: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Clean up old S3 backups
|
||||
router.delete('/s3/cleanup', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { retentionDays = 30, dryRun = false } = req.body;
|
||||
const config = await getBackupConfig();
|
||||
|
||||
if (config.backup_destination_type !== 's3') {
|
||||
return res.status(400).json({ error: 'S3 backup not configured' });
|
||||
}
|
||||
|
||||
const s3Adapter = new S3StorageAdapter({
|
||||
endpoint: config.backup_s3_endpoint,
|
||||
bucket: config.backup_s3_bucket,
|
||||
accessKeyId: config.backup_s3_access_key,
|
||||
secretAccessKey: config.backup_s3_secret_key,
|
||||
region: config.backup_s3_region || 'us-east-1',
|
||||
forcePathStyle: config.backup_s3_force_path_style || false
|
||||
});
|
||||
|
||||
const cutoffDate = new Date();
|
||||
cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
|
||||
|
||||
// List all backup files
|
||||
const backupFiles = await s3Adapter.list('backups/', { maxKeys: 1000 });
|
||||
const filesToDelete = [];
|
||||
let totalSize = 0;
|
||||
|
||||
for (const file of backupFiles.objects || []) {
|
||||
if (file.lastModified && new Date(file.lastModified) < cutoffDate) {
|
||||
filesToDelete.push(file.key);
|
||||
totalSize += file.size || 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (dryRun) {
|
||||
return res.json({
|
||||
wouldDelete: filesToDelete.length,
|
||||
totalSize: totalSize,
|
||||
files: filesToDelete.slice(0, 100), // Limit preview
|
||||
message: 'Dry run completed - no files were deleted'
|
||||
});
|
||||
}
|
||||
|
||||
// Delete files in batches
|
||||
const deleteResult = await s3Adapter.deleteMany(filesToDelete);
|
||||
const deletedCount = deleteResult.Deleted ? deleteResult.Deleted.length : 0;
|
||||
|
||||
// Also clean up database records
|
||||
await cleanupOldBackupRuns(retentionDays);
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
deletedCount: deletedCount,
|
||||
totalSize: totalSize,
|
||||
message: `Cleaned up ${deletedCount} S3 backup files older than ${retentionDays} days`
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to cleanup S3 backups:', error);
|
||||
res.status(500).json({ error: 'Failed to cleanup S3 backups: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Test S3 upload functionality
|
||||
router.post('/s3/test-upload', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const config = await getBackupConfig();
|
||||
|
||||
if (config.backup_destination_type !== 's3') {
|
||||
return res.status(400).json({ error: 'S3 backup not configured' });
|
||||
}
|
||||
|
||||
const s3Adapter = new S3StorageAdapter({
|
||||
endpoint: config.backup_s3_endpoint,
|
||||
bucket: config.backup_s3_bucket,
|
||||
accessKeyId: config.backup_s3_access_key,
|
||||
secretAccessKey: config.backup_s3_secret_key,
|
||||
region: config.backup_s3_region || 'us-east-1',
|
||||
forcePathStyle: config.backup_s3_force_path_style || false
|
||||
});
|
||||
|
||||
// Create test content
|
||||
const testKey = `test/backup-test-${Date.now()}.txt`;
|
||||
const testContent = `PicPeak S3 backup test\nTimestamp: ${new Date().toISOString()}\nEndpoint: ${config.backup_s3_endpoint || 'AWS'}\nBucket: ${config.backup_s3_bucket}`;
|
||||
|
||||
// Test upload
|
||||
const uploadStart = Date.now();
|
||||
await s3Adapter.upload(testKey, Buffer.from(testContent));
|
||||
const uploadTime = Date.now() - uploadStart;
|
||||
|
||||
// Test download
|
||||
const downloadStart = Date.now();
|
||||
const downloadedContent = await s3Adapter.download(testKey);
|
||||
const downloadTime = Date.now() - downloadStart;
|
||||
|
||||
// Verify content
|
||||
const contentMatch = downloadedContent.toString() === testContent;
|
||||
|
||||
// Test deletion
|
||||
await s3Adapter.delete(testKey);
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
testKey: testKey,
|
||||
uploadTime: uploadTime,
|
||||
downloadTime: downloadTime,
|
||||
contentMatch: contentMatch,
|
||||
message: 'S3 upload test completed successfully'
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('S3 upload test failed:', error);
|
||||
res.status(500).json({ error: 'S3 upload test failed: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Download entire backup
|
||||
router.get('/download/:backupId', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { backupId } = req.params;
|
||||
|
||||
// Get backup run details
|
||||
const backupRun = await db('backup_runs')
|
||||
.where('id', backupId)
|
||||
.first();
|
||||
|
||||
if (!backupRun) {
|
||||
return res.status(404).json({ error: 'Backup not found' });
|
||||
}
|
||||
|
||||
if (backupRun.status !== 'completed') {
|
||||
return res.status(400).json({ error: 'Backup is not completed' });
|
||||
}
|
||||
|
||||
const config = await getBackupConfig();
|
||||
|
||||
// Handle different backup types
|
||||
switch (config.backup_destination_type) {
|
||||
case 'local':
|
||||
// Stream local backup as zip
|
||||
const backupPath = path.join(config.backup_destination_path, `backup-${backupRun.id}`);
|
||||
const archive = archiver('zip', { zlib: { level: 9 } });
|
||||
|
||||
res.attachment(`picpeak-backup-${backupRun.id}.zip`);
|
||||
archive.pipe(res);
|
||||
|
||||
// Add backup directory contents
|
||||
archive.directory(backupPath, false);
|
||||
|
||||
// Add manifest if exists
|
||||
if (backupRun.manifest_path && await fs.access(backupRun.manifest_path).then(() => true).catch(() => false)) {
|
||||
archive.file(backupRun.manifest_path, { name: 'manifest.json' });
|
||||
}
|
||||
|
||||
await archive.finalize();
|
||||
break;
|
||||
|
||||
case 's3':
|
||||
// For S3, provide pre-signed URLs or stream files
|
||||
const s3Adapter = new S3StorageAdapter({
|
||||
endpoint: config.backup_s3_endpoint,
|
||||
bucket: config.backup_s3_bucket,
|
||||
accessKeyId: config.backup_s3_access_key,
|
||||
secretAccessKey: config.backup_s3_secret_key,
|
||||
region: config.backup_s3_region || 'us-east-1',
|
||||
forcePathStyle: config.backup_s3_force_path_style || false
|
||||
});
|
||||
|
||||
// List all files for this backup
|
||||
const prefix = `backups/${backupRun.id}/`;
|
||||
const files = await s3Adapter.list(prefix, { maxKeys: 1000 });
|
||||
|
||||
// Generate pre-signed URLs
|
||||
const urls = [];
|
||||
for (const file of files.objects || []) {
|
||||
const url = await s3Adapter.getSignedUrl('getObject', file.key, { expiresIn: 3600 }); // 1 hour
|
||||
urls.push({
|
||||
key: file.key,
|
||||
size: file.size,
|
||||
url: url
|
||||
});
|
||||
}
|
||||
|
||||
res.json({
|
||||
backupId: backupRun.id,
|
||||
type: 's3',
|
||||
files: urls,
|
||||
expiresIn: 3600,
|
||||
message: 'Use the provided URLs to download individual files'
|
||||
});
|
||||
break;
|
||||
|
||||
case 'rsync':
|
||||
return res.status(400).json({ error: 'Direct download not available for rsync backups' });
|
||||
|
||||
default:
|
||||
return res.status(400).json({ error: 'Unknown backup type' });
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error('Failed to download backup:', error);
|
||||
res.status(500).json({ error: 'Failed to download backup: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Get current file checksums
|
||||
router.get('/checksums', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { path: targetPath = '', recursive = true } = req.query;
|
||||
const checksums = {};
|
||||
|
||||
// Get storage path
|
||||
const storagePath = process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');
|
||||
const basePath = targetPath ? path.join(storagePath, targetPath) : storagePath;
|
||||
|
||||
// Calculate checksums for files
|
||||
async function calculateDirChecksums(dirPath, relative = '') {
|
||||
try {
|
||||
const entries = await fs.readdir(dirPath, { withFileTypes: true });
|
||||
|
||||
for (const entry of entries) {
|
||||
const fullPath = path.join(dirPath, entry.name);
|
||||
const relativePath = path.join(relative, entry.name);
|
||||
|
||||
if (entry.isDirectory() && recursive) {
|
||||
await calculateDirChecksums(fullPath, relativePath);
|
||||
} else if (entry.isFile()) {
|
||||
const hash = crypto.createHash('sha256');
|
||||
const stream = require('fs').createReadStream(fullPath);
|
||||
|
||||
await new Promise((resolve, reject) => {
|
||||
stream.on('data', data => hash.update(data));
|
||||
stream.on('end', () => {
|
||||
checksums[relativePath] = {
|
||||
checksum: hash.digest('hex'),
|
||||
size: entry.size,
|
||||
modified: entry.mtime
|
||||
};
|
||||
resolve();
|
||||
});
|
||||
stream.on('error', reject);
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error(`Failed to calculate checksums for ${dirPath}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
await calculateDirChecksums(basePath);
|
||||
|
||||
// Also get database checksums from backup_file_states
|
||||
const dbChecksums = await db('backup_file_states')
|
||||
.select('file_path', 'checksum', 'size_bytes', 'last_modified');
|
||||
|
||||
res.json({
|
||||
currentChecksums: checksums,
|
||||
totalFiles: Object.keys(checksums).length,
|
||||
databaseChecksums: dbChecksums.reduce((acc, row) => {
|
||||
acc[row.file_path] = {
|
||||
checksum: row.checksum,
|
||||
size: row.size_bytes,
|
||||
modified: row.last_modified
|
||||
};
|
||||
return acc;
|
||||
}, {}),
|
||||
path: targetPath || '/'
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get file checksums:', error);
|
||||
res.status(500).json({ error: 'Failed to get file checksums: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Estimate backup size before running
|
||||
router.post('/estimate', adminAuth, async (req, res) => {
|
||||
try {
|
||||
const { includeArchived = true } = req.body;
|
||||
|
||||
// Get storage path
|
||||
const storagePath = process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');
|
||||
let totalSize = 0;
|
||||
let fileCount = 0;
|
||||
const breakdown = {};
|
||||
|
||||
// Estimate size for each directory
|
||||
async function estimateDir(dirPath, category) {
|
||||
let dirSize = 0;
|
||||
let dirCount = 0;
|
||||
|
||||
try {
|
||||
const entries = await fs.readdir(dirPath, { withFileTypes: true });
|
||||
|
||||
for (const entry of entries) {
|
||||
const fullPath = path.join(dirPath, entry.name);
|
||||
|
||||
if (entry.isDirectory()) {
|
||||
const subResult = await estimateDir(fullPath, category);
|
||||
dirSize += subResult.size;
|
||||
dirCount += subResult.count;
|
||||
} else if (entry.isFile()) {
|
||||
const stats = await fs.stat(fullPath);
|
||||
dirSize += stats.size;
|
||||
dirCount++;
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
if (error.code !== 'ENOENT') {
|
||||
logger.error(`Failed to estimate ${dirPath}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
return { size: dirSize, count: dirCount };
|
||||
}
|
||||
|
||||
// Estimate each category
|
||||
const categories = [
|
||||
{ path: 'events/active', name: 'Active Events' },
|
||||
{ path: 'thumbnails', name: 'Thumbnails' },
|
||||
{ path: 'uploads', name: 'Uploads' }
|
||||
];
|
||||
|
||||
if (includeArchived) {
|
||||
categories.push({ path: 'events/archived', name: 'Archived Events' });
|
||||
}
|
||||
|
||||
for (const category of categories) {
|
||||
const result = await estimateDir(path.join(storagePath, category.path), category.name);
|
||||
breakdown[category.name] = {
|
||||
size: result.size,
|
||||
sizeFormatted: formatBytes(result.size),
|
||||
fileCount: result.count
|
||||
};
|
||||
totalSize += result.size;
|
||||
fileCount += result.count;
|
||||
}
|
||||
|
||||
// Estimate database size
|
||||
const dbPath = process.env.DB_TYPE === 'postgresql'
|
||||
? null
|
||||
: path.join(__dirname, '../../database.sqlite');
|
||||
|
||||
if (dbPath) {
|
||||
try {
|
||||
const dbStats = await fs.stat(dbPath);
|
||||
breakdown['Database'] = {
|
||||
size: dbStats.size,
|
||||
sizeFormatted: formatBytes(dbStats.size),
|
||||
fileCount: 1
|
||||
};
|
||||
totalSize += dbStats.size;
|
||||
fileCount += 1;
|
||||
} catch (error) {
|
||||
logger.error('Failed to get database size:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Estimate compression ratio (typically 20-40% for mixed media)
|
||||
const estimatedCompressedSize = Math.round(totalSize * 0.7);
|
||||
|
||||
res.json({
|
||||
totalSize: totalSize,
|
||||
totalSizeFormatted: formatBytes(totalSize),
|
||||
estimatedCompressedSize: estimatedCompressedSize,
|
||||
estimatedCompressedSizeFormatted: formatBytes(estimatedCompressedSize),
|
||||
fileCount: fileCount,
|
||||
breakdown: breakdown,
|
||||
includeArchived: includeArchived,
|
||||
estimatedDuration: Math.max(60, Math.round(totalSize / (50 * 1024 * 1024))), // Estimate 50MB/s
|
||||
warnings: totalSize > 10 * 1024 * 1024 * 1024 ? ['Backup size exceeds 10GB, may take significant time'] : []
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to estimate backup size:', error);
|
||||
res.status(500).json({ error: 'Failed to estimate backup size: ' + error.message });
|
||||
}
|
||||
});
|
||||
|
||||
// Helper function to format bytes
|
||||
function formatBytes(bytes, decimals = 2) {
|
||||
if (bytes === 0) return '0 Bytes';
|
||||
const k = 1024;
|
||||
const dm = decimals < 0 ? 0 : decimals;
|
||||
const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
|
||||
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
||||
return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
|
||||
}
|
||||
|
||||
// Helper function to get backup configuration
|
||||
async function getBackupConfig() {
|
||||
try {
|
||||
const settings = await db('app_settings')
|
||||
.where('setting_type', 'backup')
|
||||
.select('setting_key', 'setting_value');
|
||||
|
||||
const config = {};
|
||||
settings.forEach(setting => {
|
||||
try {
|
||||
config[setting.setting_key] = JSON.parse(setting.setting_value);
|
||||
} catch (e) {
|
||||
config[setting.setting_key] = setting.setting_value;
|
||||
}
|
||||
});
|
||||
|
||||
return config;
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup configuration:', error);
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function to validate manifest data
|
||||
async function validateManifestData(manifestData) {
|
||||
try {
|
||||
// Check required fields
|
||||
const requiredFields = ['version', 'backupId', 'timestamp', 'files'];
|
||||
const missingFields = requiredFields.filter(field => !manifestData[field]);
|
||||
|
||||
if (missingFields.length > 0) {
|
||||
return {
|
||||
valid: false,
|
||||
error: `Missing required fields: ${missingFields.join(', ')}`,
|
||||
details: { missingFields }
|
||||
};
|
||||
}
|
||||
|
||||
// Validate version
|
||||
if (manifestData.version !== '1.0') {
|
||||
return {
|
||||
valid: false,
|
||||
error: `Unsupported manifest version: ${manifestData.version}`,
|
||||
details: { version: manifestData.version }
|
||||
};
|
||||
}
|
||||
|
||||
// Validate files array
|
||||
if (!Array.isArray(manifestData.files)) {
|
||||
return {
|
||||
valid: false,
|
||||
error: 'Files must be an array',
|
||||
details: { filesType: typeof manifestData.files }
|
||||
};
|
||||
}
|
||||
|
||||
// Validate each file entry
|
||||
const invalidFiles = [];
|
||||
for (let i = 0; i < manifestData.files.length; i++) {
|
||||
const file = manifestData.files[i];
|
||||
if (!file.path || !file.checksum || typeof file.size !== 'number') {
|
||||
invalidFiles.push({ index: i, file });
|
||||
}
|
||||
}
|
||||
|
||||
if (invalidFiles.length > 0) {
|
||||
return {
|
||||
valid: false,
|
||||
error: `Invalid file entries: ${invalidFiles.length}`,
|
||||
details: { invalidFiles: invalidFiles.slice(0, 10) } // Limit to first 10
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
valid: true,
|
||||
details: {
|
||||
version: manifestData.version,
|
||||
backupId: manifestData.backupId,
|
||||
timestamp: manifestData.timestamp,
|
||||
fileCount: manifestData.files.length,
|
||||
totalSize: manifestData.files.reduce((sum, f) => sum + (f.size || 0), 0)
|
||||
}
|
||||
};
|
||||
} catch (error) {
|
||||
return {
|
||||
valid: false,
|
||||
error: `Validation error: ${error.message}`,
|
||||
details: { error: error.message }
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = router;
|
||||
@@ -0,0 +1,273 @@
|
||||
const express = require('express');
|
||||
const router = express.Router();
|
||||
const { adminAuth } = require('../middleware/auth');
|
||||
const { databaseBackupService } = require('../services/databaseBackup');
|
||||
const { db } = require('../database/db');
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
// All routes require admin authentication
|
||||
router.use(adminAuth);
|
||||
|
||||
/**
|
||||
* Get database backup status and configuration
|
||||
*/
|
||||
router.get('/status', async (req, res) => {
|
||||
try {
|
||||
// Get configuration
|
||||
const config = await databaseBackupService.getBackupConfig();
|
||||
|
||||
// Get recent backup history
|
||||
const history = await databaseBackupService.getBackupHistory(10);
|
||||
|
||||
// Get current progress if running
|
||||
const progress = databaseBackupService.getProgress();
|
||||
|
||||
// Calculate health status
|
||||
const lastBackup = history[0];
|
||||
const isHealthy = lastBackup && lastBackup.status === 'completed' &&
|
||||
new Date(lastBackup.completed_at) > new Date(Date.now() - 48 * 60 * 60 * 1000); // Within 48 hours
|
||||
|
||||
res.json({
|
||||
config,
|
||||
isRunning: databaseBackupService.isRunning,
|
||||
isHealthy,
|
||||
currentProgress: progress,
|
||||
lastBackup,
|
||||
recentBackups: history,
|
||||
dbType: databaseBackupService.dbType
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get database backup status:', error);
|
||||
res.status(500).json({ error: 'Failed to get backup status' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Update database backup configuration
|
||||
*/
|
||||
router.put('/config', async (req, res) => {
|
||||
try {
|
||||
const allowedSettings = [
|
||||
'database_backup_enabled',
|
||||
'database_backup_schedule',
|
||||
'database_backup_destination_path',
|
||||
'database_backup_compress',
|
||||
'database_backup_validate_integrity',
|
||||
'database_backup_include_checksums',
|
||||
'database_backup_retention_days',
|
||||
'database_backup_email_on_failure',
|
||||
'database_backup_email_on_success'
|
||||
];
|
||||
|
||||
const updates = [];
|
||||
|
||||
for (const [key, value] of Object.entries(req.body)) {
|
||||
if (allowedSettings.includes(key)) {
|
||||
// Check if setting exists
|
||||
const existing = await db('app_settings')
|
||||
.where('setting_key', key)
|
||||
.first();
|
||||
|
||||
if (existing) {
|
||||
await db('app_settings')
|
||||
.where('setting_key', key)
|
||||
.update({
|
||||
setting_value: JSON.stringify(value),
|
||||
updated_at: new Date()
|
||||
});
|
||||
} else {
|
||||
await db('app_settings').insert({
|
||||
setting_key: key,
|
||||
setting_value: JSON.stringify(value),
|
||||
setting_type: 'database_backup'
|
||||
});
|
||||
}
|
||||
|
||||
updates.push(key);
|
||||
}
|
||||
}
|
||||
|
||||
// Restart scheduled backups if enabled state changed
|
||||
if (updates.includes('database_backup_enabled') || updates.includes('database_backup_schedule')) {
|
||||
const { startScheduledBackups, stopScheduledBackups } = require('../services/databaseBackup');
|
||||
stopScheduledBackups();
|
||||
await startScheduledBackups();
|
||||
}
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
updatedSettings: updates,
|
||||
message: 'Database backup configuration updated successfully'
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to update database backup config:', error);
|
||||
res.status(500).json({ error: 'Failed to update configuration' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Trigger manual database backup
|
||||
*/
|
||||
router.post('/backup', async (req, res) => {
|
||||
try {
|
||||
if (databaseBackupService.isRunning) {
|
||||
return res.status(409).json({ error: 'Backup already in progress' });
|
||||
}
|
||||
|
||||
// Start backup asynchronously
|
||||
res.json({
|
||||
success: true,
|
||||
message: 'Database backup started',
|
||||
trackingUrl: '/api/admin/database-backup/progress'
|
||||
});
|
||||
|
||||
// Run backup in background
|
||||
databaseBackupService.backup(req.body).catch(error => {
|
||||
logger.error('Manual database backup failed:', error);
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to start database backup:', error);
|
||||
res.status(500).json({ error: 'Failed to start backup' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get current backup progress
|
||||
*/
|
||||
router.get('/progress', async (req, res) => {
|
||||
try {
|
||||
const progress = databaseBackupService.getProgress();
|
||||
|
||||
res.json({
|
||||
isRunning: databaseBackupService.isRunning,
|
||||
progress
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup progress:', error);
|
||||
res.status(500).json({ error: 'Failed to get progress' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get backup history with pagination
|
||||
*/
|
||||
router.get('/history', async (req, res) => {
|
||||
try {
|
||||
const page = parseInt(req.query.page) || 1;
|
||||
const limit = parseInt(req.query.limit) || 20;
|
||||
const offset = (page - 1) * limit;
|
||||
|
||||
const [backups, totalCount] = await Promise.all([
|
||||
db('database_backup_runs')
|
||||
.orderBy('started_at', 'desc')
|
||||
.limit(limit)
|
||||
.offset(offset),
|
||||
db('database_backup_runs').count('* as count').first()
|
||||
]);
|
||||
|
||||
res.json({
|
||||
backups,
|
||||
pagination: {
|
||||
page,
|
||||
limit,
|
||||
total: totalCount.count,
|
||||
pages: Math.ceil(totalCount.count / limit)
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get backup history:', error);
|
||||
res.status(500).json({ error: 'Failed to get history' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Delete old backup files
|
||||
*/
|
||||
router.delete('/cleanup', async (req, res) => {
|
||||
try {
|
||||
const { retentionDays = 30 } = req.body;
|
||||
|
||||
await databaseBackupService.cleanupOldBackups(retentionDays);
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
message: `Cleaned up backups older than ${retentionDays} days`
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to cleanup old backups:', error);
|
||||
res.status(500).json({ error: 'Failed to cleanup backups' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Test database backup configuration
|
||||
*/
|
||||
router.post('/test', async (req, res) => {
|
||||
try {
|
||||
const config = await databaseBackupService.getBackupConfig();
|
||||
|
||||
// Test database connection
|
||||
const testResults = {
|
||||
databaseConnection: false,
|
||||
destinationWritable: false,
|
||||
compressionAvailable: true,
|
||||
estimatedSize: null
|
||||
};
|
||||
|
||||
// Test database connection
|
||||
try {
|
||||
await db.raw('SELECT 1');
|
||||
testResults.databaseConnection = true;
|
||||
} catch (error) {
|
||||
testResults.databaseConnectionError = error.message;
|
||||
}
|
||||
|
||||
// Test destination path
|
||||
if (config.destinationPath) {
|
||||
try {
|
||||
const fs = require('fs').promises;
|
||||
const testFile = `${config.destinationPath}/.test-${Date.now()}`;
|
||||
await fs.writeFile(testFile, 'test');
|
||||
await fs.unlink(testFile);
|
||||
testResults.destinationWritable = true;
|
||||
} catch (error) {
|
||||
testResults.destinationError = error.message;
|
||||
}
|
||||
}
|
||||
|
||||
// Estimate database size
|
||||
try {
|
||||
testResults.estimatedSize = await databaseBackupService.getDatabaseSize();
|
||||
} catch (error) {
|
||||
testResults.sizeError = error.message;
|
||||
}
|
||||
|
||||
res.json({
|
||||
success: testResults.databaseConnection && testResults.destinationWritable,
|
||||
results: testResults
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to test backup configuration:', error);
|
||||
res.status(500).json({ error: 'Failed to test configuration' });
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get table checksums
|
||||
*/
|
||||
router.get('/checksums', async (req, res) => {
|
||||
try {
|
||||
const checksums = await databaseBackupService.getTableChecksums();
|
||||
|
||||
res.json({
|
||||
checksums,
|
||||
tableCount: Object.keys(checksums).length,
|
||||
totalRows: Object.values(checksums).reduce((sum, table) => sum + table.rowCount, 0)
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get table checksums:', error);
|
||||
res.status(500).json({ error: 'Failed to get checksums' });
|
||||
}
|
||||
});
|
||||
|
||||
module.exports = router;
|
||||
@@ -0,0 +1,461 @@
|
||||
const express = require('express');
|
||||
const router = express.Router();
|
||||
const { restoreService } = require('../services/restoreService');
|
||||
const { adminAuth } = require('../middleware/auth');
|
||||
const { body, query, validationResult } = require('express-validator');
|
||||
const logger = require('../utils/logger');
|
||||
const { db } = require('../database/db');
|
||||
const path = require('path');
|
||||
const fs = require('fs').promises;
|
||||
|
||||
/**
|
||||
* Admin routes for restore operations
|
||||
* All routes require admin authentication
|
||||
*/
|
||||
|
||||
// Apply admin authentication to all routes
|
||||
router.use(adminAuth);
|
||||
|
||||
/**
|
||||
* Get restore service status and history
|
||||
*/
|
||||
router.get('/status', async (req, res) => {
|
||||
try {
|
||||
const limit = parseInt(req.query.limit) || 10;
|
||||
const history = await restoreService.getRestoreHistory(limit);
|
||||
|
||||
const status = {
|
||||
isRunning: restoreService.isRunning,
|
||||
currentProgress: restoreService.getProgress(),
|
||||
history: history,
|
||||
settings: await getRestoreSettings()
|
||||
};
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
data: status
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get restore status:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to get restore status'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Validate restore request
|
||||
*/
|
||||
router.post('/validate', [
|
||||
body('source').notEmpty().withMessage('Backup source is required'),
|
||||
body('manifestPath').notEmpty().withMessage('Manifest path is required'),
|
||||
body('restoreType').isIn(['full', 'database', 'files', 'selective']).withMessage('Invalid restore type'),
|
||||
body('selectedItems').optional().isArray(),
|
||||
body('s3Config').optional().isObject()
|
||||
], async (req, res) => {
|
||||
const errors = validationResult(req);
|
||||
if (!errors.isEmpty()) {
|
||||
return res.status(400).json({
|
||||
success: false,
|
||||
errors: errors.array()
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
// Perform dry run validation
|
||||
const result = await restoreService.restore({
|
||||
...req.body,
|
||||
dryRun: true,
|
||||
force: false
|
||||
});
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
data: {
|
||||
validation: result.validation,
|
||||
spaceCheck: result.spaceCheck,
|
||||
logs: result.logs
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Restore validation failed:', error);
|
||||
res.status(400).json({
|
||||
success: false,
|
||||
error: error.message,
|
||||
logs: restoreService.restoreLog
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Start restore operation
|
||||
*/
|
||||
router.post('/start', [
|
||||
body('source').notEmpty().withMessage('Backup source is required'),
|
||||
body('manifestPath').notEmpty().withMessage('Manifest path is required'),
|
||||
body('restoreType').isIn(['full', 'database', 'files', 'selective']).withMessage('Invalid restore type'),
|
||||
body('selectedItems').optional().isArray(),
|
||||
body('skipPreBackup').optional().isBoolean(),
|
||||
body('force').optional().isBoolean(),
|
||||
body('s3Config').optional().isObject()
|
||||
], async (req, res) => {
|
||||
const errors = validationResult(req);
|
||||
if (!errors.isEmpty()) {
|
||||
return res.status(400).json({
|
||||
success: false,
|
||||
errors: errors.array()
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
// Check if restore is already running
|
||||
if (restoreService.isRunning) {
|
||||
return res.status(409).json({
|
||||
success: false,
|
||||
error: 'Restore operation already in progress'
|
||||
});
|
||||
}
|
||||
|
||||
// Check permissions for dangerous options
|
||||
const settings = await getRestoreSettings();
|
||||
if (req.body.force && !settings.restore_allow_force) {
|
||||
return res.status(403).json({
|
||||
success: false,
|
||||
error: 'Force restore is not allowed by system settings'
|
||||
});
|
||||
}
|
||||
|
||||
if (req.body.skipPreBackup && settings.restore_require_pre_backup) {
|
||||
return res.status(403).json({
|
||||
success: false,
|
||||
error: 'Skipping pre-restore backup is not allowed by system settings'
|
||||
});
|
||||
}
|
||||
|
||||
// Log restore attempt
|
||||
logger.warn('Restore operation started', {
|
||||
user: req.user.email,
|
||||
ip: req.ip,
|
||||
restoreType: req.body.restoreType,
|
||||
source: req.body.source
|
||||
});
|
||||
|
||||
// Start restore in background
|
||||
restoreService.restore({
|
||||
...req.body,
|
||||
dryRun: false,
|
||||
operator: {
|
||||
type: 'manual',
|
||||
userId: req.user.id,
|
||||
ip: req.ip
|
||||
}
|
||||
}).catch(error => {
|
||||
logger.error('Background restore failed:', error);
|
||||
});
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
message: 'Restore operation started'
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to start restore:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: error.message
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get current restore progress
|
||||
*/
|
||||
router.get('/progress', async (req, res) => {
|
||||
try {
|
||||
const progress = restoreService.getProgress();
|
||||
const logs = restoreService.restoreLog.slice(-50); // Last 50 log entries
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
data: {
|
||||
isRunning: restoreService.isRunning,
|
||||
progress: progress,
|
||||
logs: logs
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get restore progress:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to get restore progress'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get restore run details
|
||||
*/
|
||||
router.get('/run/:id', async (req, res) => {
|
||||
try {
|
||||
const run = await db('restore_runs')
|
||||
.where('id', req.params.id)
|
||||
.first();
|
||||
|
||||
if (!run) {
|
||||
return res.status(404).json({
|
||||
success: false,
|
||||
error: 'Restore run not found'
|
||||
});
|
||||
}
|
||||
|
||||
// Parse JSON fields
|
||||
if (run.statistics) run.statistics = JSON.parse(run.statistics);
|
||||
if (run.restore_log) run.restore_log = JSON.parse(run.restore_log);
|
||||
if (run.metadata) run.metadata = JSON.parse(run.metadata);
|
||||
|
||||
// Get validation results
|
||||
const validations = await db('restore_validation_results')
|
||||
.where('restore_run_id', run.id)
|
||||
.select('*');
|
||||
|
||||
validations.forEach(v => {
|
||||
if (v.errors) v.errors = JSON.parse(v.errors);
|
||||
if (v.warnings) v.warnings = JSON.parse(v.warnings);
|
||||
if (v.checksums) v.checksums = JSON.parse(v.checksums);
|
||||
});
|
||||
|
||||
// Get file operations summary
|
||||
const fileOps = await db('restore_file_operations')
|
||||
.where('restore_run_id', run.id)
|
||||
.select('status', db.raw('COUNT(*) as count'))
|
||||
.groupBy('status');
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
data: {
|
||||
run: run,
|
||||
validations: validations,
|
||||
fileOperations: fileOps
|
||||
}
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get restore run details:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to get restore run details'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get restore run report
|
||||
*/
|
||||
router.get('/run/:id/report', async (req, res) => {
|
||||
try {
|
||||
const run = await db('restore_runs')
|
||||
.where('id', req.params.id)
|
||||
.first();
|
||||
|
||||
if (!run) {
|
||||
return res.status(404).json({
|
||||
success: false,
|
||||
error: 'Restore run not found'
|
||||
});
|
||||
}
|
||||
|
||||
// Parse JSON fields
|
||||
if (run.statistics) run.statistics = JSON.parse(run.statistics);
|
||||
if (run.restore_log) run.restore_log = JSON.parse(run.restore_log);
|
||||
|
||||
// Generate report
|
||||
const report = restoreService.generateRestoreReport({
|
||||
success: run.status === 'completed',
|
||||
duration: run.duration_seconds,
|
||||
dryRun: run.is_dry_run,
|
||||
result: run.statistics,
|
||||
logs: run.restore_log || []
|
||||
});
|
||||
|
||||
res.type('text/plain').send(report);
|
||||
} catch (error) {
|
||||
logger.error('Failed to generate restore report:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to generate restore report'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* List available backups for restore
|
||||
*/
|
||||
router.get('/available-backups', async (req, res) => {
|
||||
try {
|
||||
const backups = [];
|
||||
|
||||
// Get local file backups
|
||||
const backupConfig = await getBackupConfig();
|
||||
if (backupConfig.backup_destination_type === 'local' && backupConfig.backup_destination_path) {
|
||||
try {
|
||||
const files = await fs.readdir(backupConfig.backup_destination_path);
|
||||
for (const file of files) {
|
||||
if (file.endsWith('.json') || file.endsWith('.yaml')) {
|
||||
const filePath = path.join(backupConfig.backup_destination_path, file);
|
||||
const stats = await fs.stat(filePath);
|
||||
backups.push({
|
||||
type: 'local',
|
||||
name: file,
|
||||
path: filePath,
|
||||
size: stats.size,
|
||||
modified: stats.mtime
|
||||
});
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
logger.warn('Failed to list local backups:', error);
|
||||
}
|
||||
}
|
||||
|
||||
// Get database backups from backup_runs table
|
||||
const backupRuns = await db('backup_runs')
|
||||
.where('status', 'completed')
|
||||
.whereNotNull('manifest_path')
|
||||
.orderBy('completed_at', 'desc')
|
||||
.limit(20);
|
||||
|
||||
for (const run of backupRuns) {
|
||||
backups.push({
|
||||
type: run.manifest_path.startsWith('s3://') ? 's3' : 'local',
|
||||
name: `Backup ${run.completed_at}`,
|
||||
path: run.manifest_path,
|
||||
manifestId: run.manifest_id,
|
||||
size: run.total_size_bytes,
|
||||
filesCount: run.files_backed_up,
|
||||
duration: run.duration_seconds,
|
||||
completed: run.completed_at
|
||||
});
|
||||
}
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
data: backups
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to list available backups:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to list available backups'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Get restore settings
|
||||
*/
|
||||
router.get('/settings', async (req, res) => {
|
||||
try {
|
||||
const settings = await getRestoreSettings();
|
||||
res.json({
|
||||
success: true,
|
||||
data: settings
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to get restore settings:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to get restore settings'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Update restore settings
|
||||
*/
|
||||
router.put('/settings', [
|
||||
body('restore_allow_force').optional().isBoolean(),
|
||||
body('restore_require_pre_backup').optional().isBoolean(),
|
||||
body('restore_max_file_size_mb').optional().isInt({ min: 1 }),
|
||||
body('restore_verify_checksums').optional().isBoolean(),
|
||||
body('restore_email_on_completion').optional().isBoolean(),
|
||||
body('restore_retention_days').optional().isInt({ min: 1 })
|
||||
], async (req, res) => {
|
||||
const errors = validationResult(req);
|
||||
if (!errors.isEmpty()) {
|
||||
return res.status(400).json({
|
||||
success: false,
|
||||
errors: errors.array()
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
// Update settings
|
||||
for (const [key, value] of Object.entries(req.body)) {
|
||||
await db('app_settings')
|
||||
.where('setting_key', key)
|
||||
.where('setting_type', 'restore')
|
||||
.update({
|
||||
setting_value: typeof value === 'boolean' ? (value ? '1' : '0') : value.toString(),
|
||||
updated_at: db.fn.now()
|
||||
});
|
||||
}
|
||||
|
||||
logger.info('Restore settings updated', {
|
||||
user: req.user.email,
|
||||
settings: req.body
|
||||
});
|
||||
|
||||
res.json({
|
||||
success: true,
|
||||
message: 'Settings updated successfully'
|
||||
});
|
||||
} catch (error) {
|
||||
logger.error('Failed to update restore settings:', error);
|
||||
res.status(500).json({
|
||||
success: false,
|
||||
error: 'Failed to update settings'
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Helper function to get restore settings
|
||||
*/
|
||||
async function getRestoreSettings() {
|
||||
const settings = await db('app_settings')
|
||||
.where('setting_type', 'restore')
|
||||
.select('setting_key', 'setting_value');
|
||||
|
||||
const result = {};
|
||||
settings.forEach(setting => {
|
||||
// Convert boolean strings to actual booleans
|
||||
if (setting.setting_value === '1' || setting.setting_value === '0') {
|
||||
result[setting.setting_key] = setting.setting_value === '1';
|
||||
} else {
|
||||
result[setting.setting_key] = setting.setting_value;
|
||||
}
|
||||
});
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to get backup configuration
|
||||
*/
|
||||
async function getBackupConfig() {
|
||||
const settings = await db('app_settings')
|
||||
.where('setting_type', 'backup')
|
||||
.select('setting_key', 'setting_value');
|
||||
|
||||
const config = {};
|
||||
settings.forEach(setting => {
|
||||
try {
|
||||
config[setting.setting_key] = JSON.parse(setting.setting_value);
|
||||
} catch (e) {
|
||||
config[setting.setting_key] = setting.setting_value;
|
||||
}
|
||||
});
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
module.exports = router;
|
||||
Reference in New Issue
Block a user