Application.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Di\ServiceProvider;
use Elgg\Filesystem\Directory;
 
class Application {
 
    const GET_PATH_KEY = '__elgg_uri';
    const REWRITE_TEST_TOKEN = '__testing_rewrite';
    const REWRITE_TEST_OUTPUT = 'success';
 
    private $services;
 
    private $engine_dir;
 
    private static $testing_app;
 
    private static $public_services = [
        //'config' => true,
        'menus' => true,
        'table_columns' => true,
    ];
 
    public static $_instance;
 
    public function __construct(ServiceProvider $services) {
        $this->services = $services;
 
        if (!isset($GLOBALS['START_MICROTIME'])) {
            $GLOBALS['START_MICROTIME'] = microtime(true);
        }
 
        $services->timer->begin([]);
 
        if (!isset($GLOBALS['_ELGG'])) {
            $GLOBALS['_ELGG'] = new \stdClass();
        }
 
        $this->engine_dir = __DIR__ . '/../..';
    }
 
    public function loadSettings() {
        $this->services->config->loadSettingsFile();
    }
 
    public function loadCore() {
        if (function_exists('elgg')) {
            return;
        }
 
        $lib_dir = self::elggDir()->chroot("engine/lib");
 
        // load the rest of the library files from engine/lib/
        // All on separate lines to make diffs easy to read + make it apparent how much
        // we're actually loading on every page (Hint: it's too much).
        $lib_files = array(
            // Needs to be loaded first to correctly bootstrap
            'autoloader.php',
            'elgglib.php',
 
            // The order of these doesn't matter, so keep them alphabetical
            'access.php',
            'actions.php',
            'admin.php',
            'annotations.php',
            'cache.php',
            'comments.php',
            'configuration.php',
            'cron.php',
            'database.php',
            'entities.php',
            'extender.php',
            'filestore.php',
            'friends.php',
            'group.php',
            'input.php',
            'languages.php',
            'mb_wrapper.php',
            'memcache.php',
            'metadata.php',
            'metastrings.php',
            'navigation.php',
            'notification.php',
            'objects.php',
            'output.php',
            'pagehandler.php',
            'pageowner.php',
            'pam.php',
            'plugins.php',
            'private_settings.php',
            'relationships.php',
            'river.php',
            'sessions.php',
            'sites.php',
            'statistics.php',
            'system_log.php',
            'tags.php',
            'user_settings.php',
            'users.php',
            'upgrade.php',
            'views.php',
            'widgets.php',
 
            // backward compatibility
            'deprecated-1.9.php',
            'deprecated-1.10.php',
            'deprecated-1.11.php',
            'deprecated-1.12.php',
            'deprecated-2.1.php',
        );
 
        // isolate global scope
        call_user_func(function () use ($lib_dir, $lib_files) {
 
            $setups = array();
 
            // include library files, capturing setup functions
            foreach ($lib_files as $file) {
                $setup = (require_once $lib_dir->getPath($file));
 
                if ($setup instanceof \Closure) {
                    $setups[$file] = $setup;
                }
            }
 
            // store instance to be returned by elgg()
            self::$_instance = $this;
 
            // set up autoloading and DIC
            _elgg_services($this->services);
 
            $events = $this->services->events;
            $hooks = $this->services->hooks;
 
            // run setups
            foreach ($setups as $func) {
                $func($events, $hooks);
            }
        });
    }
 
    public static function start() {
        $app = self::create();
        $app->bootCore();
        return $app;
    }
 
    public function bootCore() {
 
        $config = $this->services->config;
 
        if ($this->isTestingApplication()) {
            throw new \RuntimeException('Unit tests should not call ' . __METHOD__);
        }
 
        if ($config->getVolatile('boot_complete')) {
            return;
        }
 
        $this->loadSettings();
 
        $config->set('boot_complete', false);
 
        // This will be overridden by the DB value but may be needed before the upgrade script can be run.
        $config->set('default_limit', 10);
 
        // in case not loaded already
        $this->loadCore();
 
        $events = $this->services->events;
 
        // Connect to database, load language files, load configuration, init session
        // Plugins can't use this event because they haven't been loaded yet.
        $events->trigger('boot', 'system');
 
        // Load the plugins that are active
        $this->services->plugins->load();
 
        $root = Directory\Local::root();
        if ($root->getPath() != self::elggDir()->getPath()) {
            // Elgg is installed as a composer dep, so try to treat the root directory
            // as a custom plugin that is always loaded last and can't be disabled...
            if (!elgg_get_config('system_cache_loaded')) {
                // configure view locations for the custom plugin (not Elgg core)
                $viewsFile = $root->getFile('views.php');
                if ($viewsFile->exists()) {
                    $viewsSpec = $viewsFile->includeFile();
                    if (is_array($viewsSpec)) {
                        _elgg_services()->views->mergeViewsSpec($viewsSpec);
                    }
                }
 
                // find views for the custom plugin (not Elgg core)
                _elgg_services()->views->registerPluginViews($root->getPath());
            }
 
            if (!elgg_get_config('i18n_loaded_from_cache')) {
                _elgg_services()->translator->registerPluginTranslations($root->getPath());
            }
 
            // This is root directory start.php, not elgg/engine/start.php
            $root_start = $root->getPath("start.php");
            if (is_file($root_start)) {
                require $root_start;
            }
        }
 
 
        // @todo move loading plugins into a single boot function that replaces 'boot', 'system' event
        // and then move this code in there.
        // This validates the view type - first opportunity to do it is after plugins load.
        $viewtype = elgg_get_viewtype();
        if (!elgg_is_registered_viewtype($viewtype)) {
            elgg_set_viewtype('default');
        }
 
        $this->allowPathRewrite();
 
        // Allows registering handlers strictly before all init, system handlers
        $events->trigger('plugins_boot', 'system');
 
        // Complete the boot process for both engine and plugins
        $events->trigger('init', 'system');
 
        $config->set('boot_complete', true);
 
        // System loaded and ready
        $events->trigger('ready', 'system');
    }
 
    public function getDb() {
        $this->loadSettings();
        return $this->services->publicDb;
    }
 
    public function __get($name) {
        if (isset(self::$public_services[$name])) {
            return $this->services->{$name};
        }
        trigger_error("Undefined property: " . __CLASS__ . ":\${$name}");
    }
 
    private static function create() {
        if (self::$_instance === null) {
            // we need to register for shutdown before Symfony registers the
            // session_write_close() function. https://github.com/Elgg/Elgg/issues/9243
            register_shutdown_function(function () {
                // There are cases where we may exit before this function is defined
                if (function_exists('_elgg_shutdown_hook')) {
                    _elgg_shutdown_hook();
                }
            });
 
            self::$_instance = new self(new Di\ServiceProvider(new Config()));
        }
 
        return self::$_instance;
    }
 
    public static function index() {
        return self::create()->run();
    }
 
    public function run() {
        $path = $this->setupPath();
 
        // allow testing from the upgrade page before the site is upgraded.
        if (isset($_GET[self::REWRITE_TEST_TOKEN])) {
            if (false !== strpos($path, self::REWRITE_TEST_TOKEN)) {
                echo self::REWRITE_TEST_OUTPUT;
            }
            return true;
        }
 
        if (php_sapi_name() === 'cli-server') {
            $www_root = "http://{$_SERVER['SERVER_NAME']}:{$_SERVER['SERVER_PORT']}/";
            $this->services->config->set('wwwroot', $www_root);
        }
 
        if (0 === strpos($path, '/cache/')) {
            (new Application\CacheHandler($this, $this->services->config, $_SERVER))->handleRequest($path);
            return true;
        }
 
        if (0 === strpos($path, '/serve-file/')) {
            $this->services->serveFileHandler->getResponse($this->services->request)->send();
            return true;
        }
 
        if ($path === '/rewrite.php') {
            require Directory\Local::root()->getPath("install.php");
            return true;
        }
 
        if (php_sapi_name() === 'cli-server') {
            // The CLI server routes ALL requests here (even existing files), so we have to check for these.
            if ($path !== '/' && Directory\Local::root()->isFile($path)) {
                // serve the requested resource as-is.
                return false;
            }
        }
 
        $this->bootCore();
 
        // TODO use formal Response object instead
        header("Content-Type: text/html;charset=utf-8");
 
        if (!$this->services->router->route($this->services->request)) {
            forward('', '404');
        }
    }
 
    public static function getDataPath() {
        $app = self::create();
        $app->services->config->loadSettingsFile();
 
        if ($GLOBALS['_ELGG']->dataroot_in_settings) {
            return $app->services->config->getVolatile('dataroot');
        }
 
        $dataroot = $app->services->datalist->get('dataroot');
        if (!$dataroot) {
            throw new \InstallationException('The datalists table lacks a value for "dataroot".');
        }
        $dataroot = rtrim($dataroot, '/\\') . DIRECTORY_SEPARATOR;
        $app->services->config->set('dataroot', $dataroot);
        return $dataroot;
    }
 
    public static function elggDir() /*: Directory*/ {
        return Directory\Local::fromPath(realpath(__DIR__ . '/../../..'));
    }
 
    public static function install() {
        ini_set('display_errors', 1);
        $installer = new \ElggInstaller();
        $step = get_input('step', 'welcome');
        $installer->run($step);
    }
 
    public static function upgrade() {
        // we want to know if an error occurs
        ini_set('display_errors', 1);
 
        define('UPGRADING', 'upgrading');
 
        self::start();
 
        $site_url = elgg_get_config('url');
        $site_host = parse_url($site_url, PHP_URL_HOST) . '/';
 
        // turn any full in-site URLs into absolute paths
        $forward_url = elgg_normalize_site_url(get_input('forward', '/admin', false));
        $forward_url = str_replace(array($site_url, $site_host), '/', $forward_url);
 
        if (strpos($forward_url, '/') !== 0) {
            $forward_url = '/' . $forward_url;
        }
 
        if (get_input('upgrade') == 'upgrade') {
 
            $upgrader = _elgg_services()->upgrades;
            $result = $upgrader->run();
            if ($result['failure'] == true) {
                register_error($result['reason']);
                forward($forward_url);
            }
        } else {
            $rewriteTester = new \ElggRewriteTester();
            $url = elgg_get_site_url() . "__testing_rewrite?__testing_rewrite=1";
            if (!$rewriteTester->runRewriteTest($url)) {
                // see if there is a problem accessing the site at all
                // due to ip restrictions for example
                if (!$rewriteTester->runLocalhostAccessTest()) {
                    // note: translation may not be available until after upgrade
                    $msg = elgg_echo("installation:htaccess:localhost:connectionfailed");
                    if ($msg === "installation:htaccess:localhost:connectionfailed") {
                        $msg = "Elgg cannot connect to itself to test rewrite rules properly. Check "
                                . "that curl is working and there are no IP restrictions preventing "
                                . "localhost connections.";
                    }
                    echo $msg;
                    exit;
                }
 
                // note: translation may not be available until after upgrade
                $msg = elgg_echo("installation:htaccess:needs_upgrade");
                if ($msg === "installation:htaccess:needs_upgrade") {
                    $msg = "You must update your .htaccess file so that the path is injected "
                        . "into the GET parameter __elgg_uri (you can use install/config/htaccess.dist as a guide).";
                }
                echo $msg;
                exit;
            }
 
            $vars = array(
                'forward' => $forward_url
            );
 
            // reset cache to have latest translations available during upgrade
            elgg_reset_system_cache();
 
            echo elgg_view_page(elgg_echo('upgrading'), '', 'upgrade', $vars);
            exit;
        }
 
        forward($forward_url);
    }
 
    private function setupPath() {
        if (!isset($_GET[self::GET_PATH_KEY]) || is_array($_GET[self::GET_PATH_KEY])) {
            if (php_sapi_name() === 'cli-server') {
                $_GET[self::GET_PATH_KEY] = (string)parse_url($_SERVER["REQUEST_URI"], PHP_URL_PATH);
            } else {
                $_GET[self::GET_PATH_KEY] = '/';
            }
        }
 
        // normalize
        $_GET[self::GET_PATH_KEY] = '/' . trim($_GET[self::GET_PATH_KEY], '/');
 
        return $_GET[self::GET_PATH_KEY];
    }
 
    private function allowPathRewrite() {
        $request = $this->services->request;
        $new = $this->services->router->allowRewrite($request);
        if ($new === $request) {
            return;
        }
 
        $this->services->setValue('request', $new);
        _elgg_set_initial_context($new);
    }
 
    public static function setTestingApplication($testing = true) {
        self::$testing_app = $testing;
    }
 
    public static function isTestingApplication() {
        return (bool) self::$testing_app;
    }
}