vendor/pimcore/pimcore/lib/Kernel.php line 266

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Commercial License (PCL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  13.  */
  14. namespace Pimcore;
  15. use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
  16. use Doctrine\Bundle\MigrationsBundle\DoctrineMigrationsBundle;
  17. use FOS\JsRoutingBundle\FOSJsRoutingBundle;
  18. use League\FlysystemBundle\FlysystemBundle;
  19. use Pimcore\Bundle\AdminBundle\PimcoreAdminBundle;
  20. use Pimcore\Bundle\CoreBundle\PimcoreCoreBundle;
  21. use Pimcore\Cache\Runtime;
  22. use Pimcore\Config\BundleConfigLocator;
  23. use Pimcore\Event\SystemEvents;
  24. use Pimcore\Extension\Bundle\Config\StateConfig;
  25. use Pimcore\HttpKernel\BundleCollection\BundleCollection;
  26. use Pimcore\HttpKernel\BundleCollection\ItemInterface;
  27. use Pimcore\HttpKernel\BundleCollection\LazyLoadedItem;
  28. use Presta\SitemapBundle\PrestaSitemapBundle;
  29. use Scheb\TwoFactorBundle\SchebTwoFactorBundle;
  30. use Sensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle;
  31. use Symfony\Bundle\DebugBundle\DebugBundle;
  32. use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
  33. use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
  34. use Symfony\Bundle\MonologBundle\MonologBundle;
  35. use Symfony\Bundle\SecurityBundle\SecurityBundle;
  36. use Symfony\Bundle\TwigBundle\TwigBundle;
  37. use Symfony\Bundle\WebProfilerBundle\WebProfilerBundle;
  38. use Symfony\Cmf\Bundle\RoutingBundle\CmfRoutingBundle;
  39. use Symfony\Component\Config\Loader\LoaderInterface;
  40. use Symfony\Component\Config\Resource\FileExistenceResource;
  41. use Symfony\Component\Config\Resource\FileResource;
  42. use Symfony\Component\DependencyInjection\ContainerBuilder;
  43. use Symfony\Component\DependencyInjection\ContainerInterface;
  44. use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
  45. use Symfony\Component\EventDispatcher\GenericEvent;
  46. use Symfony\Component\HttpKernel\Bundle\BundleInterface;
  47. use Symfony\Component\HttpKernel\Kernel as SymfonyKernel;
  48. use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
  49. abstract class Kernel extends SymfonyKernel
  50. {
  51.     use MicroKernelTrait {
  52.         registerContainerConfiguration as microKernelRegisterContainerConfiguration;
  53.         registerBundles as microKernelRegisterBundles;
  54.     }
  55.     /**
  56.      * @var Extension\Config
  57.      */
  58.     protected $extensionConfig;
  59.     /**
  60.      * @var BundleCollection
  61.      */
  62.     private $bundleCollection;
  63.     /**
  64.      * @deprecated
  65.      */
  66.     public function getRootDir()
  67.     {
  68.         trigger_deprecation(
  69.             'pimcore/pimcore',
  70.             '10.3',
  71.             'Kernel::getRootDir() is deprecated and will be removed in Pimcore 11. Use Kernel::getProjectDir() instead.',
  72.         );
  73.         return PIMCORE_PROJECT_ROOT;
  74.     }
  75.     /**
  76.      * {@inheritdoc}
  77.      */
  78.     public function getProjectDir()
  79.     {
  80.         return PIMCORE_PROJECT_ROOT;
  81.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function getCacheDir()
  86.     {
  87.         if (isset($_SERVER['APP_CACHE_DIR'])) {
  88.             return $_SERVER['APP_CACHE_DIR'].'/'.$this->environment;
  89.         }
  90.         return PIMCORE_SYMFONY_CACHE_DIRECTORY '/' $this->environment;
  91.     }
  92.     /**
  93.      * {@inheritdoc}
  94.      */
  95.     public function getLogDir()
  96.     {
  97.         return PIMCORE_LOG_DIRECTORY;
  98.     }
  99.     /**
  100.      * {@inheritdoc}
  101.      */
  102.     protected function configureContainer(ContainerConfigurator $container): void
  103.     {
  104.         $projectDir realpath($this->getProjectDir());
  105.         $container->import($projectDir '/config/{packages}/*.yaml');
  106.         $container->import($projectDir '/config/{packages}/'.$this->environment.'/*.yaml');
  107.         if (is_file($projectDir '/config/services.yaml')) {
  108.             $container->import($projectDir '/config/services.yaml');
  109.             $container->import($projectDir '/config/{services}_'.$this->environment.'.yaml');
  110.         } elseif (is_file($path $projectDir '/config/services.php')) {
  111.             (require $path)($container->withPath($path), $this);
  112.         }
  113.     }
  114.     /**
  115.      * {@inheritdoc}
  116.      */
  117.     protected function configureRoutes(RoutingConfigurator $routes): void
  118.     {
  119.         $projectDir realpath($this->getProjectDir());
  120.         $routes->import($projectDir '/config/{routes}/'.$this->environment.'/*.yaml');
  121.         $routes->import($projectDir '/config/{routes}/*.yaml');
  122.         if (is_file($projectDir '/config/routes.yaml')) {
  123.             $routes->import($projectDir '/config/routes.yaml');
  124.         } elseif (is_file($path $projectDir '/config/routes.php')) {
  125.             (require $path)($routes->withPath($path), $this);
  126.         }
  127.     }
  128.     /**
  129.      * {@inheritdoc}
  130.      */
  131.     public function registerContainerConfiguration(LoaderInterface $loader)
  132.     {
  133.         $loader->load(function (ContainerBuilder $container) {
  134.             $this->registerExtensionConfigFileResources($container);
  135.         });
  136.         $bundleConfigLocator = new BundleConfigLocator($this);
  137.         foreach ($bundleConfigLocator->locate('config') as $bundleConfig) {
  138.             $loader->load($bundleConfig);
  139.         }
  140.         $this->microKernelRegisterContainerConfiguration($loader);
  141.         //load system configuration
  142.         $systemConfigFile Config::locateConfigFile('system.yml');
  143.         if (file_exists($systemConfigFile)) {
  144.             $loader->load($systemConfigFile);
  145.         }
  146.         $configArray = [
  147.             [
  148.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_IMAGE_THUMBNAILS',
  149.                 'defaultStorageDirectoryName' => 'image-thumbnails',
  150.             ],
  151.             [
  152.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_VIDEO_THUMBNAILS',
  153.                 'defaultStorageDirectoryName' => 'video-thumbnails',
  154.             ],
  155.             [
  156.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_CUSTOM_REPORTS',
  157.                 'defaultStorageDirectoryName' => 'custom-reports',
  158.             ],
  159.             [
  160.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_DOCUMENT_TYPES',
  161.                 'defaultStorageDirectoryName' => 'document-types',
  162.             ],
  163.             [
  164.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_WEB_TO_PRINT',
  165.                 'defaultStorageDirectoryName' => 'web-to-print',
  166.             ],
  167.             [
  168.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_PREDEFINED_PROPERTIES',
  169.                 'defaultStorageDirectoryName' => 'predefined-properties',
  170.             ],
  171.             [
  172.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_PREDEFINED_ASSET_METADATA',
  173.                 'defaultStorageDirectoryName' => 'predefined-asset-metadata',
  174.             ],
  175.             [
  176.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_STATICROUTES',
  177.                 'defaultStorageDirectoryName' => 'staticroutes',
  178.             ],
  179.             [
  180.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_PERSPECTIVES',
  181.                 'defaultStorageDirectoryName' => 'perspectives',
  182.             ],
  183.             [
  184.                 'storageDirectoryEnvVariableName' => 'PIMCORE_CONFIG_STORAGE_DIR_CUSTOM_VIEWS',
  185.                 'defaultStorageDirectoryName' => 'custom-views',
  186.             ],
  187.         ];
  188.         foreach ($configArray as $config) {
  189.             $configDir rtrim($_SERVER[$config['storageDirectoryEnvVariableName']] ?? PIMCORE_CONFIGURATION_DIRECTORY '/' $config['defaultStorageDirectoryName'], '/\\');
  190.             $configDir "$configDir/";
  191.             if (is_dir($configDir)) {
  192.                 // @phpstan-ignore-next-line
  193.                 $loader->import($configDir);
  194.             }
  195.         }
  196.     }
  197.     private function registerExtensionConfigFileResources(ContainerBuilder $container)
  198.     {
  199.         $filenames = [
  200.             'extensions.php',
  201.             sprintf('extensions_%s.php'$this->getEnvironment()),
  202.         ];
  203.         $directories = [
  204.             PIMCORE_CUSTOM_CONFIGURATION_DIRECTORY,
  205.             PIMCORE_CONFIGURATION_DIRECTORY,
  206.         ];
  207.         // add possible extensions.php files as file existence resources (only for the current env)
  208.         foreach ($directories as $directory) {
  209.             foreach ($filenames as $filename) {
  210.                 $container->addResource(new FileExistenceResource($directory '/' $filename));
  211.             }
  212.         }
  213.         // add extensions.php as container resource
  214.         if ($this->extensionConfig->configFileExists()) {
  215.             $container->addResource(new FileResource($this->extensionConfig->locateConfigFile()));
  216.         }
  217.     }
  218.     /**
  219.      * {@inheritdoc}
  220.      */
  221.     public function boot()
  222.     {
  223.         if (true === $this->booted) {
  224.             // make sure container reset is handled properly
  225.             parent::boot();
  226.             return;
  227.         }
  228.         // handle system requirements
  229.         $this->setSystemRequirements();
  230.         // initialize extension manager config
  231.         $this->extensionConfig = new Extension\Config();
  232.         parent::boot();
  233.     }
  234.     /**
  235.      * {@inheritdoc}
  236.      */
  237.     public function shutdown()
  238.     {
  239.         if (true === $this->booted) {
  240.             // cleanup runtime cache, doctrine, monolog ... to free some memory and avoid locking issues
  241.             $this->container->get(\Pimcore\Helper\LongRunningHelper::class)->cleanUp();
  242.         }
  243.         parent::shutdown();
  244.     }
  245.     /**
  246.      * {@inheritdoc}
  247.      */
  248.     protected function initializeContainer()
  249.     {
  250.         parent::initializeContainer();
  251.         // initialize runtime cache (defined as synthetic service)
  252.         Runtime::getInstance();
  253.         // set the extension config on the container
  254.         $this->getContainer()->set(Extension\Config::class, $this->extensionConfig);
  255.         \Pimcore::initLogger();
  256.         \Pimcore\Cache::init();
  257.         // on pimcore shutdown
  258.         register_shutdown_function(function () {
  259.             // check if container still exists at this point as it could already
  260.             // be cleared (e.g. when running tests which boot multiple containers)
  261.             try {
  262.                 $container $this->getContainer();
  263.             } catch (\LogicException) {
  264.                 // Container is cleared. Allow tests to finish.
  265.             }
  266.             if (isset($container) && $container instanceof ContainerInterface) {
  267.                 $container->get('event_dispatcher')->dispatch(new GenericEvent(), SystemEvents::SHUTDOWN);
  268.             }
  269.             \Pimcore::shutdown();
  270.         });
  271.     }
  272.     /**
  273.      * Returns an array of bundles to register.
  274.      *
  275.      * @return BundleInterface[] An array of bundle instances
  276.      */
  277.     public function registerBundles(): array
  278.     {
  279.         $collection $this->createBundleCollection();
  280.         if (is_file($this->getProjectDir().'/config/bundles.php')) {
  281.             $flexBundles = [];
  282.             array_push($flexBundles, ...$this->microKernelRegisterBundles());
  283.             $collection->addBundles($flexBundles);
  284.         }
  285.         // core bundles (Symfony, Pimcore)
  286.         $this->registerCoreBundlesToCollection($collection);
  287.         // custom bundles
  288.         $this->registerBundlesToCollection($collection);
  289.         // bundles registered in extensions.php
  290.         $this->registerExtensionManagerBundles($collection);
  291.         $bundles $collection->getBundles($this->getEnvironment());
  292.         $this->bundleCollection $collection;
  293.         return $bundles;
  294.     }
  295.     /**
  296.      * Creates bundle collection. Use this method to set bundles on the collection
  297.      * early.
  298.      *
  299.      * @return BundleCollection
  300.      */
  301.     protected function createBundleCollection(): BundleCollection
  302.     {
  303.         return new BundleCollection();
  304.     }
  305.     /**
  306.      * Returns the bundle collection which was used to build the set of used bundles
  307.      *
  308.      * @return BundleCollection
  309.      */
  310.     public function getBundleCollection(): BundleCollection
  311.     {
  312.         return $this->bundleCollection;
  313.     }
  314.     /**
  315.      * Registers "core" bundles
  316.      *
  317.      * @param BundleCollection $collection
  318.      */
  319.     protected function registerCoreBundlesToCollection(BundleCollection $collection)
  320.     {
  321.         $collection->addBundles([
  322.             // symfony "core"/standard
  323.             new FrameworkBundle(),
  324.             new SecurityBundle(),
  325.             new TwigBundle(),
  326.             new MonologBundle(),
  327.             new DoctrineBundle(),
  328.             new DoctrineMigrationsBundle(),
  329.             new SensioFrameworkExtraBundle(),
  330.             new CmfRoutingBundle(),
  331.             new PrestaSitemapBundle(),
  332.             new SchebTwoFactorBundle(),
  333.             new FOSJsRoutingBundle(),
  334.             new FlysystemBundle(),
  335.         ], 100);
  336.         // pimcore bundles
  337.         $collection->addBundles([
  338.             new PimcoreCoreBundle(),
  339.             new PimcoreAdminBundle(),
  340.         ], 60);
  341.         // load development bundles only in matching environments
  342.         if (in_array($this->getEnvironment(), $this->getEnvironmentsForDevBundles(), true)) {
  343.             $collection->addBundles([
  344.                 new DebugBundle(),
  345.                 new WebProfilerBundle(),
  346.             ], 80);
  347.         }
  348.     }
  349.     protected function getEnvironmentsForDevBundles(): array
  350.     {
  351.         return ['dev''test'];
  352.     }
  353.     /**
  354.      * Registers bundles enabled via extension manager
  355.      *
  356.      * @param BundleCollection $collection
  357.      */
  358.     protected function registerExtensionManagerBundles(BundleCollection $collection)
  359.     {
  360.         $stateConfig = new StateConfig($this->extensionConfig);
  361.         foreach ($stateConfig->getEnabledBundles() as $className => $options) {
  362.             if (!class_exists($className)) {
  363.                 continue;
  364.             }
  365.             // do not register bundles twice - skip if it was already loaded manually
  366.             if ($collection->hasItem($className)) {
  367.                 continue;
  368.             }
  369.             // use lazy loaded item to instantiate the bundle only if environment matches
  370.             $collection->add(new LazyLoadedItem(
  371.                 $className,
  372.                 $options['priority'],
  373.                 $options['environments'],
  374.                 ItemInterface::SOURCE_EXTENSION_MANAGER_CONFIG
  375.             ));
  376.         }
  377.     }
  378.     /**
  379.      * Adds bundles to register to the bundle collection. The collection is able
  380.      * to handle priorities and environment specific bundles.
  381.      *
  382.      * To be implemented in child classes
  383.      *
  384.      * @param BundleCollection $collection
  385.      */
  386.     public function registerBundlesToCollection(BundleCollection $collection)
  387.     {
  388.     }
  389.     /**
  390.      * Handle system settings and requirements
  391.      */
  392.     protected function setSystemRequirements()
  393.     {
  394.         // try to set system-internal variables
  395.         $maxExecutionTime 240;
  396.         if (php_sapi_name() === 'cli') {
  397.             $maxExecutionTime 0;
  398.         }
  399.         //@ini_set("memory_limit", "1024M");
  400.         @ini_set('max_execution_time'$maxExecutionTime);
  401.         @set_time_limit($maxExecutionTime);
  402.         ini_set('default_charset''UTF-8');
  403.         // set internal character encoding to UTF-8
  404.         mb_internal_encoding('UTF-8');
  405.         // zlib.output_compression conflicts with while (@ob_end_flush()) ;
  406.         // see also: https://github.com/pimcore/pimcore/issues/291
  407.         if (ini_get('zlib.output_compression')) {
  408.             @ini_set('zlib.output_compression''Off');
  409.         }
  410.         // set dummy timezone if no tz is specified / required for example by the logger, ...
  411.         $defaultTimezone = @date_default_timezone_get();
  412.         if (!$defaultTimezone) {
  413.             date_default_timezone_set('UTC'); // UTC -> default timezone
  414.         }
  415.     }
  416. }