360 lines
10 KiB
PHP
Executable File
360 lines
10 KiB
PHP
Executable File
<?php
|
|
/*
|
|
* OpenSTAManager: il software gestionale open source per l'assistenza tecnica e la fatturazione
|
|
* Copyright (C) DevCode s.r.l.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
use Ifsnop\Mysqldump\Mysqldump;
|
|
use Util\FileSystem;
|
|
use Util\Generator;
|
|
use Util\Zip;
|
|
|
|
/**
|
|
* Classe per la gestione dei backup.
|
|
*
|
|
* @since 2.4
|
|
*/
|
|
class Backup
|
|
{
|
|
/** @var string Pattern per i nomi dei backup */
|
|
public const PATTERN = 'OSM backup YYYY-m-d H_i_s AAAAAAA';
|
|
|
|
/** @var array Elenco delle variabili che identificano i backup giornalieri */
|
|
protected static $daily_replaces = [
|
|
'YYYY', 'm', 'd',
|
|
];
|
|
|
|
/**
|
|
* Restituisce il percorso su previsto per il salvataggio dei backup.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getDirectory()
|
|
{
|
|
$result = App::getConfig()['backup_dir'];
|
|
|
|
$result = rtrim($result, '/');
|
|
if (!directory($result) || !is_writable($result)) {
|
|
// throw new UnexpectedValueException();
|
|
}
|
|
|
|
return slashes($result);
|
|
}
|
|
|
|
/**
|
|
* Restituisce l'elenco dei backup disponibili.
|
|
*
|
|
* @param string $pattern Eventuale pattern alternativo
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getList($pattern = null)
|
|
{
|
|
$directory = self::getDirectory();
|
|
if (!is_writable($directory) || !is_readable($directory)) {
|
|
return [];
|
|
}
|
|
|
|
// Costruzione del pattern
|
|
if (empty($pattern)) {
|
|
$replaces = self::getReplaces();
|
|
$regexs = array_column($replaces, 'regex');
|
|
|
|
$pattern = str_replace(array_keys($replaces), array_values($regexs), self::PATTERN);
|
|
}
|
|
|
|
// Individuazione dei backup
|
|
$backups = Symfony\Component\Finder\Finder::create()
|
|
->name('/^'.$pattern.'/')
|
|
->sortByName()
|
|
->in($directory)
|
|
->depth('== 0');
|
|
|
|
$results = [];
|
|
foreach ($backups as $backup) {
|
|
$results[] = $backup->getRealPath();
|
|
}
|
|
|
|
return $results;
|
|
}
|
|
|
|
/**
|
|
* Restituisce i valori utilizzati sulle variabili sostituite.
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function readName($string)
|
|
{
|
|
return Generator::read(self::PATTERN, basename($string));
|
|
}
|
|
|
|
/**
|
|
* Controlla se il backup giornaliero è stato effettuato.
|
|
*
|
|
* @return bool|null
|
|
*/
|
|
public static function isDailyComplete()
|
|
{
|
|
// Costruzione del pattern
|
|
$replaces = self::getReplaces();
|
|
|
|
foreach ($replaces as $key => $replace) {
|
|
if (in_array($key, self::$daily_replaces)) {
|
|
$replaces[$key] = $replace['value'];
|
|
} else {
|
|
$replaces[$key] = $replace['regex'];
|
|
}
|
|
}
|
|
|
|
$pattern = str_replace(array_keys($replaces), array_values($replaces), self::PATTERN);
|
|
|
|
// Individuazione dei backup
|
|
$backups = self::getList($pattern);
|
|
|
|
return !empty($backups);
|
|
}
|
|
|
|
/**
|
|
* Effettua il backup giornaliero.
|
|
*
|
|
* @return bool|null
|
|
*/
|
|
public static function daily()
|
|
{
|
|
// Creazione del backup eventuale
|
|
if (!self::isDailyComplete()) {
|
|
return self::create();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Esegue il backup del progetto.
|
|
*
|
|
* @param array $ignores eventuali dirs o files da ignorare
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function create($ignores)
|
|
{
|
|
self::checkSpace();
|
|
|
|
$backup_dir = self::getDirectory();
|
|
$backup_name = tr(self::getNextName(), ['AAAAAAA' => ($ignores['dirs'] || $ignores['files']) ? 'PARTIAL' : 'FULL']);
|
|
|
|
set_time_limit(0);
|
|
|
|
// Backup del database
|
|
$database_file = self::getDatabaseDirectory().'/database.sql';
|
|
self::database($database_file);
|
|
|
|
// Files e dirs da ignorare di default
|
|
$default_ignores = [
|
|
'files' => [
|
|
'config.inc.php',
|
|
'*.lock',
|
|
'*.phar',
|
|
'*.log',
|
|
],
|
|
'dirs' => [
|
|
'node_modules',
|
|
'tests',
|
|
'tmp',
|
|
'.git',
|
|
'.github',
|
|
],
|
|
];
|
|
|
|
$ignores = array_merge_recursive($ignores, $default_ignores);
|
|
|
|
// Escludo la directory dei backup
|
|
if (string_starts_with($backup_dir, slashes(base_dir()))) {
|
|
$ignores['dirs'][] = basename($backup_dir);
|
|
}
|
|
|
|
// Creazione backup in formato ZIP
|
|
if (extension_loaded('zip')) {
|
|
$result = Zip::create([
|
|
base_dir(),
|
|
self::getDatabaseDirectory(),
|
|
], $backup_dir.'/'.$backup_name.'.zip', $ignores);
|
|
}
|
|
|
|
// Creazione backup attraverso la copia dei file
|
|
else {
|
|
$result = copyr([
|
|
base_dir(),
|
|
self::getDatabaseDirectory(),
|
|
], $backup_dir.'/'.$backup_name.'.zip', $ignores);
|
|
}
|
|
|
|
// Rimozione cartella temporanea
|
|
delete($database_file);
|
|
|
|
self::cleanup();
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Effettua il dump del database.
|
|
*
|
|
* @param string $file
|
|
*/
|
|
public static function database($file)
|
|
{
|
|
$config = App::getConfig();
|
|
|
|
$dump = new Mysqldump('mysql:host='.$config['db_host'].';dbname='.$config['db_name'], $config['db_username'], $config['db_password'], [
|
|
'add-drop-table' => true,
|
|
'add-locks' => false,
|
|
]);
|
|
|
|
$dump->start($file);
|
|
}
|
|
|
|
/**
|
|
* Rimuove i backup più vecchi.
|
|
*/
|
|
public static function cleanup()
|
|
{
|
|
$max_backups = intval(setting('Numero di backup da mantenere'));
|
|
|
|
$backups = self::getList();
|
|
$count = count($backups);
|
|
|
|
// Rimozione dei backup più vecchi
|
|
for ($i = 0; $i < $count - $max_backups; ++$i) {
|
|
delete($backups[$i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ripristina un backup esistente.
|
|
*
|
|
* @param string $path
|
|
*/
|
|
public static function restore($path, $cleanup = true)
|
|
{
|
|
$database = database();
|
|
$extraction_dir = is_dir($path) ? $path : Zip::extract($path);
|
|
|
|
// TODO: Forzo il log out di tutti gli utenti e ne impedisco il login
|
|
// fino a ripristino ultimato
|
|
|
|
// Rimozione del database
|
|
$tables = include base_dir().'/update/tables.php';
|
|
|
|
// Ripristino del database
|
|
$database_file = $extraction_dir.'/database.sql';
|
|
if (file_exists($database_file)) {
|
|
$database->query('SET foreign_key_checks = 0');
|
|
foreach ($tables as $table) {
|
|
$database->query('DROP TABLE IF EXISTS `'.$table.'`');
|
|
}
|
|
$database->query('DROP TABLE IF EXISTS `updates`');
|
|
|
|
// Ripristino del database
|
|
$database->multiQuery($database_file);
|
|
$database->query('SET foreign_key_checks = 1');
|
|
}
|
|
|
|
// Salva il file di configurazione
|
|
$config = file_get_contents(base_dir().'/config.inc.php');
|
|
|
|
// Copia i file dalla cartella temporanea alla root
|
|
copyr($extraction_dir, base_dir());
|
|
|
|
// Ripristina il file di configurazione dell'installazione
|
|
file_put_contents(base_dir().'/config.inc.php', $config);
|
|
|
|
// Pulizia
|
|
if (!empty($cleanup)) {
|
|
delete($extraction_dir);
|
|
}
|
|
delete(base_dir().'/database.sql');
|
|
}
|
|
|
|
/**
|
|
* Effettua i controlli relativi allo spazio disponibile per l'esecuzione del backup;.
|
|
*/
|
|
public static function checkSpace()
|
|
{
|
|
$scarto = 1.1;
|
|
|
|
// Informazioni di base sui limiti di spazio
|
|
$spazio_libero = disk_free_space('.');
|
|
if (!empty(setting('Soft quota'))) {
|
|
$soft_quota = (float) setting('Soft quota'); // Impostazione in GB
|
|
$soft_quota = $soft_quota * (1024 ** 3); // Trasformazione in GB
|
|
}
|
|
|
|
// Informazioni sullo spazio occupato
|
|
$spazio_occupato = $spazio_necessario = FileSystem::folderSize(base_dir(), ['htaccess']);
|
|
$cartelle_ignorate = [
|
|
self::getDirectory(),
|
|
'node_modules',
|
|
'tests',
|
|
'tmp',
|
|
];
|
|
foreach ($cartelle_ignorate as $path) {
|
|
$spazio_necessario -= FileSystem::folderSize($path);
|
|
}
|
|
|
|
// Errori visualizzati
|
|
if (isset($soft_quota) && $soft_quota < ($spazio_necessario + $spazio_occupato) * $scarto) {
|
|
throw new InvalidArgumentException('Spazio disponibile in esaurimento');
|
|
} elseif ($spazio_libero < $spazio_necessario * $scarto) {
|
|
throw new InvalidArgumentException('Spazio del server in esaurimento');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restituisce il percorso su cui salvare temporaneamente il dump del database.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected static function getDatabaseDirectory()
|
|
{
|
|
$result = self::getDirectory().'/database';
|
|
|
|
if (!directory($result)) {
|
|
throw new UnexpectedValueException();
|
|
}
|
|
|
|
return slashes($result);
|
|
}
|
|
|
|
/**
|
|
* Restituisce l'elenco delle variabili da sostituire normalizzato per l'utilizzo.
|
|
*/
|
|
protected static function getReplaces()
|
|
{
|
|
return Generator::getReplaces();
|
|
}
|
|
|
|
/**
|
|
* Restituisce il nome previsto per il backup successivo.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected static function getNextName()
|
|
{
|
|
return Generator::generate(self::PATTERN);
|
|
}
|
|
}
|