UpgradeService.php

Go to the documentation of this file.

<?php
namespace Elgg;

class UpgradeService {

    private $CONFIG;

    public function __construct() {
        global $CONFIG;
        $this->CONFIG = $CONFIG;
    }

    public function run() {
        $result = array(
            'failure' => false,
            'reason' => '',
        );

        // prevent someone from running the upgrade script in parallel (see #4643)
        if (!$this->getUpgradeMutex()) {
            $result['failure'] = true;
            $result['reason'] = _elgg_services()->translator->translate('upgrade:locked');
            return $result;
        }

        // disable the system log for upgrades to avoid exceptions when the schema changes.
        _elgg_services()->events->unregisterHandler('log', 'systemlog', 'system_log_default_logger');
        _elgg_services()->events->unregisterHandler('all', 'all', 'system_log_listener');

        // turn off time limit
        set_time_limit(0);

        if ($this->getUnprocessedUpgrades()) {
            $this->processUpgrades();
        }

        _elgg_services()->events->trigger('upgrade', 'system', null);
        elgg_flush_caches();

        $this->releaseUpgradeMutex();

        return $result;
    }

    protected function upgradeCode($version, $quiet = false) {
        $version = (int) $version;
        $upgrade_path = _elgg_services()->config->get('path') . 'engine/lib/upgrades/';
        $processed_upgrades = $this->getProcessedUpgrades();

        // upgrading from 1.7 to 1.8. Need to bootstrap.
        if (!$processed_upgrades) {
            $this->bootstrap17to18();

            // grab accurate processed upgrades
            $processed_upgrades = $this->getProcessedUpgrades();
        }

        $upgrade_files = $this->getUpgradeFiles($upgrade_path);

        if ($upgrade_files === false) {
            return false;
        }

        $upgrades = $this->getUnprocessedUpgrades($upgrade_files, $processed_upgrades);

        // Sort and execute
        sort($upgrades);

        foreach ($upgrades as $upgrade) {
            $upgrade_version = $this->getUpgradeFileVersion($upgrade);
            $success = true;

            if ($upgrade_version <= $version) {
                // skip upgrade files from before the installation version of Elgg
                // because the upgrade files from before the installation version aren't
                // added to the database.
                continue;
            }
            
            // hide all errors.
            if ($quiet) {
                // hide include errors as well as any exceptions that might happen
                try {
                    if (!@self::includeCode("$upgrade_path/$upgrade")) {
                        $success = false;
                        error_log("Could not include $upgrade_path/$upgrade");
                    }
                } catch (\Exception $e) {
                    $success = false;
                    error_log($e->getMessage());
                }
            } else {
                if (!self::includeCode("$upgrade_path/$upgrade")) {
                    $success = false;
                    error_log("Could not include $upgrade_path/$upgrade");
                }
            }

            if ($success) {
                // don't set the version to a lower number in instances where an upgrade
                // has been merged from a lower version of Elgg
                if ($upgrade_version > $version) {
                    _elgg_services()->datalist->set('version', $upgrade_version);
                }

                // incrementally set upgrade so we know where to start if something fails.
                $this->setProcessedUpgrade($upgrade);
            } else {
                return false;
            }
        }

        return true;
    }

    protected static function includeCode($file) {
        // do not remove - some upgrade scripts depend on this
        global $CONFIG;

        return include $file;
    }

    protected function setProcessedUpgrade($upgrade) {
        $processed_upgrades = $this->getProcessedUpgrades();
        $processed_upgrades[] = $upgrade;
        $processed_upgrades = array_unique($processed_upgrades);
        return _elgg_services()->datalist->set('processed_upgrades', serialize($processed_upgrades));
    }

    protected function getProcessedUpgrades() {
        $upgrades = _elgg_services()->datalist->get('processed_upgrades');
        $unserialized = unserialize($upgrades);
        return $unserialized;
    }

    protected function getUpgradeFileVersion($filename) {
        preg_match('/^([0-9]{10})([\.a-z0-9-_]+)?\.(php)$/i', $filename, $matches);

        if (isset($matches[1])) {
            return (int) $matches[1];
        }

        return false;
    }

    protected function getUpgradeFiles($upgrade_path = null) {
        if (!$upgrade_path) {
            $upgrade_path = _elgg_services()->config->get('path') . 'engine/lib/upgrades/';
        }
        $upgrade_path = sanitise_filepath($upgrade_path);
        $handle = opendir($upgrade_path);

        if (!$handle) {
            return false;
        }

        $upgrade_files = array();

        while ($upgrade_file = readdir($handle)) {
            // make sure this is a wellformed upgrade.
            if (is_dir($upgrade_path . '$upgrade_file')) {
                continue;
            }
            $upgrade_version = $this->getUpgradeFileVersion($upgrade_file);
            if (!$upgrade_version) {
                continue;
            }
            $upgrade_files[] = $upgrade_file;
        }

        sort($upgrade_files);

        return $upgrade_files;
    }

    protected function getUnprocessedUpgrades($upgrade_files = null, $processed_upgrades = null) {
        if ($upgrade_files === null) {
            $upgrade_files = $this->getUpgradeFiles();
        }

        if ($processed_upgrades === null) {
            $processed_upgrades = unserialize(_elgg_services()->datalist->get('processed_upgrades'));
            if (!is_array($processed_upgrades)) {
                $processed_upgrades = array();
            }
        }

        $unprocessed = array_diff($upgrade_files, $processed_upgrades);
        return $unprocessed;
    }

    protected function processUpgrades() {

        $dbversion = (int) _elgg_services()->datalist->get('version');

        // No version number? Oh snap...this is an upgrade from a clean installation < 1.7.
        // Run all upgrades without error reporting and hope for the best.
        // See https://github.com/elgg/elgg/issues/1432 for more.
        $quiet = !$dbversion;

        // Note: Database upgrades are deprecated as of 1.8.  Use code upgrades.  See #1433
        if ($this->dbUpgrade($dbversion, '', $quiet)) {
            system_message(_elgg_services()->translator->translate('upgrade:db'));
        }

        if ($this->upgradeCode($dbversion, $quiet)) {
            system_message(_elgg_services()->translator->translate('upgrade:core'));

            // Now we trigger an event to give the option for plugins to do something
            $upgrade_details = new \stdClass;
            $upgrade_details->from = $dbversion;
            $upgrade_details->to = elgg_get_version();

            _elgg_services()->events->trigger('upgrade', 'upgrade', $upgrade_details);

            return true;
        }

        return false;
    }

    protected function bootstrap17to18() {
        $db_version = (int) _elgg_services()->datalist->get('version');

        // the 1.8 upgrades before the upgrade system change that are interspersed with 1.7 upgrades.
        $upgrades_18 = array(
            '2010111501.php',
            '2010121601.php',
            '2010121602.php',
            '2010121701.php',
            '2010123101.php',
            '2011010101.php',
        );

        $upgrade_files = $this->getUpgradeFiles();
        $processed_upgrades = array();

        foreach ($upgrade_files as $upgrade_file) {
            // ignore if not in 1.7 format or if it's a 1.8 upgrade
            if (in_array($upgrade_file, $upgrades_18) || !preg_match("/[0-9]{10}\.php/", $upgrade_file)) {
                continue;
            }

            $upgrade_version = $this->getUpgradeFileVersion($upgrade_file);

            // this has already been run in a previous 1.7.X -> 1.7.X upgrade
            if ($upgrade_version < $db_version) {
                $this->setProcessedUpgrade($upgrade_file);
            }
        }
    }

    protected function getUpgradeMutex() {
        

        if (!$this->isUpgradeLocked()) {
            // lock it
            _elgg_services()->db->insertData("create table {$this->CONFIG->dbprefix}upgrade_lock (id INT)");
            _elgg_services()->logger->notice('Locked for upgrade.');
            return true;
        }

        _elgg_services()->logger->warn('Cannot lock for upgrade: already locked');
        return false;
    }

    public function releaseUpgradeMutex() {
        
        _elgg_services()->db->deleteData("drop table {$this->CONFIG->dbprefix}upgrade_lock");
        _elgg_services()->logger->notice('Upgrade unlocked.');
    }

    public function isUpgradeLocked() {
        

        $is_locked = count(_elgg_services()->db->getData("SHOW TABLES LIKE '{$this->CONFIG->dbprefix}upgrade_lock'"));

        return (bool)$is_locked;
    }

    protected function dbUpgrade($version, $fromdir = "", $quiet = false) {
        

        $version = (int) $version;

        if (!$fromdir) {
            $fromdir = $this->CONFIG->path . 'engine/schema/upgrades/';
        }

        $i = 0;

        if ($handle = opendir($fromdir)) {
            $sqlupgrades = array();

            while ($sqlfile = readdir($handle)) {
                if (!is_dir($fromdir . $sqlfile)) {
                    if (preg_match('/^([0-9]{10})\.(sql)$/', $sqlfile, $matches)) {
                        $sql_version = (int) $matches[1];
                        if ($sql_version > $version) {
                            $sqlupgrades[] = $sqlfile;
                        }
                    }
                }
            }

            asort($sqlupgrades);

            if (sizeof($sqlupgrades) > 0) {
                foreach ($sqlupgrades as $sqlfile) {

                    // hide all errors.
                    if ($quiet) {
                        try {
                            _elgg_services()->db->runSqlScript($fromdir . $sqlfile);
                        } catch (\DatabaseException $e) {
                            error_log($e->getmessage());
                        }
                    } else {
                        _elgg_services()->db->runSqlScript($fromdir . $sqlfile);
                    }
                    $i++;
                }
            }
        }

        return $i;
    }

}