Application.php

Go to the documentation of this file.

<?php

namespace Elgg;

use ClassException;
use Closure;
use ConfigurationException;
use DatabaseException;
use Elgg\Application\BootHandler;
use Elgg\Application\ErrorHandler;
use Elgg\Application\ExceptionHandler;
use Elgg\Application\ShutdownHandler;
use Elgg\Database\DbConfig;
use Elgg\Di\ServiceProvider;
use Elgg\Filesystem\Directory;
use Elgg\Filesystem\Directory\Local;
use Elgg\Http\ErrorResponse;
use Elgg\Http\OkResponse;
use Elgg\Http\RedirectResponse;
use Elgg\Http\Request as HttpRequest;
use Elgg\Http\ResponseBuilder;
use Elgg\Http\ResponseTransport;
use Elgg\Project\Paths;
use Elgg\Security\UrlSigner;
use ElggInstaller;
use Exception;
use InstallationException;
use InvalidArgumentException;
use InvalidParameterException;
use SecurityException;
use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Console\Output\NullOutput;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\HttpFoundation\RedirectResponse as SymfonyRedirect;
use Symfony\Component\HttpFoundation\Response;

class Application {

    use Loggable;

    const DEFAULT_LANG = 'en';
    const DEFAULT_LIMIT = 10;

    public $_services;

    private static $_setups = [];

    public static $_instance;

    public static function getInstance() {
        if (self::$_instance === null) {
            self::$_instance = self::factory();
            self::setGlobalConfig(self::$_instance);
        }

        return self::$_instance;
    }

    public static function setInstance(Application $application = null) {
        self::$_instance = $application;
    }

    public function __construct(ServiceProvider $services) {
        $this->_services = $services;
    }

    public static function loadCore() {
        $setups = [];

        $path = Paths::elgg() . 'engine/lib';

        // include library files, capturing setup functions
        foreach (self::getEngineLibs() as $file) {
            try {
                $setups[] = self::requireSetupFileOnce("$path/$file");
            } catch (\Error $e) {
                throw new \InstallationException("Elgg lib file failed include: $path/$file");
            }
        }

        return $setups;
    }

    public static function requireSetupFileOnce($file) {
        if (isset(self::$_setups[$file])) {
            return self::$_setups[$file];
        }

        $return = Includer::requireFileOnce($file);
        self::$_setups[$file] = $return;

        return $return;
    }

    public static function start() {
        $app = self::getInstance();
        $app->bootCore();

        return $app;
    }

    public static function isCoreLoaded() {
        return function_exists('elgg');
    }

    public function bootCore() {
        $boot = new BootHandler($this);
        $boot();
    }

    public function getDbConfig() {
        return $this->_services->dbConfig;
    }

    public function getDb() {
        return $this->_services->publicDb;
    }

    public static function setGlobalConfig(Application $application) {
        global $CONFIG;
        $CONFIG = $application->_services->config;
    }

    public static function factory(array $spec = []) {

        $defaults = [
            'config' => null,
            'handle_exceptions' => true,
            'handle_shutdown' => true,
            'request' => null,
            'service_provider' => null,
            'set_start_time' => true,
            'settings_path' => null,
        ];
        $spec = array_merge($defaults, $spec);

        if ($spec['set_start_time']) {
            if (!isset($GLOBALS['START_MICROTIME'])) {
                $GLOBALS['START_MICROTIME'] = microtime(true);
            }
        }

        if ($spec['handle_exceptions']) {
            set_error_handler(new ErrorHandler());
            set_exception_handler(new ExceptionHandler());
        }

        self::loadCore();

        if (!$spec['service_provider']) {
            if (!$spec['config']) {
                $spec['config'] = Config::factory($spec['settings_path']);
            }
            $spec['service_provider'] = new ServiceProvider($spec['config']);
        }

        if ($spec['request']) {
            if ($spec['request'] instanceof HttpRequest) {
                $spec['service_provider']->setValue('request', $spec['request']);
            } else {
                throw new InvalidArgumentException("Given request is not a " . HttpRequest::class);
            }
        }

        $app = new self($spec['service_provider']);

        if ($spec['handle_shutdown']) {
            register_shutdown_function(new ShutdownHandler($app));
        }

        return $app;
    }

    public static function route(HttpRequest $request) {
        self::loadCore();

        if ($request->isRewriteCheck()) {
            $response = new OkResponse(HttpRequest::REWRITE_TEST_OUTPUT);
            return self::respond($response);
        }

        if (self::$_instance) {
            $app = self::$_instance;
            $app->_services->setValue('request', $request);
        } else {
            try {
                $app = self::factory([
                    'request' => $request,
                ]);

                self::setGlobalConfig($app);
                self::setInstance($app);
            } catch (ConfigurationException $ex) {
                return self::install();
            }
        }

        return $app->run();
    }

    public static function respond(ResponseBuilder $builder) {
        if (self::$_instance) {
            self::$_instance->_services->responseFactory->respond($builder);

            return self::$_instance->_services->responseFactory->getSentResponse();
        }

        try {
            $content = $builder->getContent();
            $status = $builder->getStatusCode();
            $headers = $builder->getHeaders();

            if ($builder->isRedirection()) {
                $forward_url = $builder->getForwardURL();
                $response = new SymfonyRedirect($forward_url, $status, $headers);
            } else {
                $response = new Response($content, $status, $headers);
            }
        } catch (Exception $ex) {
            $response = new Response($ex->getMessage(), 500);
        }

        $response->headers->set('Pragma', 'public');
        $response->headers->set('Cache-Control', 'no-cache, must-revalidate');
        $response->headers->set('Expires', 'Fri, 05 Feb 1982 00:00:00 -0500');

        self::getResponseTransport()->send($response);

        return $response;
    }

    public static function index() {
        return self::route(self::getRequest());
    }

    public function run() {
        $config = $this->_services->config;
        $request = $this->_services->request;

        try {
            if ($request->isCliServer()) {
                if ($request->isCliServable(Paths::project())) {
                    return false;
                }

                // overwrite value from settings
                $www_root = rtrim($request->getSchemeAndHttpHost() . $request->getBaseUrl(), '/') . '/';
                $config->wwwroot = $www_root;
                $config->wwwroot_cli_server = $www_root;
            }

            if (0 === strpos($request->getElggPath(), '/cache/')) {
                $config->_disable_session_save = true;
                $response = $this->_services->cacheHandler->handleRequest($request, $this)->prepare($request);
                self::getResponseTransport()->send($response);

                return $response;
            }

            if (0 === strpos($request->getElggPath(), '/serve-file/')) {
                $response = $this->_services->serveFileHandler->getResponse($request);
                self::getResponseTransport()->send($response);

                return $response;
            }

            $this->bootCore();

            // re-fetch new request from services in case it was replaced by route:rewrite
            $request = $this->_services->request;

            if (!$this->_services->router->route($request)) {
                throw new PageNotFoundException();
            }
        } catch (HttpException $ex) {
            $forward_url = $ex->getRedirectUrl();
            if (!$forward_url) {
                if ($ex instanceof GatekeeperException) {
                    $forward_url = elgg_is_logged_in() ? null : elgg_get_login_url();
                } else if ($request->getFirstUrlSegment() == 'action') {
                    $forward_url = REFERRER;
                }
            }

            $hook_params = [
                'exception' => $ex,
            ];

            $forward_url = $this->_services->hooks->trigger('forward', $ex->getCode(), $hook_params, $forward_url);

            if ($forward_url) {
                if ($ex->getMessage()) {
                    $this->_services->systemMessages->addErrorMessage($ex->getMessage());
                }
                $response = new RedirectResponse($forward_url);
            } else {
                $response = new ErrorResponse($ex->getMessage(), $ex->getCode(), $forward_url);
            }

            self::respond($response);
        }

        return $this->_services->responseFactory->getSentResponse();
    }

    public static function elggDir() {
        return Local::elggRoot();
    }

    public static function projectDir() {
        return Local::projectRoot();
    }

    public static function install() {
        ini_set('display_errors', 1);

        try {
            $installer = new ElggInstaller();
            $response = $installer->run();
        } catch (Exception $ex) {
            $response = new ErrorResponse($ex->getMessage(), 500);
        }

        return self::respond($response);
    }

    public static function upgrade() {

        try {
            self::migrate();
            self::start();

            $request = self::$_instance->_services->request;
            $signer = self::$_instance->_services->urlSigner;

            $url = $request->getCurrentURL();
            $query = $request->getParams();

            // We need to resign the URL because the path is different
            $mac = elgg_extract(UrlSigner::KEY_MAC, $query);
            if (isset($mac) && !$signer->isValid($url)) {
                throw new \Elgg\HttpException(elgg_echo('invalid_request_signature'), ELGG_HTTP_FORBIDDEN);
            }

            unset($query[UrlSigner::KEY_MAC]);

            $base_url = elgg_normalize_site_url('upgrade/init');
            $url = elgg_http_add_url_query_elements($base_url, $query);

            if (isset($mac)) {
                $url = self::$_instance->_services->urlSigner->sign($url);
            }

            $response = new RedirectResponse($url, ELGG_HTTP_PERMANENTLY_REDIRECT);
        } catch (Exception $ex) {
            $response = new ErrorResponse($ex->getMessage(), $ex->getCode() ? : ELGG_HTTP_INTERNAL_SERVER_ERROR);
        }

        return self::respond($response);
    }

    public static function migrate() {
        
        $constants = self::elggDir()->getPath('engine/lib/constants.php');
        self::requireSetupFileOnce($constants);
        
        $conf = self::elggDir()->getPath('engine/conf/migrations.php');
        if (!$conf) {
            throw new InstallationException('Settings file is required to run database migrations.');
        }

        // setting timeout because some database migrations can take a long time
        set_time_limit(0);

        $app = new \Phinx\Console\PhinxApplication();
        $wrapper = new \Phinx\Wrapper\TextWrapper($app, [
            'configuration' => $conf,
        ]);
        $log = $wrapper->getMigrate();

        if (!empty($_SERVER['argv']) && in_array('--verbose', $_SERVER['argv'])) {
            error_log($log);
        }

        return true;
    }

    public static function getMigrationSettings() {

        $config = Config::factory();
        $db_config = DbConfig::fromElggConfig($config);

        if ($db_config->isDatabaseSplit()) {
            $conn = $db_config->getConnectionConfig(DbConfig::WRITE);
        } else {
            $conn = $db_config->getConnectionConfig();
        }

        return [
            "paths" => [
                "migrations" => Paths::elgg() . 'engine/schema/migrations/',
            ],
            "environments" => [
                "default_migration_table" => "{$conn['prefix']}migrations",
                "default_database" => "prod",
                "prod" => [
                    "adapter" => "mysql",
                    "host" => $conn['host'],
                    "name" => $conn['database'],
                    "user" => $conn['user'],
                    "pass" => $conn['password'],
                    "charset" => $conn['encoding'],
                    "table_prefix" => $conn['prefix'],
                ],
            ],
        ];
    }

    public function allowPathRewrite() {
        $request = $this->_services->request;
        $new = $this->_services->router->allowRewrite($request);
        if ($new === $request) {
            return;
        }

        $this->_services->setValue('request', $new);
    }

    public static function isCli() {
        switch (php_sapi_name()) {
            case 'cli' :
            case 'phpdbg' :
                return true;

            default:
                return false;
        }
    }

    public static function getRequest() {
        if (self::$_instance) {
            return self::$_instance->_services->request;
        }

        return HttpRequest::createFromGlobals();
    }

    public static function getStdIn() {
        if (self::isCli()) {
            $request = self::getRequest();
            $argv = $request->server->get('argv') ? : [];
            return new ArgvInput($argv);
        }

        return new ArrayInput([]);
    }

    public static function getStdOut() {
        if (self::isCli()) {
            return new ConsoleOutput();
        } else {
            return new NullOutput();
        }
    }

    public static function getStdErr() {
        $std_out = self::getStdOut();
        if (is_callable([$std_out, 'getErrorOutput'])) {
            return $std_out->getErrorOutput();
        }

        return $std_out;
    }

    public static function getResponseTransport() {
        if (self::isCli()) {
            return new \Elgg\Http\OutputBufferTransport();
        }

        return new \Elgg\Http\HttpProtocolTransport();
    }

    private static function getEngineLibs() {
        return [
            'elgglib.php',
            'access.php',
            'actions.php',
            'admin.php',
            'annotations.php',
            'cache.php',
            'comments.php',
            'configuration.php',
            'constants.php',
            'cron.php',
            'database.php',
            'deprecated-2.3.php',
            'deprecated-3.0.php',
            'entities.php',
            'filestore.php',
            'group.php',
            'input.php',
            'languages.php',
            'mb_wrapper.php',
            'metadata.php',
            'navigation.php',
            'notification.php',
            'output.php',
            'pagehandler.php',
            'pageowner.php',
            'pam.php',
            'plugins.php',
            'relationships.php',
            'river.php',
            'search.php',
            'sessions.php',
            'statistics.php',
            'tags.php',
            'upgrade.php',
            'user_settings.php',
            'users.php',
            'views.php',
            'widgets.php',
        ];
    }
}