mirror of
https://github.com/Part-DB/Part-DB-server.git
synced 2026-02-11 20:19:36 +00:00
453 lines
17 KiB
PHP
453 lines
17 KiB
PHP
<?php
|
|
/*
|
|
* This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
|
|
*
|
|
* Copyright (C) 2019 - 2024 Jan Böhmer (https://github.com/jbtronics)
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published
|
|
* by the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Services\System;
|
|
|
|
use Doctrine\ORM\EntityManagerInterface;
|
|
use Psr\Log\LoggerInterface;
|
|
use Shivas\VersioningBundle\Service\VersionManagerInterface;
|
|
use Symfony\Component\DependencyInjection\Attribute\Autowire;
|
|
use Symfony\Component\Filesystem\Filesystem;
|
|
use Symfony\Component\Process\Process;
|
|
|
|
/**
|
|
* Manages Part-DB backups: creation, restoration, and listing.
|
|
*
|
|
* This service handles all backup-related operations and can be used
|
|
* by the Update Manager, CLI commands, or other services.
|
|
*/
|
|
readonly class BackupManager
|
|
{
|
|
private const BACKUP_DIR = 'var/backups';
|
|
|
|
public function __construct(
|
|
#[Autowire(param: 'kernel.project_dir')]
|
|
private string $projectDir,
|
|
private LoggerInterface $logger,
|
|
private Filesystem $filesystem,
|
|
private VersionManagerInterface $versionManager,
|
|
private EntityManagerInterface $entityManager,
|
|
private CommandRunHelper $commandRunHelper,
|
|
) {
|
|
}
|
|
|
|
/**
|
|
* Get the backup directory path.
|
|
*/
|
|
public function getBackupDir(): string
|
|
{
|
|
return $this->projectDir . '/' . self::BACKUP_DIR;
|
|
}
|
|
|
|
/**
|
|
* Get the current version string for use in filenames.
|
|
*/
|
|
private function getCurrentVersionString(): string
|
|
{
|
|
return $this->versionManager->getVersion()->toString();
|
|
}
|
|
|
|
/**
|
|
* Create a backup before updating.
|
|
*
|
|
* @param string|null $targetVersion Optional target version for naming
|
|
* @param string|null $prefix Optional prefix for the backup filename
|
|
* @return string The path to the created backup file
|
|
*/
|
|
public function createBackup(?string $targetVersion = null, ?string $prefix = 'backup'): string
|
|
{
|
|
$backupDir = $this->getBackupDir();
|
|
|
|
if (!is_dir($backupDir)) {
|
|
$this->filesystem->mkdir($backupDir, 0755);
|
|
}
|
|
|
|
$currentVersion = $this->getCurrentVersionString();
|
|
|
|
// Build filename
|
|
if ($targetVersion) {
|
|
$targetVersionClean = preg_replace('/[^a-zA-Z0-9\.]/', '', $targetVersion);
|
|
$backupFile = $backupDir . '/pre-update-v' . $currentVersion . '-to-' . $targetVersionClean . '-' . date('Y-m-d-His') . '.zip';
|
|
} else {
|
|
$backupFile = $backupDir . '/' . $prefix . '-v' . $currentVersion . '-' . date('Y-m-d-His') . '.zip';
|
|
}
|
|
|
|
$this->commandRunHelper->runCommand([
|
|
'php', 'bin/console', 'partdb:backup',
|
|
'--full',
|
|
'--overwrite',
|
|
$backupFile,
|
|
], 'Create backup', 600);
|
|
|
|
$this->logger->info('Created backup', ['file' => $backupFile]);
|
|
|
|
return $backupFile;
|
|
}
|
|
|
|
/**
|
|
* Get list of backups, that are available, sorted by date descending.
|
|
*
|
|
* @return array<array{file: string, path: string, date: int, size: int}>
|
|
*/
|
|
public function getBackups(): array
|
|
{
|
|
$backupDir = $this->getBackupDir();
|
|
|
|
if (!is_dir($backupDir)) {
|
|
return [];
|
|
}
|
|
|
|
$backups = [];
|
|
foreach (glob($backupDir . '/*.zip') as $backupFile) {
|
|
$backups[] = [
|
|
'file' => basename($backupFile),
|
|
'path' => $backupFile,
|
|
'date' => filemtime($backupFile),
|
|
'size' => filesize($backupFile),
|
|
];
|
|
}
|
|
|
|
// Sort by date descending
|
|
usort($backups, static fn($a, $b) => $b['date'] <=> $a['date']);
|
|
|
|
return $backups;
|
|
}
|
|
|
|
/**
|
|
* Get details about a specific backup file.
|
|
*
|
|
* @param string $filename The backup filename
|
|
* @return null|array{file: string, path: string, date: int, size: int, from_version: ?string, to_version: ?string, contains_database?: bool, contains_config?: bool, contains_attachments?: bool} Backup details or null if not found
|
|
*/
|
|
public function getBackupDetails(string $filename): ?array
|
|
{
|
|
$backupDir = $this->getBackupDir();
|
|
$backupPath = $backupDir . '/' . basename($filename);
|
|
|
|
if (!file_exists($backupPath) || !str_ends_with($backupPath, '.zip')) {
|
|
return null;
|
|
}
|
|
|
|
// Parse version info from filename: pre-update-v2.5.1-to-v2.5.0-2024-01-30-185400.zip
|
|
$info = [
|
|
'file' => basename($backupPath),
|
|
'path' => $backupPath,
|
|
'date' => filemtime($backupPath),
|
|
'size' => filesize($backupPath),
|
|
'from_version' => null,
|
|
'to_version' => null,
|
|
];
|
|
|
|
if (preg_match('/pre-update-v([\d.]+)-to-v?([\d.]+)-/', $filename, $matches)) {
|
|
$info['from_version'] = $matches[1];
|
|
$info['to_version'] = $matches[2];
|
|
}
|
|
|
|
// Check what the backup contains by reading the ZIP
|
|
try {
|
|
$zip = new \ZipArchive();
|
|
if ($zip->open($backupPath) === true) {
|
|
$info['contains_database'] = $zip->locateName('database.sql') !== false || $zip->locateName('var/app.db') !== false;
|
|
$info['contains_config'] = $zip->locateName('.env.local') !== false || $zip->locateName('config/parameters.yaml') !== false;
|
|
$info['contains_attachments'] = $zip->locateName('public/media/') !== false || $zip->locateName('uploads/') !== false;
|
|
$zip->close();
|
|
}
|
|
} catch (\Exception $e) {
|
|
$this->logger->warning('Could not read backup ZIP contents', ['error' => $e->getMessage()]);
|
|
}
|
|
|
|
return $info;
|
|
}
|
|
|
|
/**
|
|
* Delete a backup file.
|
|
*
|
|
* @param string $filename The backup filename to delete
|
|
* @return bool True if deleted successfully
|
|
*/
|
|
public function deleteBackup(string $filename): bool
|
|
{
|
|
$backupDir = $this->getBackupDir();
|
|
$backupPath = $backupDir . '/' . basename($filename);
|
|
|
|
if (!file_exists($backupPath) || !str_ends_with($backupPath, '.zip')) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
$this->filesystem->remove($backupPath);
|
|
$this->logger->info('Deleted backup', ['file' => $filename]);
|
|
return true;
|
|
} catch (\Exception $e) {
|
|
$this->logger->error('Failed to delete backup', ['file' => $filename, 'error' => $e->getMessage()]);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restore from a backup file.
|
|
*
|
|
* @param string $filename The backup filename to restore
|
|
* @param bool $restoreDatabase Whether to restore the database
|
|
* @param bool $restoreConfig Whether to restore config files
|
|
* @param bool $restoreAttachments Whether to restore attachments
|
|
* @param callable|null $onProgress Callback for progress updates
|
|
* @return array{success: bool, steps: array, error: ?string}
|
|
*/
|
|
public function restoreBackup(
|
|
string $filename,
|
|
bool $restoreDatabase = true,
|
|
bool $restoreConfig = false,
|
|
bool $restoreAttachments = false,
|
|
?callable $onProgress = null
|
|
): array {
|
|
$steps = [];
|
|
$startTime = microtime(true);
|
|
|
|
$log = function (string $step, string $message, bool $success, ?float $duration = null) use (&$steps, $onProgress): void {
|
|
$entry = [
|
|
'step' => $step,
|
|
'message' => $message,
|
|
'success' => $success,
|
|
'timestamp' => (new \DateTime())->format('c'),
|
|
'duration' => $duration,
|
|
];
|
|
$steps[] = $entry;
|
|
$this->logger->info('[Restore] ' . $step . ': ' . $message, ['success' => $success]);
|
|
|
|
if ($onProgress) {
|
|
$onProgress($entry);
|
|
}
|
|
};
|
|
|
|
try {
|
|
// Validate backup file
|
|
$backupDir = $this->getBackupDir();
|
|
$backupPath = $backupDir . '/' . basename($filename);
|
|
|
|
if (!file_exists($backupPath)) {
|
|
throw new \RuntimeException('Backup file not found: ' . $filename);
|
|
}
|
|
|
|
$stepStart = microtime(true);
|
|
|
|
// Step 1: Extract backup to temp directory
|
|
$tempDir = sys_get_temp_dir() . '/partdb_restore_' . uniqid();
|
|
$this->filesystem->mkdir($tempDir);
|
|
|
|
$zip = new \ZipArchive();
|
|
if ($zip->open($backupPath) !== true) {
|
|
throw new \RuntimeException('Could not open backup ZIP file');
|
|
}
|
|
$zip->extractTo($tempDir);
|
|
$zip->close();
|
|
$log('extract', 'Extracted backup to temporary directory', true, microtime(true) - $stepStart);
|
|
|
|
// Step 2: Restore database if requested and present
|
|
if ($restoreDatabase) {
|
|
$stepStart = microtime(true);
|
|
$this->restoreDatabaseFromBackup($tempDir);
|
|
$log('database', 'Restored database', true, microtime(true) - $stepStart);
|
|
}
|
|
|
|
// Step 3: Restore config files if requested and present
|
|
if ($restoreConfig) {
|
|
$stepStart = microtime(true);
|
|
$this->restoreConfigFromBackup($tempDir);
|
|
$log('config', 'Restored configuration files', true, microtime(true) - $stepStart);
|
|
}
|
|
|
|
// Step 4: Restore attachments if requested and present
|
|
if ($restoreAttachments) {
|
|
$stepStart = microtime(true);
|
|
$this->restoreAttachmentsFromBackup($tempDir);
|
|
$log('attachments', 'Restored attachments', true, microtime(true) - $stepStart);
|
|
}
|
|
|
|
// Step 5: Clean up temp directory
|
|
$stepStart = microtime(true);
|
|
$this->filesystem->remove($tempDir);
|
|
$log('cleanup', 'Cleaned up temporary files', true, microtime(true) - $stepStart);
|
|
|
|
$totalDuration = microtime(true) - $startTime;
|
|
$log('complete', sprintf('Restore completed successfully in %.1f seconds', $totalDuration), true);
|
|
|
|
return [
|
|
'success' => true,
|
|
'steps' => $steps,
|
|
'error' => null,
|
|
];
|
|
|
|
} catch (\Throwable $e) {
|
|
$this->logger->error('Restore failed: ' . $e->getMessage(), [
|
|
'exception' => $e,
|
|
'file' => $filename,
|
|
]);
|
|
|
|
// Try to clean up
|
|
try {
|
|
if (isset($tempDir) && is_dir($tempDir)) {
|
|
$this->filesystem->remove($tempDir);
|
|
}
|
|
} catch (\Throwable $cleanupError) {
|
|
$this->logger->error('Cleanup after failed restore also failed', ['error' => $cleanupError->getMessage()]);
|
|
}
|
|
|
|
return [
|
|
'success' => false,
|
|
'steps' => $steps,
|
|
'error' => $e->getMessage(),
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restore database from backup.
|
|
*/
|
|
private function restoreDatabaseFromBackup(string $tempDir): void
|
|
{
|
|
// Check for SQL dump (MySQL/PostgreSQL)
|
|
$sqlFile = $tempDir . '/database.sql';
|
|
if (file_exists($sqlFile)) {
|
|
// Import SQL using mysql/psql command directly
|
|
// First, get database connection params from Doctrine
|
|
$connection = $this->entityManager->getConnection();
|
|
$params = $connection->getParams();
|
|
$platform = $connection->getDatabasePlatform();
|
|
|
|
if ($platform instanceof \Doctrine\DBAL\Platforms\AbstractMySQLPlatform) {
|
|
// Use mysql command to import - need to use shell to handle input redirection
|
|
$mysqlCmd = 'mysql';
|
|
if (isset($params['host'])) {
|
|
$mysqlCmd .= ' -h ' . escapeshellarg($params['host']);
|
|
}
|
|
if (isset($params['port'])) {
|
|
$mysqlCmd .= ' -P ' . escapeshellarg((string)$params['port']);
|
|
}
|
|
if (isset($params['user'])) {
|
|
$mysqlCmd .= ' -u ' . escapeshellarg($params['user']);
|
|
}
|
|
if (isset($params['password']) && $params['password']) {
|
|
$mysqlCmd .= ' -p' . escapeshellarg($params['password']);
|
|
}
|
|
if (isset($params['dbname'])) {
|
|
$mysqlCmd .= ' ' . escapeshellarg($params['dbname']);
|
|
}
|
|
$mysqlCmd .= ' < ' . escapeshellarg($sqlFile);
|
|
|
|
// Execute using shell
|
|
$process = Process::fromShellCommandline($mysqlCmd, $this->projectDir, null, null, 300);
|
|
$process->run();
|
|
|
|
if (!$process->isSuccessful()) {
|
|
throw new \RuntimeException('MySQL import failed: ' . $process->getErrorOutput());
|
|
}
|
|
} elseif ($platform instanceof \Doctrine\DBAL\Platforms\PostgreSQLPlatform) {
|
|
// Use psql command to import
|
|
$psqlCmd = 'psql';
|
|
if (isset($params['host'])) {
|
|
$psqlCmd .= ' -h ' . escapeshellarg($params['host']);
|
|
}
|
|
if (isset($params['port'])) {
|
|
$psqlCmd .= ' -p ' . escapeshellarg((string)$params['port']);
|
|
}
|
|
if (isset($params['user'])) {
|
|
$psqlCmd .= ' -U ' . escapeshellarg($params['user']);
|
|
}
|
|
if (isset($params['dbname'])) {
|
|
$psqlCmd .= ' -d ' . escapeshellarg($params['dbname']);
|
|
}
|
|
$psqlCmd .= ' -f ' . escapeshellarg($sqlFile);
|
|
|
|
// Set PGPASSWORD environment variable if password is provided
|
|
$env = null;
|
|
if (isset($params['password']) && $params['password']) {
|
|
$env = ['PGPASSWORD' => $params['password']];
|
|
}
|
|
|
|
// Execute using shell
|
|
$process = Process::fromShellCommandline($psqlCmd, $this->projectDir, $env, null, 300);
|
|
$process->run();
|
|
|
|
if (!$process->isSuccessful()) {
|
|
throw new \RuntimeException('PostgreSQL import failed: ' . $process->getErrorOutput());
|
|
}
|
|
} else {
|
|
throw new \RuntimeException('Unsupported database platform for restore');
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Check for SQLite database file
|
|
$sqliteFile = $tempDir . '/var/app.db';
|
|
if (file_exists($sqliteFile)) {
|
|
$targetDb = $this->projectDir . '/var/app.db';
|
|
$this->filesystem->copy($sqliteFile, $targetDb, true);
|
|
return;
|
|
}
|
|
|
|
$this->logger->warning('No database found in backup');
|
|
}
|
|
|
|
/**
|
|
* Restore config files from backup.
|
|
*/
|
|
private function restoreConfigFromBackup(string $tempDir): void
|
|
{
|
|
// Restore .env.local
|
|
$envLocal = $tempDir . '/.env.local';
|
|
if (file_exists($envLocal)) {
|
|
$this->filesystem->copy($envLocal, $this->projectDir . '/.env.local', true);
|
|
}
|
|
|
|
// Restore config/parameters.yaml
|
|
$parametersYaml = $tempDir . '/config/parameters.yaml';
|
|
if (file_exists($parametersYaml)) {
|
|
$this->filesystem->copy($parametersYaml, $this->projectDir . '/config/parameters.yaml', true);
|
|
}
|
|
|
|
// Restore config/banner.md
|
|
$bannerMd = $tempDir . '/config/banner.md';
|
|
if (file_exists($bannerMd)) {
|
|
$this->filesystem->copy($bannerMd, $this->projectDir . '/config/banner.md', true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restore attachments from backup.
|
|
*/
|
|
private function restoreAttachmentsFromBackup(string $tempDir): void
|
|
{
|
|
// Restore public/media
|
|
$publicMedia = $tempDir . '/public/media';
|
|
if (is_dir($publicMedia)) {
|
|
$this->filesystem->mirror($publicMedia, $this->projectDir . '/public/media', null, ['override' => true]);
|
|
}
|
|
|
|
// Restore uploads
|
|
$uploads = $tempDir . '/uploads';
|
|
if (is_dir($uploads)) {
|
|
$this->filesystem->mirror($uploads, $this->projectDir . '/uploads', null, ['override' => true]);
|
|
}
|
|
}
|
|
}
|