285 lines
9.9 KiB
PHP
285 lines
9.9 KiB
PHP
<?php
|
|
|
|
namespace App\Http\Controllers\Admin;
|
|
|
|
use App\Http\Controllers\Controller;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\Artisan;
|
|
use Illuminate\Support\Facades\File;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
|
|
class BackupController extends Controller
|
|
{
|
|
/**
|
|
* Directorio de respaldos.
|
|
*/
|
|
protected $backupDir;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->backupDir = storage_path('app/backups');
|
|
}
|
|
|
|
/**
|
|
* Muestra el panel con el listado de copias de seguridad.
|
|
*/
|
|
public function index()
|
|
{
|
|
// Asegurarse de que el directorio exista
|
|
if (!File::exists($this->backupDir)) {
|
|
File::makeDirectory($this->backupDir, 0755, true);
|
|
}
|
|
|
|
$files = File::files($this->backupDir);
|
|
$backups = [];
|
|
$totalSize = 0;
|
|
|
|
foreach ($files as $file) {
|
|
if ($file->getExtension() === 'zip' && strpos($file->getFilename(), 'backup-') === 0) {
|
|
$size = $file->getSize();
|
|
$totalSize += $size;
|
|
|
|
$backups[] = [
|
|
'filename' => $file->getFilename(),
|
|
'size' => $this->formatBytes($size),
|
|
'raw_size' => $size,
|
|
'created_at' => \Carbon\Carbon::createFromTimestamp($file->getMTime())->format('d/m/Y H:i:s'),
|
|
'mtime' => $file->getMTime(),
|
|
];
|
|
}
|
|
}
|
|
|
|
// Ordenar de más nuevo a más viejo
|
|
usort($backups, function ($a, $b) {
|
|
return $b['mtime'] <=> $a['mtime'];
|
|
});
|
|
|
|
// Estadísticas de disco
|
|
$freeDiskSpace = disk_free_space($this->backupDir);
|
|
$totalDiskSpace = disk_total_space($this->backupDir);
|
|
|
|
$diskStats = [
|
|
'total_backups_size' => $this->formatBytes($totalSize),
|
|
'free_space' => $this->formatBytes($freeDiskSpace),
|
|
'total_space' => $this->formatBytes($totalDiskSpace),
|
|
'free_percentage' => round(($freeDiskSpace / $totalDiskSpace) * 100, 1),
|
|
];
|
|
|
|
return view('admin.backups.index', compact('backups', 'diskStats'));
|
|
}
|
|
|
|
public function create()
|
|
{
|
|
try {
|
|
$exitCode = Artisan::call('db:backup');
|
|
$output = Artisan::output();
|
|
|
|
if ($exitCode === 0) {
|
|
return redirect()->route('admin.backups.index')
|
|
->with('success', 'Copia de seguridad generada correctamente.');
|
|
} else {
|
|
\Illuminate\Support\Facades\Log::error("Artisan db:backup failed with exit code {$exitCode}. Output: " . $output);
|
|
return redirect()->route('admin.backups.index')
|
|
->with('error', 'Ocurrió un error al generar la copia de seguridad. Detalles: ' . trim($output));
|
|
}
|
|
} catch (\Exception $e) {
|
|
\Illuminate\Support\Facades\Log::error("Artisan db:backup threw exception: " . $e->getMessage());
|
|
return redirect()->route('admin.backups.index')
|
|
->with('error', 'Error: ' . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Descargar una copia de seguridad.
|
|
*/
|
|
public function download($filename)
|
|
{
|
|
// Validación de seguridad para evitar directory traversal
|
|
if (strpos($filename, '..') !== false || strpos($filename, '/') !== false || strpos($filename, '\\') !== false) {
|
|
abort(404, 'Nombre de archivo no válido.');
|
|
}
|
|
|
|
$path = $this->backupDir . '/' . $filename;
|
|
|
|
if (!File::exists($path)) {
|
|
abort(404, 'El archivo no existe.');
|
|
}
|
|
|
|
return response()->download($path);
|
|
}
|
|
|
|
/**
|
|
* Eliminar una copia de seguridad.
|
|
*/
|
|
public function destroy($filename)
|
|
{
|
|
// Validación de seguridad para evitar directory traversal
|
|
if (strpos($filename, '..') !== false || strpos($filename, '/') !== false || strpos($filename, '\\') !== false) {
|
|
abort(400, 'Nombre de archivo no válido.');
|
|
}
|
|
|
|
$path = $this->backupDir . '/' . $filename;
|
|
|
|
if (File::exists($path)) {
|
|
File::delete($path);
|
|
return redirect()->route('admin.backups.index')
|
|
->with('success', 'Copia de seguridad eliminada correctamente.');
|
|
}
|
|
|
|
return redirect()->route('admin.backups.index')
|
|
->with('error', 'No se encontró el archivo a eliminar.');
|
|
}
|
|
|
|
/**
|
|
* Subir un archivo de copia de seguridad (.zip).
|
|
*/
|
|
public function upload(Request $request)
|
|
{
|
|
$request->validate([
|
|
'backup_file' => 'required|file|mimes:zip|max:50000', // 50MB max
|
|
]);
|
|
|
|
$file = $request->file('backup_file');
|
|
$filename = $file->getClientOriginalName();
|
|
|
|
// Validación de seguridad para el nombre del archivo
|
|
if (strpos($filename, 'backup-') !== 0 || $file->getClientOriginalExtension() !== 'zip') {
|
|
return redirect()->route('admin.backups.index')
|
|
->with('error', 'El archivo debe ser un .zip válido de respaldo (su nombre debe empezar con "backup-").');
|
|
}
|
|
|
|
// Asegurarse de que el directorio exista
|
|
if (!File::exists($this->backupDir)) {
|
|
File::makeDirectory($this->backupDir, 0755, true);
|
|
}
|
|
|
|
$file->move($this->backupDir, $filename);
|
|
|
|
return redirect()->route('admin.backups.index')
|
|
->with('success', 'Copia de seguridad subida correctamente.');
|
|
}
|
|
|
|
/**
|
|
* Restaurar la base de datos a partir de una copia de seguridad.
|
|
*/
|
|
public function restore($filename)
|
|
{
|
|
// Validación de seguridad para evitar directory traversal
|
|
if (strpos($filename, '..') !== false || strpos($filename, '/') !== false || strpos($filename, '\\') !== false) {
|
|
abort(400, 'Nombre de archivo no válido.');
|
|
}
|
|
|
|
$zipPath = $this->backupDir . '/' . $filename;
|
|
|
|
if (!File::exists($zipPath)) {
|
|
return redirect()->route('admin.backups.index')->with('error', 'El archivo no existe.');
|
|
}
|
|
|
|
// Extraer el archivo SQL del ZIP
|
|
$zip = new \ZipArchive();
|
|
if ($zip->open($zipPath) === true) {
|
|
// Buscamos el primer archivo SQL dentro del zip
|
|
$sqlFilename = null;
|
|
for ($i = 0; $i < $zip->numFiles; $i++) {
|
|
$stat = $zip->statIndex($i);
|
|
if (pathinfo($stat['name'], PATHINFO_EXTENSION) === 'sql') {
|
|
$sqlFilename = $stat['name'];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!$sqlFilename) {
|
|
$zip->close();
|
|
return redirect()->route('admin.backups.index')->with('error', 'No se encontró ningún archivo SQL en el archivo comprimido.');
|
|
}
|
|
|
|
// Extraer el SQL a un directorio temporal de backups
|
|
$zip->extractTo($this->backupDir, $sqlFilename);
|
|
$zip->close();
|
|
|
|
$sqlPath = $this->backupDir . '/' . $sqlFilename;
|
|
|
|
// Datos de conexión
|
|
$dbConfig = config('database.connections.mysql');
|
|
$host = $dbConfig['host'] ?? '127.0.0.1';
|
|
$port = $dbConfig['port'] ?? '3306';
|
|
$database = $dbConfig['database'] ?? 'lauck';
|
|
$username = $dbConfig['username'] ?? 'root';
|
|
$password = $dbConfig['password'] ?? '';
|
|
|
|
// Ejecutable de mysql
|
|
$mysqlPath = 'mysql';
|
|
if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
|
|
$xamppPath = 'C:\\xampp\\mysql\\bin\\mysql.exe';
|
|
if (File::exists($xamppPath)) {
|
|
$mysqlPath = $xamppPath;
|
|
}
|
|
}
|
|
|
|
// Ejecutar importación usando Process y redirección de entrada de archivo
|
|
$command = [
|
|
$mysqlPath,
|
|
"--host={$host}",
|
|
"--port={$port}",
|
|
"--user={$username}",
|
|
$database
|
|
];
|
|
|
|
$env = [
|
|
'SystemRoot' => getenv('SystemRoot') ?: 'C:\\Windows',
|
|
'windir' => getenv('windir') ?: 'C:\\Windows',
|
|
'PATH' => getenv('PATH'),
|
|
];
|
|
if ($password !== '') {
|
|
$env['MYSQL_PWD'] = $password;
|
|
}
|
|
|
|
$process = new \Symfony\Component\Process\Process($command, null, $env);
|
|
|
|
// Pasar el contenido del archivo SQL a la entrada estándar (stdin)
|
|
$process->setInput(File::get($sqlPath));
|
|
$process->setTimeout(300);
|
|
|
|
try {
|
|
$process->run();
|
|
|
|
// Limpiar archivo SQL temporal
|
|
File::delete($sqlPath);
|
|
|
|
if (!$process->isSuccessful()) {
|
|
throw new \Exception(trim($process->getErrorOutput()) ?: 'Error desconocido al restaurar el respaldo.');
|
|
}
|
|
|
|
return redirect()->route('admin.backups.index')
|
|
->with('success', 'Base de datos restaurada correctamente a partir del respaldo: ' . $filename);
|
|
|
|
} catch (\Exception $e) {
|
|
if (File::exists($sqlPath)) {
|
|
File::delete($sqlPath);
|
|
}
|
|
\Illuminate\Support\Facades\Log::error("Backup restore failed: " . $e->getMessage());
|
|
return redirect()->route('admin.backups.index')
|
|
->with('error', 'Error al restaurar base de datos: ' . $e->getMessage());
|
|
}
|
|
} else {
|
|
return redirect()->route('admin.backups.index')->with('error', 'No se pudo abrir el archivo ZIP.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Formatear bytes a tamaño legible.
|
|
*/
|
|
private function formatBytes($bytes, $precision = 2)
|
|
{
|
|
$units = ['B', 'KB', 'MB', 'GB', 'TB'];
|
|
|
|
$bytes = max($bytes, 0);
|
|
$pow = floor(($bytes ? log($bytes) : 0) / log(1024));
|
|
$pow = min($pow, count($units) - 1);
|
|
|
|
$bytes /= pow(1024, $pow);
|
|
|
|
return round($bytes, $precision) . ' ' . $units[$pow];
|
|
}
|
|
}
|