OpenXE/classes/Modules/Backup/BackupService.php

<?php

namespace Xentral\Modules\Backup;

use Config;
use DateInterval;
use DateTime;
use Exception;
use Xentral\Components\Backup\Adapter\AdapterInterface;
use Xentral\Components\Backup\FileBackup;
use Xentral\Components\Backup\DatabaseBackup;
use Xentral\Components\Backup\Logger\BackupLog;
use Xentral\Components\Database\Database;
use Xentral\Components\Database\DatabaseConfig;
use Xentral\Components\Database\Exception\DatabaseExceptionInterface;
use Xentral\Modules\Backup\Exception\BackupProcessStarterException;
use ZipArchive;
use Xentral\Modules\Backup\Exception\RuntimeException;

/**
 * Class BackupService
 *
 * @package Xentral\Modules\Backup
 */
final class BackupService
{
    /**
     * @var BackupGateway
     */
    private $gateway;
    /**
     * @var DatabaseBackup
     */
    private $oDbBackup;
    /**
     * @var FileBackup
     */
    private $oFileBackup;

    /** @var string */
    const STATUS_FILE = 'status.txt';

    /** @var string */
    const SESSION_FILE = 'session.txt';

    /** @var Database $db */
    private $db;

    /** @var  BackupProcessStarterService $processStarter */
    private $processStarter;

    /** @var  BackupSystemConfigurationService $backupSystemConfiguration */
    private $backupSystemConfiguration;

    /** @var BackupLog $logger */
    private $logger;

    /** @var int min free disk in Bytes */
    const MIN_FREE_DISK = 1073741824;

    private static $publicSubdirectories = ['dms', 'pdfarchiv', 'pdfmirror', 'emailbackup', 'tmp', 'uebertragung'];

    /**
     * BackupService constructor.
     *
     * @param BackupGateway                    $gateway
     * @param DatabaseBackup                   $oDbBackup
     * @param FileBackup                       $oFileBackup
     * @param BackupProcessStarterService      $processStarter
     * @param BackupSystemConfigurationService $backupSystemConfiguration
     * @param Database                         $database
     * @param BackupLog                        $logger
     */
    public function __construct(
        BackupGateway $gateway,
        DatabaseBackup $oDbBackup,
        FileBackup $oFileBackup,
        BackupProcessStarterService $processStarter,
        BackupSystemConfigurationService $backupSystemConfiguration,
        Database $database,
        BackupLog $logger
    ) {
        $this->gateway = $gateway;
        $this->oDbBackup = $oDbBackup;
        $this->oFileBackup = $oFileBackup;
        $this->processStarter = $processStarter;
        $this->backupSystemConfiguration = $backupSystemConfiguration;
        $this->db = $database;
        $this->logger = $logger;
    }

    /**
     * @param string $file
     *
     * @return false|string
     */
    protected function generateMetaData($file)
    {
        /** @var  $adminIds */
        $adminIds = $this->gateway->getAdminUserIds();
        $hMeta = [
            'tables'  => $this->gateway->getTablesChecksum(),
            'users'   => !empty($adminIds) ? array_column($adminIds, 'id') : [],
            'created' => time(),
            'name'    => $file,
        ];

        return json_encode($hMeta);
    }

    /**
     * @param string $file
     *
     * @return false|int
     */
    protected function addMetadata($file)
    {
        $sMetaFile = $this->oDbBackup->getMetaFileName($file);
        $sMeta = base64_encode($this->generateMetaData($sMetaFile));

        return file_put_contents($sMetaFile, $sMeta);
    }

    /**
     * @param Config $config
     *
     * @return DatabaseConfig
     */
    public function convertLegacyDbConf(Config $config)
    {
        return new DatabaseConfig(
            $config->WFdbhost,
            $config->WFdbuser,
            $config->WFdbpass,
            $config->WFdbname,
            null,
            $config->WFdbport
        );
    }

    /**
     * @param string $backupFile
     *
     * @return string
     */
    public function getMySQLFileName($backupFile)
    {
        $asFile = explode('.', $backupFile);
        array_pop($asFile);

        return implode('.', $asFile) . '.sql';
    }

    /**
     * @param Config   $config
     * @param string   $filename
     * @param array    $options
     * @param int|null $minimumSpace
     */
    public function create(Config $config, $filename, $options = [], $minimumSpace = null)
    {
        if (!$this->hasExecutableExtension('zip')) {
            $this->oFileBackup->breakCleanUp();
            $this->logger->writePersistent('Required Zip Module is missing!');
            throw new RuntimeException('Required Zip Module is missing!');
        }

        // create mysql dump
        $userPath = $config->WFuserdata;

        if ($sTmpDir = $this->oFileBackup->begin($userPath)) {
            $ssid = array_key_exists('ssid', $options) ? $options['ssid'] : null;
            $this->logger->write('--BEGIN--');

            // DELETE OLD BACKUPS ON THE FILESYSTEM (BACKWARDS AS WELL)
            exec(sprintf('cd %s && ls', $this->oFileBackup->getSnapshotsDir()), $asResult);
            if (is_array($asResult) && count($asResult) > 0) {
                foreach ($asResult as $file) {
                    if (!empty($file) && $file !== $filename) {
                        $fullFile = sprintf('%s%s', $this->oFileBackup->getSnapshotsDir(), $file);
                        if (file_exists($fullFile)) {
                            @unlink($fullFile);
                        }
                    }
                }
            }

            if (null !== $ssid) {
                $this->logger->write($ssid, null, static::SESSION_FILE, false, false);
            }
            $sMySQLFile = $this->getMySQLFileName($filename);
            $sMySQLFullPath = $sTmpDir . $sMySQLFile;
            $this->logger->write('Create MySQL Dump');

            if ($this->hasEnoughFreeDisk($userPath, $minimumSpace) === false) {
                $this->oFileBackup->breakCleanUp();
                $this->logger->write('ERROR');
                $this->logger->writePersistent('Not enough free disk space for Dump creation');
                throw new RuntimeException('Not enough free disk space for Dump creation');
            }

            $this->oDbBackup->createDump($this->convertLegacyDbConf($config), $sMySQLFullPath, null);
            if (filesize($sMySQLFullPath . '.gz') > 1024) {
                $this->logger->write('Create Dump meta file');
                // $this->addMetadata($this->oDbBackup->getMetaFileName($this->oFileBackup->getLocalPath($filename,
                // $userPath)));
            }

            if ($this->hasEnoughFreeDisk($userPath, $minimumSpace) === false) {
                $this->oFileBackup->breakCleanUp();
                $this->logger->write('ERROR');
                $this->logger->writePersistent(sprintf('Not enough free disk space for %s', $userPath));
                throw new RuntimeException(sprintf('Not enough free disk space for %s', $userPath));
            }

            // Create File Backup
            $this->logger->write('Create File Backup for userdata');
            $this->oFileBackup->createBackup($filename, $userPath, $sMySQLFile . '.gz');
            if (filesize($this->getArchivePath($filename, $userPath)) > 1024) {
                $this->logger->write('Add in Backup table');
                // DELETE OLD Backup
                if ($latest = $this->gateway->getLatestBackup()) {
                    $this->db->perform('DELETE FROM backup WHERE id=:id', ['id' => $latest['id']]);
                }
                $this->db->perform('INSERT INTO backup (adresse, name, dateiname, datum) VALUES (:addr,:name,:file_name,NOW())',
                    ['addr' => $options['addr'], 'name' => $options['name'], 'file_name' => $filename]);
            }

            $this->logger->write('--END--');
            $this->removeLoggerFiles();
        }
    }

    /**
     * @param Config $config
     * @param string $filename
     * @param array  $options
     */
    public function restore(Config $config, $filename, $options = [])
    {
        $userPath = $config->WFuserdata;
        if ($sTmpDir = $this->oFileBackup->begin($userPath)) {
            $ssid = array_key_exists('ssid', $options) ? $options['ssid'] : null;

            $this->logger->write('--BEGIN--');
            if (null !== $ssid) {
                $this->logger->write($ssid, null, static::SESSION_FILE, false, false);
            }

            if ($this->hasEnoughFreeDisk($userPath) === false) {
                $this->oFileBackup->breakCleanUp();
                $this->logger->write('ERROR');
                $this->logger->writePersistent('Not enough free disk space for Backup restore');
                throw new RuntimeException('Not enough free disk space for Backup restore');
            }

            // Replay SQL DUMP
            // Backup-Tabelle extra sichern
            $sBackupTmpFullPath = $sTmpDir . 'backup_temp.sql';
            $this->logger->write('DUMP backup table');
            $this->oDbBackup->createDump($this->convertLegacyDbConf($config), $sBackupTmpFullPath, 'backup');
            $sMySQLFile = $this->getMySQLFileName($filename) . '.gz';

            $FullBckPath = $this->getArchivePath($filename, $userPath);
            $oZip = new ZipArchive;
            $xRes = $oZip->open($FullBckPath);
            $this->logger->write('Fetch Database DUMP from Backup archive');
            if ($xRes !== true) {
                $this->oFileBackup->breakCleanUp();
                $this->logger->write('ERROR');
                $this->logger->writePersistent(sprintf('Backup File "%s" cannot be unzipped!', $FullBckPath));
                throw new RuntimeException(sprintf('Backup File "%s" cannot be unzipped!', $FullBckPath));
            }

            if ($oZip->extractTo($sTmpDir, [$sMySQLFile]) === false) {
                $this->oFileBackup->breakCleanUp();
                $this->logger->write('ERROR');
                $this->logger->writePersistent(sprintf('SQL file not found in achieve file %s', $filename));
                throw new RuntimeException(sprintf('SQL file not found in achieve file %s', $filename));
            }

            $oZip->close();

            $asTables = $this->gateway->getTables();
            $this->logger->write('DROP ALL TABLES');
            foreach ($asTables as $sTable) {
                $this->db->perform('DROP TABLE IF EXISTS ' . $sTable);
            }
            $sMySQLFullPath = $sTmpDir . $sMySQLFile;
            $this->logger->write('RESTORE Database DUMP');
            $this->oDbBackup->restoreDump($this->convertLegacyDbConf($config), $sMySQLFullPath);
            // remove Backup Dump
            $this->logger->write('REMOVE DUMP FILE');
            @unlink($sMySQLFullPath);

            // RESTORE Backup table
            $this->logger->write('Restore Backup Table');
            $this->oDbBackup->restoreDump($this->convertLegacyDbConf($config), $sBackupTmpFullPath . '.gz');
            @unlink($sBackupTmpFullPath . '.gz');

            $this->logger->write('Restore Backup System files');

            $restoreOptions = [];
            if (array_key_exists('exclude_dir', $options) && is_array($options['exclude_dir'])) {
                $restoreOptions['exclude_dir'] = $options['exclude_dir'];
            }
            $this->oFileBackup->restoreFileSystem($filename, $userPath, $restoreOptions);
            $iUserId = array_key_exists('user_id', $options) ? $options['user_id'] : 0;
            if (!empty($iUserId)) {
                $ssid = array_key_exists('ssid', $options) ? $options['ssid'] : null;
                $ip = array_key_exists('ip', $options) ? $options['ip'] : null;
                $this->logger->write('RECONNECT current User');
                $this->reconnectUser($iUserId, $ssid, $ip);
            }
            if (array_key_exists('old_dbname', $options) && !empty($options['old_dbname'])) {
                $this->migratePublicSubdirectory($options['old_dbname'], $config);
            }
            $this->logger->write('--END--');
        }
    }

    /**
     * @return string
     */
    public function getArchiveExtension()
    {
        return $this->oFileBackup->getBackupExtension();
    }

    /**
     * @param string $filename
     *
     * @param string $userPath
     *
     * @return string
     */
    public function getArchivePath($filename, $userPath)
    {
        return $this->oFileBackup->getLocalPath($filename, $userPath);
    }

    /**
     * @param int         $iUserId
     *
     * @param string      $ssid
     *
     * @param string|null $ip
     *
     * @return void
     */
    public function reconnectUser($iUserId, $ssid, $ip = null)
    {
        if (isset($iUserId) && is_numeric($iUserId) && is_string($ssid)) {
            $ip = null === $ip ? '127.0.0.1' : $ip;
            $this->db->perform('DELETE FROM useronline WHERE user_id=:uid', ['uid' => $iUserId]);
            $this->db->perform(
                'INSERT INTO useronline (user_id, login, sessionid, ip, time) VALUES (:uid,1,:ssid,:ip,NOW())',
                [
                    'uid'  => $iUserId,
                    'ssid' => $ssid,
                    'ip'   => $ip,
                ]
            );
        }
    }

    /**
     * @param string      $filename
     *
     * @param string|null $userPath
     *
     * @return string|null
     */
    public function getDumpMetaData($filename, $userPath = null)
    {
        $filePath = $this->oFileBackup->getLocalPath($filename, $userPath, true);

        return $this->oDbBackup->getDumpMetaData($filePath);
    }

    /**
     * @param string $filename
     * @param string $userPath
     *
     * @return array
     */
    public function checkSumOnAfterRecovery($filename, $userPath = null)
    {
        $asDiff = [];
        $hDbCheckSums = $this->oDbBackup->excludeCheckSumTables($this->gateway->getTablesChecksum());
        if (($xData = $this->getDumpMetaData($filename, $userPath)) && !empty($hFileCheckSums = $xData['tables'])) {
            $ahFileCheckSums = $this->oDbBackup->excludeCheckSumTables($hFileCheckSums);
            foreach ($ahFileCheckSums as $table => &$asFileCheckSum) {
                // downward compatible
                if (!is_array($asFileCheckSum)) {
                    $params = ['checksum', 'items'];
                    $values = [$asFileCheckSum, 0];
                    $asFileCheckSum = array_combine($params, $values);
                }
                if ($asFileCheckSum['checksum'] !== $hDbCheckSums[$table]['checksum'] && $asFileCheckSum['items'] !== $hDbCheckSums[$table]['items']) {
                    $asDiff[] = $table;
                }
            }

            return $asDiff;
        }

        return null;
    }

    /**
     * @param string      $xConfig     Configuration options for backup
     * @param string      $identifier  description/Title of cron action
     * @param string      $sParam      Parameter to set in the configuration table for that action
     * @param string      $cronFile    Cron file (in .php) located under cronjobs directory
     * @param string|null $userDataDir userData directory
     *
     * @throws RuntimeException
     * @throws Exception
     * @return bool
     */
    public function addToProcessStarter(
        $xConfig,
        $identifier = 'Backup',
        $sParam = 'backup_configuration_cron',
        $cronFile = 'backup',
        $userDataDir = null
    ) {
        // check if backup or restore is running?
        if ($this->oDbBackup->getLockStatus() === AdapterInterface::STATUS_WORKING ||
            $this->oFileBackup->getLockStatus($userDataDir) === FileBackup::STATUS_WORKING) {
            return false;
        }

        $date = new DateTime();
        $yesterday = $date->sub(new DateInterval('P1D'));

        try {
            $fakeLastRun = $yesterday->format('Y-m-d H:i:s');
            // $this->db->perform('UPDATE prozessstarter SET aktiv=:active WHERE mutex=:mut',
            //    ['active' => 0, 'mut' => 0]);
            // ADD NEW JOB ONLY IF THERE IS NO RUNNING JOB
            try {
                $xCheckPS = $this->processStarter->tryCheckProcess($cronFile, 1000, $date, $identifier);
            } catch (BackupProcessStarterException $exception) {
                $this->logger->writePersistent($exception->getMessage());
                throw new RuntimeException($exception->getMessage());
            }

            $this->backupSystemConfiguration->trySetConfiguration($sParam, $xConfig);
            if ($xCheckPS === false) {
                $aiAffected = $this->db->fetchAffected(
                    'UPDATE prozessstarter SET aktiv=:active, letzteausfuerhung=:timestamp,
                          status=:status WHERE parameter=:cron_file',
                    ['active' => 1, 'timestamp' => $fakeLastRun, 'cron_file' => $cronFile, 'status' => '']
                );

                return !empty($aiAffected);
            }
        } catch (DatabaseExceptionInterface $exception) {
            $this->logger->writePersistent($exception->getMessage());
            throw new RuntimeException($exception->getMessage());
        }

        return true;
    }

    /**
     * @param null|string $fileName
     *
     * @return void
     */
    public function removeLoggerFiles($fileName = null)
    {
        if (null !== $fileName && is_file($fileName)) {
            $tmpBackup = $fileName;
            $fileExploded = explode('.', $fileName);
            $extension = array_pop($fileExploded);
            if ($extension === 'zip') {
                $tmpMeta = implode('.', $fileExploded) . '.meta';
                if (is_file($tmpMeta)) {
                    unlink($tmpMeta);
                }
            }
            unlink($tmpBackup);
        }
        $this->logger->delete();
        $this->logger->delete(null, static::SESSION_FILE);
    }

    /**
     * @param string   $userData
     * @param int|null $minFreeDisk
     *
     * @return bool
     */
    private function hasEnoughFreeDisk($userData, $minFreeDisk = null)
    {
        $rootPath = $this->getRootPathByUserDataPath($userData);
        $minFreeDiskAverage = empty($minFreeDisk) || $minFreeDisk < static::MIN_FREE_DISK
            ? static::MIN_FREE_DISK : $minFreeDisk;
        $free = disk_free_space($rootPath);
        $minFree = (int)$minFreeDiskAverage;

        return ($free > 0 && $free > $minFree);
    }

    /**
     * @param string $userData
     *
     * @return string
     */
    private function getRootPathByUserDataPath($userData)
    {
        if (empty($userData)) {
            $this->oFileBackup->breakCleanUp();
            $this->logger->write('ERROR');
            $this->logger->writePersistent(sprintf('UserData Dir "%s" is missing!', $userData));
            throw new RuntimeException(sprintf('UserData Dir "%s" is missing!', $userData));
        }

        return dirname($userData);
    }

    /**
     * @return bool
     */
    public function isInLoginLockMode()
    {
        if ($this->backupSystemConfiguration->getConfiguration('login_lock_mode') === '1') {
            $timeMaintenance = (int)$this->backupSystemConfiguration->getConfiguration('login_lock_mode_time');

            if (empty($timeMaintenance)) {
                $this->backupSystemConfiguration->trySetConfiguration('login_lock_mode_time', time());

                return true;
            }

            $timeOutMaintenance = (int)$this->configurationService->getConfiguration('login_lock_mode_timeout');
            // default 10min
            $timeOut = empty($timeOutMaintenance) ? 600 : $timeOutMaintenance;

            if (time() - $timeMaintenance < $timeOut) {
                return true;
            }

            $this->backupSystemConfiguration->trySetConfiguration('login_lock_mode', 0);
            $this->backupSystemConfiguration->trySetConfiguration('login_lock_mode_time', '0');
            $this->backupSystemConfiguration->trySetConfiguration('login_lock_mode_timeout', '0');
        }

        return false;
    }

    /**
     * @param string $old_dbname
     * @param Config $config
     *
     * @return void
     */
    protected function migratePublicSubdirectory($old_dbname, Config $config)
    {
        $dbName = $config->WFdbname;
        if ($old_dbname !== $dbName) {
            $userPath = $config->WFuserdata;
            $userPath = rtrim($userPath, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
            foreach (self::$publicSubdirectories as $subdirectory) {
                $oldDbPath = $userPath . $subdirectory . DIRECTORY_SEPARATOR . $old_dbname;
                $newDbPath = $userPath . $subdirectory . DIRECTORY_SEPARATOR . $dbName;
                if (is_dir($userPath . $old_dbname) && !is_dir($userPath . $subdirectory)) {
                    $cmd = 'mv %s %s';
                    @exec(sprintf($cmd, $oldDbPath, $newDbPath));
                }
            }
        }
    }

    /**
     * @param string $name
     *
     * @throws RuntimeException
     * @return bool
     */
    public function hasExecutableExtension($name)
    {
        if (!function_exists('exec')) {
            $this->logger->writePersistent('Required Function exec is missing');
            throw new RuntimeException('Required Function exec is missing');
        }
        if (!is_string($name)) {
            return false;
        }
        exec(sprintf('whereis %s', $name), $out);
        if (empty($out)) {
            return false;
        }
        $result = $out[0];
        $resultExploded = explode(':', $result);
        array_shift($resultExploded);

        return !empty(trim(implode('', $resultExploded)));
    }
}