‪TYPO3CMS  ‪main
Bootstrap.php
Go to the documentation of this file.
1 <?php
2 
3 /*
4  * This file is part of the TYPO3 CMS project.
5  *
6  * It is free software; you can redistribute it and/or modify it under
7  * the terms of the GNU General Public License, either version 2
8  * of the License, or any later version.
9  *
10  * For the full copyright and license information, please read the
11  * LICENSE.txt file that was distributed with this source code.
12  *
13  * The TYPO3 project - inspiring people to share!
14  */
15 
16 namespace ‪TYPO3\CMS\Core\Core;
17 
18 use Composer\Autoload\ClassLoader;
19 use Composer\InstalledVersions;
20 use Doctrine\Common\Annotations\AnnotationReader;
21 use Psr\Container\ContainerInterface;
22 use Psr\EventDispatcher\EventDispatcherInterface;
23 use Psr\Http\Message\ServerRequestInterface;
34 use TYPO3\CMS\Core\Configuration\ConfigurationManager;
37 use TYPO3\CMS\Core\DependencyInjection\ContainerBuilder;
40 use TYPO3\CMS\Core\Package\Cache\ComposerPackageArtifact;
44 use TYPO3\CMS\Core\Package\PackageManager;
48 
61 {
69  public static function ‪init(
70  ClassLoader $classLoader,
71  bool $failsafe = false
72  ): ContainerInterface {
73  $requestId = new ‪RequestId();
74 
75  static::initializeClassLoader($classLoader);
78  }
79 
80  static::startOutputBuffering();
81 
82  $configurationManager = static::createConfigurationManager();
83  if (!static::checkIfEssentialConfigurationExists($configurationManager)) {
84  $failsafe = true;
85  }
86  static::populateLocalConfiguration($configurationManager);
87 
88  $logManager = new ‪LogManager((string)$requestId);
89  // LogManager is used by the core ErrorHandler (using GeneralUtility::makeInstance),
90  // therefore we have to push the LogManager to GeneralUtility, in case there
91  // happen errors before we call GeneralUtility::setContainer().
92  GeneralUtility::setSingletonInstance(LogManager::class, $logManager);
93 
94  static::initializeErrorHandling();
95 
96  $disableCaching = $failsafe ? true : false;
97  $coreCache = static::createCache('core', $disableCaching);
98  $packageCache = static::createPackageCache($coreCache);
99  $packageManager = static::createPackageManager(
100  $failsafe ? FailsafePackageManager::class : PackageManager::class,
101  $packageCache
102  );
103 
104  static::setDefaultTimezone();
105  static::setMemoryLimit();
106 
107  $assetsCache = static::createCache('assets', $disableCaching);
108  $dependencyInjectionContainerCache = static::createCache('di');
109 
110  $bootState = new \stdClass();
111  $bootState->complete = false;
112  $bootState->cacheDisabled = $disableCaching;
113 
114  $builder = new ContainerBuilder([
115  ClassLoader::class => $classLoader,
116  ApplicationContext::class => ‪Environment::getContext(),
117  ConfigurationManager::class => $configurationManager,
118  LogManager::class => $logManager,
119  RequestId::class => $requestId,
120  'cache.di' => $dependencyInjectionContainerCache,
121  'cache.core' => $coreCache,
122  'cache.assets' => $assetsCache,
123  PackageManager::class => $packageManager,
124 
125  // @internal
126  'boot.state' => $bootState,
127  ]);
128 
129  $container = $builder->createDependencyInjectionContainer($packageManager, $dependencyInjectionContainerCache, $failsafe);
130 
131  // Push the container to GeneralUtility as we want to make sure its
132  // makeInstance() method creates classes using the container from now on.
133  GeneralUtility::setContainer($container);
134 
135  // Reset LogManager singleton instance in order for GeneralUtility::makeInstance()
136  // to proxy LogManager retrieval to ContainerInterface->get() from now on.
137  GeneralUtility::removeSingletonInstance(LogManager::class, $logManager);
138 
139  // Push PackageManager instance to ExtensionManagementUtility
141 
142  if ($failsafe) {
143  $bootState->complete = true;
144  return $container;
145  }
146 
147  $eventDispatcher = $container->get(EventDispatcherInterface::class);
149  static::loadTypo3LoadedExtAndExtLocalconf(true, $coreCache);
150  static::unsetReservedGlobalVariables();
151  static::loadBaseTca(true, $coreCache);
152  static::checkEncryptionKey();
153  $bootState->complete = true;
154  $eventDispatcher->dispatch(new ‪BootCompletedEvent($disableCaching));
155 
156  return $container;
157  }
158 
165  public static function ‪startOutputBuffering()
166  {
167  ob_start();
168  }
169 
178  public static function ‪baseSetup()
179  {
182  }
183  }
184 
191  public static function ‪initializeClassLoader(ClassLoader $classLoader)
192  {
194 
195  // Annotations used in unit tests
196  AnnotationReader::addGlobalIgnoredName('test');
197 
198  // Annotations that control the extension scanner
199  AnnotationReader::addGlobalIgnoredName('extensionScannerIgnoreFile');
200  AnnotationReader::addGlobalIgnoredName('extensionScannerIgnoreLine');
201  }
202 
212  public static function ‪checkIfEssentialConfigurationExists(ConfigurationManager $configurationManager): bool
213  {
215  && !file_exists(‪Environment::getLegacyConfigPath() . '/PackageStates.php')
216  ) {
217  // Early return in case system is not properly set up
218  return false;
219  }
220 
221  $systemConfigurationPath = $configurationManager->getSystemConfigurationFileLocation();
222  $additionalConfigurationPath = $configurationManager->getAdditionalConfigurationFileLocation();
223 
224  $systemConfigurationFileExists = file_exists($systemConfigurationPath);
225  $additionalConfigurationFileExists = file_exists($additionalConfigurationPath);
226  if ($systemConfigurationFileExists && $additionalConfigurationFileExists) {
227  // We have a complete configuration, off we go
228  return true;
229  }
230 
231  // If system configuration file exists and no legacy additional configuration is present, we are good
232  $legacyAdditionConfigurationPath = ‪Environment::getLegacyConfigPath() . '/AdditionalConfiguration.php';
233  $legacyAdditionalConfigurationFileExists = file_exists($legacyAdditionConfigurationPath);
234  if ($systemConfigurationFileExists && !$legacyAdditionalConfigurationFileExists) {
235  return true;
236  }
237 
238  // @deprecated All code below is deprecated and can be removed with TYPO3 v14.0 and replaced with `return false;`
239 
240  // All other cases will probably need some migration work
241  $migrated = false;
242 
243  // In case no system configuration file exists at this point, check for the legacy "LocalConfiguration"
244  // file. If it exists, move it to the new location. Otherwise, the system is not complete.
245  if (!$systemConfigurationFileExists) {
246  $legacyLocalConfigurationPath = $configurationManager->getLocalConfigurationFileLocation();
247  $legacySystemConfigurationFileExists = file_exists($legacyLocalConfigurationPath);
248  if ($legacySystemConfigurationFileExists) {
249  mkdir(dirname($systemConfigurationPath), 02775, true);
250  rename($legacyLocalConfigurationPath, $systemConfigurationPath);
251  $migrated = true;
252  } else {
253  // Directly return as essential system configuration does not exist
254  return false;
255  }
256  }
257  // In case no additional configuration file exists at this point, check for the legacy
258  // "AdditionalConfiguration" file. If it exists, move it to the new location as well.
259  if (!$additionalConfigurationFileExists && $legacyAdditionalConfigurationFileExists) {
260  rename($legacyAdditionConfigurationPath, $additionalConfigurationPath);
261  $migrated = true;
262  }
263 
264  return $migrated;
265  }
266 
274  public static function ‪createPackageManager($packageManagerClassName, ‪PackageCacheInterface $packageCache): PackageManager
275  {
276  $dependencyOrderingService = GeneralUtility::makeInstance(DependencyOrderingService::class);
278  $packageManager = new $packageManagerClassName($dependencyOrderingService);
279  $packageManager->setPackageCache($packageCache);
280  $packageManager->initialize();
281 
282  return $packageManager;
283  }
284 
289  {
291  return new ‪PackageStatesPackageCache(‪Environment::getLegacyConfigPath() . '/PackageStates.php', $coreCache);
292  }
293 
294  $composerInstallersPath = InstalledVersions::getInstallPath('typo3/cms-composer-installers');
295  if ($composerInstallersPath === null) {
296  throw new \RuntimeException('Package "typo3/cms-composer-installers" not found. Replacing the package is not allowed. Fork the package instead and pull in the fork with the same name.', 1636145677);
297  }
298 
299  return new ComposerPackageArtifact(dirname($composerInstallersPath));
300  }
301 
308  public static function ‪loadTypo3LoadedExtAndExtLocalconf($allowCaching = true, ‪FrontendInterface $coreCache = null)
309  {
310  if ($allowCaching) {
311  $coreCache = $coreCache ?? GeneralUtility::makeInstance(CacheManager::class)->getCache('core');
312  }
313  ‪ExtensionManagementUtility::loadExtLocalconf($allowCaching, $coreCache);
314  }
315 
320  public static function ‪createConfigurationManager(): ConfigurationManager
321  {
322  return new ConfigurationManager();
323  }
324 
331  protected static function ‪populateLocalConfiguration(ConfigurationManager $configurationManager)
332  {
333  $configurationManager->exportConfiguration();
334  }
335 
347  public static function ‪createCache(string ‪$identifier, bool $disableCaching = false): ‪FrontendInterface
348  {
349  $cacheConfigurations = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations'] ?? [];
350  $cacheConfigurations['di']['frontend'] = PhpFrontend::class;
351  $cacheConfigurations['di']['backend'] = ContainerBackend::class;
352  $cacheConfigurations['di']['options'] = [];
353  $configuration = $cacheConfigurations[‪$identifier] ?? [];
354 
355  $frontend = $configuration['frontend'] ?? VariableFrontend::class;
356  $backend = $configuration['backend'] ?? Typo3DatabaseBackend::class;
357  $options = $configuration['options'] ?? [];
358 
359  if ($disableCaching) {
360  $backend = NullBackend::class;
361  $options = [];
362  }
363 
364  $backendInstance = new $backend('production', $options);
365  if (!$backendInstance instanceof ‪BackendInterface) {
366  throw new ‪InvalidBackendException('"' . $backend . '" is not a valid cache backend object.', 1545260108);
367  }
368  if (is_callable([$backendInstance, 'initializeObject'])) {
369  $backendInstance->initializeObject();
370  }
371 
372  $frontendInstance = new $frontend(‪$identifier, $backendInstance);
373  if (!$frontendInstance instanceof ‪FrontendInterface) {
374  throw new ‪InvalidCacheException('"' . $frontend . '" is not a valid cache frontend object.', 1545260109);
375  }
376  if (is_callable([$frontendInstance, 'initializeObject'])) {
377  $frontendInstance->initializeObject();
378  }
379 
380  return $frontendInstance;
381  }
382 
386  protected static function ‪setDefaultTimezone()
387  {
388  $timeZone = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['phpTimeZone'];
389  if (empty($timeZone)) {
390  // Time zone from the server environment (TZ env or OS query)
391  $defaultTimeZone = @date_default_timezone_get();
392  if ($defaultTimeZone !== '') {
393  $timeZone = $defaultTimeZone;
394  } else {
395  $timeZone = 'UTC';
396  }
397  }
398  // Set default to avoid E_WARNINGs with PHP > 5.3
399  date_default_timezone_set($timeZone);
400  }
401 
407  protected static function ‪initializeErrorHandling()
408  {
409  $productionExceptionHandlerClassName = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['productionExceptionHandler'];
410  $debugExceptionHandlerClassName = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['debugExceptionHandler'];
411 
412  $errorHandlerClassName = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandler'];
413  $errorHandlerErrors = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['errorHandlerErrors'] | E_USER_DEPRECATED;
414  $exceptionalErrors = ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['exceptionalErrors'];
415 
416  $displayErrorsSetting = (int)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['displayErrors'];
417  switch ($displayErrorsSetting) {
418  case -1:
419  $ipMatchesDevelopmentSystem = ‪GeneralUtility::cmpIP(GeneralUtility::getIndpEnv('REMOTE_ADDR'), ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask']);
420  $exceptionHandlerClassName = $ipMatchesDevelopmentSystem ? $debugExceptionHandlerClassName : $productionExceptionHandlerClassName;
421  $displayErrors = $ipMatchesDevelopmentSystem ? 1 : 0;
422  $exceptionalErrors = $ipMatchesDevelopmentSystem ? $exceptionalErrors : 0;
423  break;
424  case 0:
425  $exceptionHandlerClassName = $productionExceptionHandlerClassName;
426  $displayErrors = 0;
427  break;
428  case 1:
429  $exceptionHandlerClassName = $debugExceptionHandlerClassName;
430  $displayErrors = 1;
431  break;
432  default:
433  // Throw exception if an invalid option is set. A default for displayErrors is set
434  // in very early install tool, coming from DefaultConfiguration.php. It is safe here
435  // to just throw if there is no value for whatever reason.
436  throw new \RuntimeException(
437  'The option $TYPO3_CONF_VARS[SYS][displayErrors] is not set to "-1", "0" or "1".',
438  1476046290
439  );
440  }
441  @ini_set('display_errors', (string)$displayErrors);
442 
443  if (!empty($errorHandlerClassName)) {
444  // Register an error handler for the given errorHandlerError
445  $errorHandler = GeneralUtility::makeInstance($errorHandlerClassName, $errorHandlerErrors);
446  $errorHandler->setExceptionalErrors($exceptionalErrors);
447  if (is_callable([$errorHandler, 'setDebugMode'])) {
448  $errorHandler->setDebugMode($displayErrors === 1);
449  }
450  if (is_callable([$errorHandler, 'registerErrorHandler'])) {
451  $errorHandler->registerErrorHandler();
452  }
453  }
454  if (!empty($exceptionHandlerClassName)) {
455  // Registering the exception handler is done in the constructor
456  GeneralUtility::makeInstance($exceptionHandlerClassName);
457  }
458  }
459 
464  protected static function ‪setMemoryLimit()
465  {
466  if ((int)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] > 16) {
467  @ini_set('memory_limit', (string)((int)‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['setMemoryLimit'] . 'm'));
468  }
469  }
470 
477  public static function ‪unsetReservedGlobalVariables()
478  {
479  unset(‪$GLOBALS['TCA']);
480  unset(‪$GLOBALS['BE_USER']);
481  }
482 
492  public static function ‪loadBaseTca(bool $allowCaching = true, ‪FrontendInterface $coreCache = null)
493  {
494  if ($allowCaching) {
495  $coreCache = $coreCache ?? GeneralUtility::makeInstance(CacheManager::class)->getCache('core');
496  }
497  ‪ExtensionManagementUtility::loadBaseTca($allowCaching, $coreCache);
498  }
499 
503  protected static function ‪checkEncryptionKey()
504  {
505  if (empty(‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'])) {
506  throw new \RuntimeException(
507  'TYPO3 Encryption is empty. $GLOBALS[\'TYPO3_CONF_VARS\'][\'SYS\'][\'encryptionKey\'] needs to be set for TYPO3 to work securely',
508  1502987245
509  );
510  }
511  }
512 
522  public static function ‪loadExtTables(bool $allowCaching = true, ‪FrontendInterface $coreCache = null)
523  {
524  if ($allowCaching) {
525  $coreCache = $coreCache ?? GeneralUtility::makeInstance(CacheManager::class)->getCache('core');
526  }
527  ‪ExtensionManagementUtility::loadExtTables($allowCaching, $coreCache);
528  }
529 
537  public static function ‪initializeBackendUser($className = BackendUserAuthentication::class, ServerRequestInterface $request = null)
538  {
540  $backendUser = GeneralUtility::makeInstance($className);
541  // The global must be available very early, because methods below
542  // might trigger code which relies on it. See: #45625
543  ‪$GLOBALS['BE_USER'] = $backendUser;
544  $backendUser->start($request);
545  }
546 
552  public static function ‪initializeBackendAuthentication()
553  {
554  ‪$GLOBALS['BE_USER']->backendCheckLogin();
555  }
556 
562  public static function ‪initializeLanguageObject()
563  {
564  ‪$GLOBALS['LANG'] = GeneralUtility::makeInstance(LanguageServiceFactory::class)->createFromUserPreferences(‪$GLOBALS['BE_USER']);
565  }
566 }
‪TYPO3\CMS\Core\Localization\LanguageServiceFactory
Definition: LanguageServiceFactory.php:25
‪TYPO3\CMS\Core\DependencyInjection\Cache\ContainerBackend
Definition: ContainerBackend.php:26
‪TYPO3\CMS\Core\Core\Bootstrap\baseSetup
‪static baseSetup()
Definition: Bootstrap.php:178
‪TYPO3\CMS\Core\Core\Bootstrap\loadTypo3LoadedExtAndExtLocalconf
‪static loadTypo3LoadedExtAndExtLocalconf($allowCaching=true, FrontendInterface $coreCache=null)
Definition: Bootstrap.php:308
‪TYPO3\CMS\Core\Package\FailsafePackageManager
Definition: FailsafePackageManager.php:27
‪TYPO3\CMS\Core\Core\Bootstrap\unsetReservedGlobalVariables
‪static unsetReservedGlobalVariables()
Definition: Bootstrap.php:477
‪TYPO3\CMS\Core\Package\Cache\PackageStatesPackageCache
Definition: PackageStatesPackageCache.php:32
‪TYPO3\CMS\Core\Core\Environment\isComposerMode
‪static isComposerMode()
Definition: Environment.php:137
‪TYPO3\CMS\Core\Cache\Frontend\PhpFrontend
Definition: PhpFrontend.php:25
‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility\loadExtTables
‪static loadExtTables(bool $allowCaching=true, FrontendInterface $codeCache=null)
Definition: ExtensionManagementUtility.php:1401
‪TYPO3\CMS\Core\Core\Bootstrap\createPackageCache
‪static createPackageCache(FrontendInterface $coreCache)
Definition: Bootstrap.php:288
‪TYPO3\CMS\Core\Cache\Exception\InvalidBackendException
Definition: InvalidBackendException.php:24
‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility\loadExtLocalconf
‪static loadExtLocalconf(bool $allowCaching=true, FrontendInterface $codeCache=null)
Definition: ExtensionManagementUtility.php:1169
‪TYPO3\CMS\Core\Core\ClassLoadingInformation\isClassLoadingInformationAvailable
‪static bool isClassLoadingInformationAvailable()
Definition: ClassLoadingInformation.php:81
‪TYPO3\CMS\Core\Cache\Backend\Typo3DatabaseBackend
Definition: Typo3DatabaseBackend.php:30
‪TYPO3\CMS\Core\Utility\GeneralUtility\cmpIP
‪static bool cmpIP(string $baseIP, string $list)
Definition: GeneralUtility.php:114
‪TYPO3\CMS\Core\Core\Bootstrap\checkEncryptionKey
‪static checkEncryptionKey()
Definition: Bootstrap.php:503
‪TYPO3\CMS\Core\Core\Bootstrap\setMemoryLimit
‪static setMemoryLimit()
Definition: Bootstrap.php:464
‪TYPO3\CMS\Core\Core\Environment\getLegacyConfigPath
‪static getLegacyConfigPath()
Definition: Environment.php:268
‪TYPO3\CMS\Core\Core\Bootstrap\initializeClassLoader
‪static initializeClassLoader(ClassLoader $classLoader)
Definition: Bootstrap.php:191
‪TYPO3\CMS\Core\Core\Bootstrap\createConfigurationManager
‪static createConfigurationManager()
Definition: Bootstrap.php:320
‪TYPO3\CMS\Core\Core\Bootstrap\loadBaseTca
‪static loadBaseTca(bool $allowCaching=true, FrontendInterface $coreCache=null)
Definition: Bootstrap.php:492
‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility
Definition: ExtensionManagementUtility.php:40
‪TYPO3\CMS\Core\Cache\Backend\BackendInterface
Definition: BackendInterface.php:25
‪TYPO3\CMS\Core\Core\Bootstrap\setDefaultTimezone
‪static setDefaultTimezone()
Definition: Bootstrap.php:386
‪TYPO3\CMS\Core\Core\Bootstrap\initializeLanguageObject
‪static initializeLanguageObject()
Definition: Bootstrap.php:562
‪TYPO3\CMS\Core\Core\Bootstrap\initializeBackendUser
‪static initializeBackendUser($className=BackendUserAuthentication::class, ServerRequestInterface $request=null)
Definition: Bootstrap.php:537
‪TYPO3\CMS\Core\Package\Cache\PackageCacheInterface
Definition: PackageCacheInterface.php:33
‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility\setPackageManager
‪static setPackageManager(PackageManager $packageManager)
Definition: ExtensionManagementUtility.php:61
‪TYPO3\CMS\Core\Core\Bootstrap\initializeErrorHandling
‪static initializeErrorHandling()
Definition: Bootstrap.php:407
‪TYPO3\CMS\Core\Core\Bootstrap\init
‪static init(ClassLoader $classLoader, bool $failsafe=false)
Definition: Bootstrap.php:69
‪TYPO3\CMS\Core\Cache\Frontend\VariableFrontend
Definition: VariableFrontend.php:25
‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility\loadBaseTca
‪static loadBaseTca(bool $allowCaching=true, FrontendInterface $codeCache=null)
Definition: ExtensionManagementUtility.php:1257
‪TYPO3\CMS\Core\Core\RequestId
Definition: RequestId.php:26
‪TYPO3\CMS\Core\Cache\Backend\NullBackend
Definition: NullBackend.php:22
‪TYPO3\CMS\Core\Core\Bootstrap\createPackageManager
‪static createPackageManager($packageManagerClassName, PackageCacheInterface $packageCache)
Definition: Bootstrap.php:274
‪TYPO3\CMS\Core\Cache\CacheManager
Definition: CacheManager.php:36
‪TYPO3\CMS\Core\Service\DependencyOrderingService
Definition: DependencyOrderingService.php:32
‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication
Definition: BackendUserAuthentication.php:64
‪TYPO3\CMS\Core\Cache\Exception\InvalidCacheException
Definition: InvalidCacheException.php:24
‪TYPO3\CMS\Core\Core\Event\BootCompletedEvent
Definition: BootCompletedEvent.php:24
‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface
Definition: FrontendInterface.php:22
‪TYPO3\CMS\Core\Core\Bootstrap\createCache
‪static createCache(string $identifier, bool $disableCaching=false)
Definition: Bootstrap.php:347
‪$GLOBALS
‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['adminpanel']['modules']
Definition: ext_localconf.php:25
‪TYPO3\CMS\Core\Log\LogManager
Definition: LogManager.php:33
‪TYPO3\CMS\Core\Core
Definition: ApplicationContext.php:16
‪TYPO3\CMS\Core\Core\Bootstrap
Definition: Bootstrap.php:61
‪TYPO3\CMS\Core\Core\Bootstrap\checkIfEssentialConfigurationExists
‪static bool checkIfEssentialConfigurationExists(ConfigurationManager $configurationManager)
Definition: Bootstrap.php:212
‪TYPO3\CMS\Core\Core\Bootstrap\populateLocalConfiguration
‪static populateLocalConfiguration(ConfigurationManager $configurationManager)
Definition: Bootstrap.php:331
‪TYPO3\CMS\Core\Core\ClassLoadingInformation\registerClassLoadingInformation
‪static registerClassLoadingInformation()
Definition: ClassLoadingInformation.php:108
‪TYPO3\CMS\Core\Utility\ExtensionManagementUtility\setEventDispatcher
‪static setEventDispatcher(EventDispatcherInterface $eventDispatcher)
Definition: ExtensionManagementUtility.php:71
‪TYPO3\CMS\Core\Core\Bootstrap\loadExtTables
‪static loadExtTables(bool $allowCaching=true, FrontendInterface $coreCache=null)
Definition: Bootstrap.php:522
‪TYPO3\CMS\Core\Utility\GeneralUtility
Definition: GeneralUtility.php:51
‪TYPO3\CMS\Core\Core\Bootstrap\startOutputBuffering
‪static startOutputBuffering()
Definition: Bootstrap.php:165
‪TYPO3\CMS\Core\Core\Environment\getContext
‪static getContext()
Definition: Environment.php:128
‪TYPO3\CMS\Core\Core\ClassLoadingInformation\setClassLoader
‪static setClassLoader(ClassLoader $classLoader)
Definition: ClassLoadingInformation.php:70
‪TYPO3\CMS\Core\Core\Bootstrap\initializeBackendAuthentication
‪static initializeBackendAuthentication()
Definition: Bootstrap.php:552
‪TYPO3\CMS\Webhooks\Message\$identifier
‪identifier readonly string $identifier
Definition: FileAddedMessage.php:37