vendor/pimcore/pimcore/lib/Bootstrap.php line 234

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore;
  18. use Pimcore\Model\DataObject;
  19. use Pimcore\Model\Document;
  20. use Symfony\Component\Dotenv\Dotenv;
  21. use Symfony\Component\ErrorHandler\Debug;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpKernel\KernelInterface;
  25. class Bootstrap
  26. {
  27.     public static function startup()
  28.     {
  29.         self::setProjectRoot();
  30.         self::bootstrap();
  31.         $kernel = self::kernel();
  33.         return $kernel;
  34.     }
  36.     /**
  37.      * @return KernelInterface
  38.      */
  39.     public static function startupCli()
  40.     {
  41.         // ensure the cli arguments are set
  42.         if (!isset($_SERVER['argv'])) {
  43.             $_SERVER['argv'] = [];
  44.         }
  46.         self::setProjectRoot();
  48.         self::bootstrap();
  50.         $workingDirectory = getcwd();
  51.         chdir(__DIR__);
  53.         // init shell verbosity as 0 - this would normally be handled by the console application,
  54.         // but as we boot the kernel early the kernel initializes this to 3 (verbose) by default
  55.         putenv('SHELL_VERBOSITY=0');
  56.         $_ENV['SHELL_VERBOSITY'] = 0;
  57.         $_SERVER['SHELL_VERBOSITY'] = 0;
  59.         /** @var \Pimcore\Kernel $kernel */
  60.         $kernel = self::kernel();
  62.         if (is_readable($workingDirectory)) {
  63.             chdir($workingDirectory);
  64.         }
  66.         // activate inheritance for cli-scripts
  67.         \Pimcore::unsetAdminMode();
  68.         Document::setHideUnpublished(true);
  69.         DataObject::setHideUnpublished(true);
  70.         DataObject::setGetInheritedValues(true);
  71.         DataObject\Localizedfield::setGetFallbackValues(true);
  73.         // CLI has no memory/time limits
  74.         @ini_set('memory_limit', '-1');
  75.         @ini_set('max_execution_time', '-1');
  76.         @ini_set('max_input_time', '-1');
  78.         // Error reporting is enabled in CLI
  79.         @ini_set('display_errors', 'On');
  80.         @ini_set('display_startup_errors', 'On');
  82.         // Pimcore\Console handles maintenance mode through the AbstractCommand
  83.         $pimcoreConsole = (defined('PIMCORE_CONSOLE') && true === PIMCORE_CONSOLE);
  84.         if (!$pimcoreConsole) {
  85.             // skip if maintenance mode is on and the flag is not set
  86.             if (\Pimcore\Tool\Admin::isInMaintenanceMode() && !in_array('--ignore-maintenance-mode', $_SERVER['argv'])) {
  87.                 die("in maintenance mode -> skip\nset the flag --ignore-maintenance-mode to force execution\n");
  88.             }
  89.         }
  91.         return $kernel;
  92.     }
  94.     public static function setProjectRoot()
  95.     {
  96.         // this should already be defined at this point, but we include a fallback for backwards compatibility here
  97.         if (!defined('PIMCORE_PROJECT_ROOT')) {
  98.             define(
  99.                 'PIMCORE_PROJECT_ROOT',
  100.                 $_SERVER['PIMCORE_PROJECT_ROOT'] ?? $_ENV['PIMCORE_PROJECT_ROOT'] ??
  101.                 $_SERVER['REDIRECT_PIMCORE_PROJECT_ROOT'] ?? $_ENV['REDIRECT_PIMCORE_PROJECT_ROOT'] ??
  102.                 realpath(__DIR__ . '/../../../..')
  103.             );
  104.         }
  105.     }
  107.     public static function bootstrap()
  108.     {
  109.         if (defined('PIMCORE_PROJECT_ROOT') && file_exists(PIMCORE_PROJECT_ROOT . '/vendor/autoload.php')) {
  110.             // PIMCORE_PROJECT_ROOT is usually always set at this point (self::setProjectRoot()), so it makes sense to check this first
  111.             $loader = include PIMCORE_PROJECT_ROOT . '/vendor/autoload.php';
  112.         } elseif (file_exists(__DIR__ . '/../vendor/autoload.php')) {
  113.             $loader = include __DIR__ . '/../vendor/autoload.php';
  114.         } elseif (file_exists(__DIR__ . '/../../../../vendor/autoload.php')) {
  115.             $loader = include __DIR__ . '/../../../../vendor/autoload.php';
  116.         } else {
  117.             throw new \Exception('Unable to locate autoloader! Pimcore project root not found or invalid, please set/check env variable PIMCORE_PROJECT_ROOT.');
  118.         }
  120.         self::defineConstants();
  122.         /** @var \Composer\Autoload\ClassLoader $loader */
  123.         \Pimcore::setAutoloader($loader);
  124.         self::autoload();
  126.         ini_set('error_log', PIMCORE_PHP_ERROR_LOG);
  127.         ini_set('log_errors', '1');
  129.         // load a startup file if it exists - this is a good place to preconfigure the system
  130.         // before the kernel is loaded - e.g. to set trusted proxies on the request object
  131.         $startupFile = PIMCORE_PROJECT_ROOT . '/config/pimcore/startup.php';
  132.         if (file_exists($startupFile)) {
  133.             include_once $startupFile;
  134.         }
  136.         if (false === in_array(\PHP_SAPI, ['cli', 'phpdbg', 'embed'], true)) {
  137.             // see https://github.com/symfony/recipes/blob/master/symfony/framework-bundle/4.2/public/index.php#L15
  138.             if ($trustedProxies = $_SERVER['TRUSTED_PROXIES'] ?? false) {
  139.                 Request::setTrustedProxies(explode(',', $trustedProxies), Request::HEADER_X_FORWARDED_FOR | Request::HEADER_X_FORWARDED_PORT | Request::HEADER_X_FORWARDED_PROTO);
  140.             }
  141.             if ($trustedHosts = $_SERVER['TRUSTED_HOSTS'] ?? false) {
  142.                 Request::setTrustedHosts([$trustedHosts]);
  143.             }
  144.         }
  145.     }
  147.     private static function prepareEnvVariables()
  148.     {
  149.         if (!($_SERVER['PIMCORE_SKIP_DOTENV_FILE'] ?? false)) {
  150.             if (class_exists('Symfony\Component\Dotenv\Dotenv')) {
  151.                 (new Dotenv())->bootEnv(PIMCORE_PROJECT_ROOT . '/.env');
  152.             } else {
  153.                 $_SERVER += $_ENV;
  154.             }
  155.         }
  156.     }
  158.     public static function defineConstants()
  159.     {
  160.         self::prepareEnvVariables();
  162.         // load custom constants
  163.         $customConstantsFile = PIMCORE_PROJECT_ROOT . '/config/pimcore/constants.php';
  164.         if (file_exists($customConstantsFile)) {
  165.             include_once $customConstantsFile;
  166.         }
  168.         $resolveConstant = function (string $name, $default, bool $define = true) {
  169.             // return constant if defined
  170.             if (defined($name)) {
  171.                 return constant($name);
  172.             }
  174.             $value = $_SERVER[$name] ?? $default;
  175.             if ($define) {
  176.                 define($name, $value);
  177.             }
  179.             return $value;
  180.         };
  182.         // basic paths
  183.         $resolveConstant('PIMCORE_COMPOSER_PATH', PIMCORE_PROJECT_ROOT . '/vendor');
  184.         $resolveConstant('PIMCORE_COMPOSER_FILE_PATH', PIMCORE_PROJECT_ROOT);
  185.         $resolveConstant('PIMCORE_PATH', realpath(__DIR__ . '/..'));
  186.         $resolveConstant('PIMCORE_WEB_ROOT', PIMCORE_PROJECT_ROOT . '/public');
  187.         $resolveConstant('PIMCORE_PRIVATE_VAR', PIMCORE_PROJECT_ROOT . '/var');
  189.         // special directories for tests
  190.         // test mode can bei either controlled by a constant or an env variable
  191.         $testMode = (bool)$resolveConstant('PIMCORE_TEST', false, false);
  192.         if ($testMode) {
  193.             // override and initialize directories
  194.             $resolveConstant('PIMCORE_CLASS_DIRECTORY', PIMCORE_PATH . '/tests/_output/var/classes');
  196.             if (!defined('PIMCORE_TEST')) {
  197.                 define('PIMCORE_TEST', true);
  198.             }
  199.         }
  201.         // paths relying on basic paths above
  202.         $resolveConstant('PIMCORE_CUSTOM_CONFIGURATION_DIRECTORY', PIMCORE_PROJECT_ROOT . '/config/pimcore');
  203.         $resolveConstant('PIMCORE_CONFIGURATION_DIRECTORY', PIMCORE_PRIVATE_VAR . '/config');
  204.         $resolveConstant('PIMCORE_LOG_DIRECTORY', PIMCORE_PRIVATE_VAR . '/log');
  205.         $resolveConstant('PIMCORE_CACHE_DIRECTORY', PIMCORE_PRIVATE_VAR . '/cache/pimcore');
  206.         $resolveConstant('PIMCORE_LOG_FILEOBJECT_DIRECTORY', PIMCORE_PRIVATE_VAR . '/application-logger');
  207.         $resolveConstant('PIMCORE_SYMFONY_CACHE_DIRECTORY', PIMCORE_PRIVATE_VAR . '/cache');
  208.         $resolveConstant('PIMCORE_CLASS_DIRECTORY', PIMCORE_PRIVATE_VAR . '/classes');
  209.         $resolveConstant('PIMCORE_CLASS_DEFINITION_DIRECTORY', PIMCORE_CLASS_DIRECTORY);
  210.         $resolveConstant('PIMCORE_CUSTOMLAYOUT_DIRECTORY', PIMCORE_CLASS_DEFINITION_DIRECTORY . '/customlayouts');
  211.         $resolveConstant('PIMCORE_SYSTEM_TEMP_DIRECTORY', PIMCORE_PRIVATE_VAR . '/tmp');
  213.         // configure PHP's error logging
  214.         $resolveConstant('PIMCORE_PHP_ERROR_LOG', PIMCORE_LOG_DIRECTORY . '/php.log');
  215.         $resolveConstant('PIMCORE_KERNEL_CLASS', '\App\Kernel');
  216.     }
  218.     private static function autoload()
  219.     {
  220.         $loader = \Pimcore::getAutoloader();
  222.         // tell the autoloader where to find Pimcore's generated class stubs
  223.         // this is primarily necessary for tests and custom class directories, which are not covered in composer.json
  224.         $loader->addPsr4('Pimcore\\Model\\DataObject\\', PIMCORE_CLASS_DIRECTORY . '/DataObject');
  226.         if (defined('PIMCORE_APP_BUNDLE_CLASS_FILE')) {
  227.             require_once PIMCORE_APP_BUNDLE_CLASS_FILE;
  228.         }
  229.     }
  231.     /**
  232.      * @return KernelInterface
  233.      */
  234.     public static function kernel()
  235.     {
  236.         $environment = Config::getEnvironment();
  238.         $debug = (bool) ($_SERVER['APP_DEBUG'] ?? false);
  239.         if ($debug) {
  240.             umask(0000);
  241.             Debug::enable();
  242.             @ini_set('display_errors', 'On');
  243.         }
  245.         if (defined('PIMCORE_KERNEL_CLASS')) {
  246.             $kernelClass = PIMCORE_KERNEL_CLASS;
  247.         } else {
  248.             $kernelClass = '\App\Kernel';
  249.         }
  251.         if (!class_exists($kernelClass)) {
  252.             throw new \InvalidArgumentException(sprintf('Defined Kernel Class %s not found', $kernelClass));
  253.         }
  255.         if (!is_subclass_of($kernelClass, Kernel::class)) {
  256.             throw new \InvalidArgumentException(sprintf('Defined Kernel Class %s needs to extend the \Pimcore\Kernel Class', $kernelClass));
  257.         }
  259.         $kernel = new $kernelClass($environment, $debug);
  260.         \Pimcore::setKernel($kernel);
  261.         $kernel->boot();
  263.         $conf = \Pimcore::getContainer()->getParameter('pimcore.config');
  265.         if ($conf['general']['timezone']) {
  266.             date_default_timezone_set($conf['general']['timezone']);
  267.         }
  269.         return $kernel;
  270.     }
  271. }