BootHandler.php

Go to the documentation of this file.

<?php
 
namespace Elgg\Application;
 
use Elgg\Application;
 
class BootHandler {
 
    public function __construct(protected Application $app) {
    }
 
    public function __invoke(): void {
        if ($this->app->getBootStatus('full_boot_completed')) {
            return;
        }
 
        $this->bootServices();
        $this->bootPlugins();
        $this->bootApplication();
    }
 
    public function bootServices(): void {
        if ($this->app->getBootStatus('service_boot_completed')) {
            return;
        }
 
        // in case not loaded already
        $this->app->loadCore();
 
        if (!$this->app->internal_services->db) {
            // no database boot!
            elgg_views_boot();
            $this->app->internal_services->session->start();
            $this->app->internal_services->translator->bootTranslations();
 
            \Elgg\Application\SystemEventHandlers::init();
 
            $this->app->setBootStatus('full_boot_completed', true);
 
            return;
        }
 
        $this->registerEntities();
        
        // need to be registered as part of services, because partial boots do at least include the services
        // the system relies on the existence of some of the event
        $this->registerEvents();
 
        // Connect to database, load language files, load configuration, init session
        $this->app->internal_services->boot->boot($this->app->internal_services);
        
        // we don't store langs in boot data because it varies by user
        $this->app->internal_services->translator->bootTranslations();
        
        $this->app->setBootStatus('service_boot_completed', true);
    }
 
    public function bootPlugins(): void {
        if ($this->app->getBootStatus('plugins_boot_completed') || !$this->app->internal_services->db) {
            return;
        }
 
        $events = $this->app->internal_services->events;
 
        $events->registerHandler('plugins_load:before', 'system', 'elgg_views_boot');
        $events->registerHandler('plugins_load:after', 'system', function() {
            $this->app->internal_services->session->boot();
        });
 
        $events->registerHandler('plugins_boot', 'system', function() {
            $this->registerRoutes();
        });
        $events->registerHandler('plugins_boot', 'system', function() {
            $this->registerActions();
        });
 
        // Setup all boot sequence handlers for active plugins
        $this->app->internal_services->plugins->build();
 
        // Register plugin classes, entities etc
        // Call PluginBootstrap::load()
        // After event completes, Elgg session is booted
        $events->triggerSequence('plugins_load', 'system');
 
        // Boot plugin, setup languages and views
        // Call PluginBootstrap::boot()
        $events->triggerSequence('plugins_boot', 'system');
 
        $this->app->setBootStatus('plugins_boot_completed', true);
    }
 
    public function bootApplication(): void {
        if ($this->app->getBootStatus('application_boot_completed') || !$this->app->internal_services->db) {
            return;
        }
 
        $events = $this->app->internal_services->events;
 
        $this->app->allowPathRewrite();
 
        // Complete the boot process for both engine and plugins
        $events->triggerSequence('init', 'system');
 
        $this->app->setBootStatus('full_boot_completed', true);
 
        // Tell the access functions the system has booted, plugins are loaded,
        // and the user is logged in so it can start caching
        $this->app->internal_services->accessCollections->markInitComplete();
        
        // System loaded and ready
        $events->triggerSequence('ready', 'system');
 
        $this->app->setBootStatus('application_boot_completed', true);
    }
 
    public function registerEntities(): void {
        $conf = \Elgg\Project\Paths::elgg() . 'engine/entities.php';
        $spec = \Elgg\Includer::includeFile($conf);
        
        foreach ($spec as $entity) {
            if (!isset($entity['type'], $entity['subtype'], $entity['class'])) {
                continue;
            }
                
            $this->app->internal_services->entityTable->setEntityClass($entity['type'], $entity['subtype'], $entity['class']);
            
            $capabilities = elgg_extract('capabilities', $entity, []);
            foreach ($capabilities as $capability => $value) {
                $this->app->internal_services->entity_capabilities->setCapability($entity['type'], $entity['subtype'], $capability, $value);
            }
        }
    }
    
    protected function registerEvents(): void {
        $conf = \Elgg\Project\Paths::elgg() . 'engine/events.php';
        $spec = \Elgg\Includer::includeFile($conf);
        
        $events = $this->app->internal_services->events;
        
        foreach ($spec as $name => $types) {
            foreach ($types as $type => $callbacks) {
                foreach ($callbacks as $callback => $event_spec) {
                    if (!is_array($event_spec)) {
                        continue;
                    }
                    
                    $unregister = (bool) elgg_extract('unregister', $event_spec, false);
                    
                    if ($unregister) {
                        $events->unregisterHandler($name, $type, $callback);
                    } else {
                        $priority = (int) elgg_extract('priority', $event_spec, 500);
                        
                        $events->registerHandler($name, $type, $callback, $priority);
                    }
                }
            }
        }
    }
    
    protected function registerRoutes(): void {
        $conf = \Elgg\Project\Paths::elgg() . 'engine/routes.php';
        $routes = \Elgg\Includer::includeFile($conf);
    
        foreach ($routes as $name => $def) {
            $this->app->internal_services->routes->register($name, $def);
        }
    }
    
    protected function registerActions(): void {
        $conf = \Elgg\Project\Paths::elgg() . 'engine/actions.php';
        $actions = \Elgg\Includer::includeFile($conf);
        
        $root_path = \Elgg\Project\Paths::elgg();
    
        foreach ($actions as $action => $action_spec) {
            if (!is_array($action_spec)) {
                continue;
            }
            
            $access = elgg_extract('access', $action_spec, 'logged_in');
            $handler = elgg_extract('controller', $action_spec);
            if (!$handler) {
                $handler = elgg_extract('filename', $action_spec) ?: "{$root_path}/actions/{$action}.php";
            }
            
            // unset handled action specs, pass the rest to the action service
            unset($action_spec['access']);
            unset($action_spec['controller']);
            unset($action_spec['filename']);
            
            $this->app->internal_services->actions->register($action, $handler, $access, $action_spec);
        }
    }
}