Bootstrap.php

Go to the documentation of this file.

<?php
namespace ‪TYPO3\CMS\Core\Core;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use Composer\Autoload\ClassLoader;
use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use TYPO3\CMS\Core\Configuration\ConfigurationManager;
use ‪TYPO3\CMS\Core\Imaging\IconRegistry;
use ‪TYPO3\CMS\Core\IO\PharStreamWrapperInterceptor;
use ‪TYPO3\CMS\Core\Localization\Locales;
use ‪TYPO3\CMS\Core\Log\LogManager;
use ‪TYPO3\CMS\Core\Package\FailsafePackageManager;
use TYPO3\CMS\Core\Package\PackageManager;
use ‪TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\PharStreamWrapper\Behavior;
use TYPO3\PharStreamWrapper\Manager;
use TYPO3\PharStreamWrapper\PharStreamWrapper;
 
class ‪Bootstrap
{
    protected static ‪$instance;
 
    protected ‪$earlyInstances = [];
 
    protected ‪$limbo = false;
 
    protected function ‪__construct()
    {
    }
 
    public static function ‪init(
        ClassLoader $classLoader,
        bool $failsafe = false
    ): ContainerInterface {
        $requestId = substr(md5(uniqid('', true)), 0, 13);
 
        static::initializeClassLoader($classLoader);
        if (!‪Environment::isComposerMode() && ‪ClassLoadingInformation::isClassLoadingInformationAvailable()) {
            ‪ClassLoadingInformation::registerClassLoadingInformation();
        }
 
        static::startOutputBuffering();
 
        $configurationManager = static::createConfigurationManager();
        if (!static::checkIfEssentialConfigurationExists($configurationManager)) {
            $failsafe = true;
        }
        static::populateLocalConfiguration($configurationManager);
 
        $logManager = new ‪LogManager($requestId);
        // LogManager is used by the core ErrorHandler (using GeneralUtility::makeInstance),
        // therefore we have to push the LogManager to GeneralUtility, to ensure the requestId is set
        GeneralUtility::setSingletonInstance(LogManager::class, $logManager);
 
        static::initializeErrorHandling();
        static::initializeIO();
 
        $cacheManager = static::createCacheManager($failsafe ? true : false);
        $coreCache = $cacheManager->getCache('cache_core');
        $assetsCache = $cacheManager->getCache('assets');
        $cacheManager->setLimbo(true);
        $packageManager = static::createPackageManager(
            $failsafe ? FailsafePackageManager::class : PackageManager::class,
            $coreCache
        );
 
        // Push singleton instances to GeneralUtility and ExtensionManagementUtility
        // They should be fetched through a container (later) but currently a PackageManager
        // singleton instance is required by PackageManager->activePackageDuringRuntime
        GeneralUtility::setSingletonInstance(CacheManager::class, $cacheManager);
        GeneralUtility::setSingletonInstance(PackageManager::class, $packageManager);
        ‪ExtensionManagementUtility::setPackageManager($packageManager);
 
        static::initializeRuntimeActivatedPackagesFromConfiguration($packageManager);
 
        static::setDefaultTimeZone();
        ‪$locales = ‪Locales::initialize();
        static::setMemoryLimit();
 
        // Create (to be deprecated) bootstrap instance with (to be deprecated) early instances
        static::$instance = new static();
        static::$instance->earlyInstances = [
            ClassLoader::class => $classLoader,
            ConfigurationManager::class => $configurationManager,
            CacheManager::class => $cacheManager,
            PackageManager::class => $packageManager,
        ];
 
        if (!$failsafe) {
            ‪IconRegistry::setCache($assetsCache);
            ‪PageRenderer::setCache($assetsCache);
            static::loadTypo3LoadedExtAndExtLocalconf(true, $coreCache);
            static::setFinalCachingFrameworkCacheConfiguration($cacheManager);
            static::unsetReservedGlobalVariables();
            static::loadBaseTca(true, $coreCache);
            static::checkEncryptionKey();
        }
        $cacheManager->setLimbo(false);
 
        $defaultContainerEntries = [
            ClassLoader::class => $classLoader,
            'request.id' => $requestId,
            ConfigurationManager::class => $configurationManager,
            LogManager::class => $logManager,
            CacheManager::class => $cacheManager,
            PackageManager::class => $packageManager,
            Locales::class => ‪$locales,
        ];
 
        return new class($defaultContainerEntries) implements ContainerInterface {
            private $entries;
 
            public function ‪__construct(array $entries)
            {
                $this->entries = $entries;
            }
 
            public function has($id)
            {
                if (isset($this->entries[$id])) {
                    return true;
                }
 
                switch ($id) {
                case \TYPO3\CMS\Frontend\Http\Application::class:
                case \TYPO3\CMS\Backend\Http\Application::class:
                case \TYPO3\CMS\Install\Http\Application::class:
                case \TYPO3\CMS\Core\Console\CommandApplication::class:
                    return true;
                }
 
                return false;
            }
 
            public function get($id)
            {
                $entry = null;
 
                if (isset($this->entries[$id])) {
                    return $this->entries[$id];
                }
 
                switch ($id) {
                case \TYPO3\CMS\Frontend\Http\Application::class:
                case \TYPO3\CMS\Backend\Http\Application::class:
                    $entry = new $id($this->get(ConfigurationManager::class));
                    break;
                case \TYPO3\CMS\Install\Http\Application::class:
                    $entry = new $id(
                        GeneralUtility::makeInstance(\‪TYPO3\CMS\Install\Http\RequestHandler::class, $this->get(ConfigurationManager::class)),
                        GeneralUtility::makeInstance(\‪TYPO3\CMS\Install\Http\InstallerRequestHandler::class)
                    );
                    break;
                case \TYPO3\CMS\Core\Console\CommandApplication::class:
                    $entry = new $id;
                    break;
                default:
                    throw new class($id . ' not found', 1518638338) extends \‪Exception implements NotFoundExceptionInterface {
                    };
                    break;
                }
 
                $this->entries[$id] = $entry;
 
                return $entry;
            }
        };
    }
 
    public static function ‪usesComposerClassLoading()
    {
        trigger_error('Bootstrap::usesComposerClassLoading() will be removed in TYPO3 v10.0. Use Environment::isComposerMode() instead.', E_USER_DEPRECATED);
        return ‪Environment::isComposerMode();
    }
 
    protected function ‪__clone()
    {
    }
 
    public static function ‪getInstance()
    {
        if (static::$instance === null) {
            self::$instance = new static();
            self::$instance->‪defineTypo3RequestTypes();
            $requestId = substr(md5(uniqid('', true)), 0, 13);
            GeneralUtility::setSingletonInstance(LogManager::class, new ‪LogManager($requestId));
        }
        return static::$instance;
    }
 
    public static function ‪createApplicationContext(): ApplicationContext
    {
        $applicationContext = getenv('TYPO3_CONTEXT') ?: (getenv('REDIRECT_TYPO3_CONTEXT') ?: 'Production');
 
        return new ApplicationContext($applicationContext);
    }
 
    public static function ‪startOutputBuffering()
    {
        ob_start();
        return static::$instance;
    }
 
    public function ‪configure()
    {
        $this->‪startOutputBuffering()
            ->‪loadConfigurationAndInitialize(true, \‪TYPO3\CMS\Core\Package\PackageManager::class, true)
            ->‪loadTypo3LoadedExtAndExtLocalconf(true)
            ->‪setFinalCachingFrameworkCacheConfiguration()
            ->‪unsetReservedGlobalVariables()
            ->‪loadBaseTca()
            ->‪checkEncryptionKey();
        return $this;
    }
 
    public static function ‪baseSetup($entryPointLevel = null)
    {
        if (!defined('TYPO3_REQUESTTYPE')) {
            throw new \RuntimeException('No Request Type was set, TYPO3 does not know in which context it is run.', 1450561838);
        }
        // @deprecated: remove this code block in TYPO3 v10.0
        if (GeneralUtility::getApplicationContext() === null) {
            ‪SystemEnvironmentBuilder::run($entryPointLevel ?? 0, PHP_SAPI === 'cli' ? ‪SystemEnvironmentBuilder::REQUESTTYPE_CLI : ‪SystemEnvironmentBuilder::REQUESTTYPE_FE);
        }
        if (!‪Environment::isComposerMode() && ‪ClassLoadingInformation::isClassLoadingInformationAvailable()) {
            ‪ClassLoadingInformation::registerClassLoadingInformation();
        }
        return static::$instance;
    }
 
    public static function ‪initializeClassLoader(ClassLoader $classLoader)
    {
        ‪ClassLoadingInformation::setClassLoader($classLoader);
 
        AnnotationRegistry::registerLoader([$classLoader, 'loadClass']);
 
        /*
         * All annotations defined by and for Extbase need to be
         * ignored during their deprecation. Later, their usage may and
         * should throw an Exception
         */
        AnnotationReader::addGlobalIgnoredName('inject');
        AnnotationReader::addGlobalIgnoredName('transient');
        AnnotationReader::addGlobalIgnoredName('lazy');
        AnnotationReader::addGlobalIgnoredName('validate');
        AnnotationReader::addGlobalIgnoredName('cascade');
        AnnotationReader::addGlobalIgnoredName('ignorevalidation');
        AnnotationReader::addGlobalIgnoredName('cli');
        AnnotationReader::addGlobalIgnoredName('flushesCaches');
        AnnotationReader::addGlobalIgnoredName('uuid');
        AnnotationReader::addGlobalIgnoredName('identity');
 
        // Annotations used in unit tests
        AnnotationReader::addGlobalIgnoredName('test');
 
        // Annotations that control the extension scanner
        AnnotationReader::addGlobalIgnoredName('extensionScannerIgnoreFile');
        AnnotationReader::addGlobalIgnoredName('extensionScannerIgnoreLine');
 
        return static::$instance;
    }
 
    protected static function ‪checkIfEssentialConfigurationExists(ConfigurationManager $configurationManager = null): bool
    {
        if ($configurationManager === null) {
            // @deprecated A configurationManager instance needs to be handed into Bootstrap::checkIfEssentialConfigurationExists and will become mandatory in TYPO3 v10.0
            $configurationManager = new ConfigurationManager;
            static::$instance->setEarlyInstance(ConfigurationManager::class, $configurationManager);
        }
        return file_exists($configurationManager->getLocalConfigurationFileLocation())
            && file_exists(‪Environment::getLegacyConfigPath() . '/PackageStates.php');
    }
 
    public function ‪setEarlyInstance($objectName, ‪$instance)
    {
        $this->earlyInstances[$objectName] = ‪$instance;
    }
 
    public function ‪getEarlyInstance($objectName)
    {
        if (!isset($this->earlyInstances[$objectName])) {
            throw new \TYPO3\CMS\Core\Exception('Unknown early instance "' . $objectName . '"', 1365167380);
        }
        return $this->earlyInstances[$objectName];
    }
 
    public function ‪getEarlyInstances()
    {
        trigger_error('Bootstrap->getEarlyInstances() will be removed in TYPO3 v10.0. Use a simple singleton instance instead.', E_USER_DEPRECATED);
        return ‪$this->earlyInstances;
    }
 
    public static function ‪loadConfigurationAndInitialize(
        $allowCaching = true,
        $packageManagerClassName = \‪TYPO3\CMS\Core\Package\PackageManager::class,
        $isInternalCall = false
    ) {
        if (!$isInternalCall) {
            // Suppress duplicate deprecation calls
            trigger_error('Bootstrap::loadConfigurationAndInitialize() will removed in TYPO3 v10.0.', E_USER_DEPRECATED);
        }
 
        $configurationManager = static::createConfigurationManager();
        static::populateLocalConfiguration($configurationManager);
        static::initializeErrorHandling();
 
        $cacheManager = static::createCacheManager(!$allowCaching);
        $packageManager = static::createPackageManager($packageManagerClassName, $cacheManager->getCache('cache_core'));
 
        GeneralUtility::setSingletonInstance(CacheManager::class, $cacheManager);
        GeneralUtility::setSingletonInstance(PackageManager::class, $packageManager);
        ‪ExtensionManagementUtility::setPackageManager($packageManager);
 
        static::initializeRuntimeActivatedPackagesFromConfiguration($packageManager);
        static::setDefaultTimezone();
        ‪Locales::initialize();
        static::setMemoryLimit();
        return static::$instance;
    }
 
    public static function ‪createPackageManager($packageManagerClassName, FrontendInterface $coreCache): PackageManager
    {
        $dependencyOrderingService = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Service\DependencyOrderingService::class);
        $packageManager = new $packageManagerClassName($dependencyOrderingService);
        $packageManager->injectCoreCache($coreCache);
        $packageManager->initialize();
 
        return $packageManager;
    }
 
    public function ‪initializePackageManagement($packageManagerClassName)
    {
        trigger_error('Bootstrap->initializePackageManagement() will be removed in TYPO3 v10.0. Use createPackageManager() instead.', E_USER_DEPRECATED);
        $packageManager = static::createPackageManager(
            $packageManagerClassName,
            GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_core')
        );
        GeneralUtility::setSingletonInstance(PackageManager::class, $packageManager);
        ‪ExtensionManagementUtility::setPackageManager($packageManager);
        $this->‪setEarlyInstance(PackageManager::class, $packageManager);
 
        return $this;
    }
 
    protected static function ‪initializeRuntimeActivatedPackagesFromConfiguration(PackageManager $packageManager)
    {
        $packages = ‪$GLOBALS['TYPO3_CONF_VARS']['EXT']['runtimeActivatedPackages'] ?? [];
        if (!empty($packages)) {
            foreach ($packages as $runtimeAddedPackageKey) {
                $packageManager->activatePackageDuringRuntime($runtimeAddedPackageKey);
            }
        }
    }
 
    public static function ‪loadTypo3LoadedExtAndExtLocalconf($allowCaching = true, FrontendInterface $coreCache = null)
    {
        if ($allowCaching) {
            $coreCache = $coreCache ?? GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_core');
        }
        ‪ExtensionManagementUtility::loadExtLocalconf($allowCaching, $coreCache);
        return static::$instance;
    }
 
    public static function ‪createConfigurationManager(): ConfigurationManager
    {
        return new ConfigurationManager();
    }
 
    protected static function ‪populateLocalConfiguration(ConfigurationManager $configurationManager = null)
    {
        if ($configurationManager === null) {
            $configurationManager = new ConfigurationManager();
            static::$instance->setEarlyInstance(ConfigurationManager::class, $configurationManager);
        }
 
        $configurationManager->exportConfiguration();
 
        return static::$instance;
    }
 
    public static function ‪disableCoreCache()
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_core']['backend']
            = \TYPO3\CMS\Core\Cache\Backend\NullBackend::class;
        unset(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['cache_core']['options']);
        return static::$instance;
    }
 
    public static function ‪createCacheManager(bool $disableCaching = false): CacheManager
    {
        $cacheManager = new CacheManager($disableCaching);
        $cacheManager->setCacheConfigurations(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
        return $cacheManager;
    }
 
    public function ‪initializeCachingFramework(bool $allowCaching = true)
    {
        $cacheManager = static::createCacheManager(!$allowCaching);
        GeneralUtility::setSingletonInstance(CacheManager::class, $cacheManager);
        $this->‪setEarlyInstance(CacheManager::class, $cacheManager);
        return $this;
    }
 
    protected static function ‪setDefaultTimezone()
    {
        $timeZone = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['phpTimeZone'];
        if (empty($timeZone)) {
            // Time zone from the server environment (TZ env or OS query)
            $defaultTimeZone = @date_default_timezone_get();
            if ($defaultTimeZone !== '') {
                $timeZone = $defaultTimeZone;
            } else {
                $timeZone = 'UTC';
            }
        }
        // Set default to avoid E_WARNINGs with PHP > 5.3
        date_default_timezone_set($timeZone);
    }
 
    protected static function ‪initializeErrorHandling()
    {
        $productionExceptionHandlerClassName = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['productionExceptionHandler'];
        $debugExceptionHandlerClassName = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['debugExceptionHandler'];
 
        $errorHandlerClassName = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandler'];
        $errorHandlerErrors = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandlerErrors'] | E_USER_DEPRECATED;
        $exceptionalErrors = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['exceptionalErrors'];
 
        $displayErrorsSetting = (int)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['displayErrors'];
        switch ($displayErrorsSetting) {
            case -1:
                $ipMatchesDevelopmentSystem = GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);
                $exceptionHandlerClassName = $ipMatchesDevelopmentSystem ? $debugExceptionHandlerClassName : $productionExceptionHandlerClassName;
                $displayErrors = $ipMatchesDevelopmentSystem ? 1 : 0;
                $exceptionalErrors = $ipMatchesDevelopmentSystem ? $exceptionalErrors : 0;
                break;
            case 0:
                $exceptionHandlerClassName = $productionExceptionHandlerClassName;
                $displayErrors = 0;
                break;
            case 1:
                $exceptionHandlerClassName = $debugExceptionHandlerClassName;
                $displayErrors = 1;
                break;
            default:
                if (!(TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_INSTALL)) {
                    // Throw exception if an invalid option is set.
                    throw new \RuntimeException(
                        'The option $TYPO3_CONF_VARS[SYS][displayErrors] is not set to "-1", "0" or "1".',
                        1476046290
                    );
                }
        }
        @ini_set('display_errors', (string)$displayErrors);
 
        if (!empty($errorHandlerClassName)) {
            // Register an error handler for the given errorHandlerError
            $errorHandler = GeneralUtility::makeInstance($errorHandlerClassName, $errorHandlerErrors);
            $errorHandler->setExceptionalErrors($exceptionalErrors);
            if (is_callable([$errorHandler, 'setDebugMode'])) {
                $errorHandler->setDebugMode($displayErrors === 1);
            }
            if (is_callable([$errorHandler, 'registerErrorHandler'])) {
                $errorHandler->registerErrorHandler();
            }
        }
        if (!empty($exceptionHandlerClassName)) {
            // Registering the exception handler is done in the constructor
            GeneralUtility::makeInstance($exceptionHandlerClassName);
        }
    }
 
    protected static function ‪initializeIO()
    {
        if (in_array('phar', stream_get_wrappers())) {
            // destroy and re-initialize PharStreamWrapper for TYPO3 core
            Manager::destroy();
            Manager::initialize(
                (new Behavior())
                    ->withAssertion(new ‪PharStreamWrapperInterceptor())
            );
 
            stream_wrapper_unregister('phar');
            stream_wrapper_register('phar', PharStreamWrapper::class);
        }
    }
 
    protected static function ‪setMemoryLimit()
    {
        if ((int)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] > 16) {
            @ini_set('memory_limit', (string)((int)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] . 'm'));
        }
    }
 
    protected function ‪defineTypo3RequestTypes()
    {
        if (defined('TYPO3_REQUESTTYPE_FE')) {
            return;
        }
        define('TYPO3_REQUESTTYPE_FE', 1);
        define('TYPO3_REQUESTTYPE_BE', 2);
        define('TYPO3_REQUESTTYPE_CLI', 4);
        define('TYPO3_REQUESTTYPE_AJAX', 8);
        define('TYPO3_REQUESTTYPE_INSTALL', 16);
    }
 
    public function ‪setRequestType($requestType)
    {
        if (defined('TYPO3_REQUESTTYPE')) {
            throw new \RuntimeException('TYPO3_REQUESTTYPE has already been set, cannot be called multiple times', 1450561878);
        }
        define('TYPO3_REQUESTTYPE', $requestType);
        return $this;
    }
 
    protected static function ‪setFinalCachingFrameworkCacheConfiguration(CacheManager $cacheManager = null)
    {
        if ($cacheManager === null) {
            $cacheManager = GeneralUtility::makeInstance(CacheManager::class);
        }
        $cacheManager->setCacheConfigurations(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']);
        return static::$instance;
    }
 
    public static function ‪unsetReservedGlobalVariables()
    {
        unset(‪$GLOBALS['PAGES_TYPES']);
        unset(‪$GLOBALS['TCA']);
        unset(‪$GLOBALS['TBE_MODULES']);
        unset(‪$GLOBALS['TBE_STYLES']);
        unset(‪$GLOBALS['BE_USER']);
        // Those set otherwise:
        unset(‪$GLOBALS['TBE_MODULES_EXT']);
        unset(‪$GLOBALS['TCA_DESCR']);
        unset(‪$GLOBALS['LOCAL_LANG']);
        return static::$instance;
    }
 
    public static function ‪loadBaseTca(bool $allowCaching = true, FrontendInterface $coreCache = null)
    {
        if ($allowCaching) {
            $coreCache = $coreCache ?? GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_core');
        }
        ‪ExtensionManagementUtility::loadBaseTca($allowCaching, $coreCache);
        return static::$instance;
    }
 
    protected static function ‪checkEncryptionKey()
    {
        if (empty(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'])) {
            throw new \RuntimeException(
                'TYPO3 Encryption is empty. $GLOBALS[\'TYPO3_CONF_VARS\'][\'SYS\'][\'encryptionKey\'] needs to be set for TYPO3 to work securely',
                1502987245
            );
        }
    }
 
    public static function ‪loadExtTables(bool $allowCaching = true)
    {
        ‪ExtensionManagementUtility::loadExtTables($allowCaching);
        static::runExtTablesPostProcessingHooks();
        return static::$instance;
    }
 
    protected static function ‪runExtTablesPostProcessingHooks()
    {
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['GLOBAL']['extTablesInclusion-PostProcessing'] ?? [] as $className) {
            $hookObject = GeneralUtility::makeInstance($className);
            if (!$hookObject instanceof \‪TYPO3\CMS\Core\Database\TableConfigurationPostProcessingHookInterface) {
                throw new \UnexpectedValueException(
                    '$hookObject "' . $className . '" must implement interface TYPO3\\CMS\\Core\\Database\\TableConfigurationPostProcessingHookInterface',
                    1320585902
                );
            }
            $hookObject->processData();
        }
    }
 
    public static function ‪initializeBackendRouter()
    {
        // See if the Routes.php from all active packages have been built together already
        $cacheIdentifier = 'BackendRoutesFromPackages_' . sha1(TYPO3_version . ‪Environment::getProjectPath() . 'BackendRoutesFromPackages');
 
        $codeCache = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Cache\CacheManager::class)->getCache('cache_core');
        $routesFromPackages = [];
        if ($codeCache->has($cacheIdentifier)) {
            // substr is necessary, because the php frontend wraps php code around the cache value
            $routesFromPackages = unserialize(substr($codeCache->get($cacheIdentifier), 6, -2));
        } else {
            // Loop over all packages and check for a Configuration/Backend/Routes.php file
            $packageManager = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Package\PackageManager::class);
            $packages = $packageManager->getActivePackages();
            foreach ($packages as $package) {
                $routesFileNameForPackage = $package->getPackagePath() . 'Configuration/Backend/Routes.php';
                if (file_exists($routesFileNameForPackage)) {
                    $definedRoutesInPackage = require $routesFileNameForPackage;
                    if (is_array($definedRoutesInPackage)) {
                        $routesFromPackages = array_merge($routesFromPackages, $definedRoutesInPackage);
                    }
                }
                $routesFileNameForPackage = $package->getPackagePath() . 'Configuration/Backend/AjaxRoutes.php';
                if (file_exists($routesFileNameForPackage)) {
                    $definedRoutesInPackage = require $routesFileNameForPackage;
                    if (is_array($definedRoutesInPackage)) {
                        foreach ($definedRoutesInPackage as $routeIdentifier => $routeOptions) {
                            // prefix the route with "ajax_" as "namespace"
                            $routeOptions['path'] = '/ajax' . $routeOptions['path'];
                            $routesFromPackages['ajax_' . $routeIdentifier] = $routeOptions;
                            $routesFromPackages['ajax_' . $routeIdentifier]['ajax'] = true;
                        }
                    }
                }
            }
            // Store the data from all packages in the cache
            $codeCache->set($cacheIdentifier, serialize($routesFromPackages));
        }
 
        // Build Route objects from the data
        $router = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Routing\Router::class);
        foreach ($routesFromPackages as $name => $options) {
            $path = $options['path'];
            unset($options['path']);
            $route = GeneralUtility::makeInstance(\‪TYPO3\CMS\Backend\Routing\Route::class, $path, $options);
            $router->addRoute($name, $route);
        }
        return static::$instance;
    }
 
    public static function ‪initializeBackendUser($className = \‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication::class)
    {
        $backendUser = GeneralUtility::makeInstance($className);
        // The global must be available very early, because methods below
        // might trigger code which relies on it. See: #45625
        ‪$GLOBALS['BE_USER'] = $backendUser;
        $backendUser->start();
        return static::$instance;
    }
 
    public static function ‪initializeBackendAuthentication($proceedIfNoUserIsLoggedIn = false)
    {
        ‪$GLOBALS['BE_USER']->backendCheckLogin($proceedIfNoUserIsLoggedIn);
        return static::$instance;
    }
 
    public static function ‪initializeLanguageObject()
    {
        ‪$GLOBALS['LANG'] = GeneralUtility::makeInstance(\‪TYPO3\CMS\Core\Localization\LanguageService::class);
        ‪$GLOBALS['LANG']->init(‪$GLOBALS['BE_USER']->uc['lang']);
        return static::$instance;
    }
 
    public static function ‪__callStatic($methodName, array $arguments)
    {
        switch ($methodName) {
            case 'checkIfEssentialConfigurationExists':
            case 'setFinalCachingFrameworkCacheConfiguration':
            case 'populateLocalConfiguration':
                return call_user_func_array([self::class, $methodName], $arguments);
            default:
                throw new \Error(sprintf('Call to undefined method "%s"', $methodName), 1534156090);
        }
    }
 
    public function ‪__call($methodName, array $arguments)
    {
        return ‪self::__callStatic($methodName, $arguments);
    }
}