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

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.         (new Dotenv())->bootEnv(PIMCORE_PROJECT_ROOT .'/.env');
  150.     }
  152.     public static function defineConstants()
  153.     {
  154.         self::prepareEnvVariables();
  156.         // load custom constants
  157.         $customConstantsFile = PIMCORE_PROJECT_ROOT . '/config/pimcore/constants.php';
  158.         if (file_exists($customConstantsFile)) {
  159.             include_once $customConstantsFile;
  160.         }
  162.         $resolveConstant = function (string $name, $default, bool $define = true) {
  163.             // return constant if defined
  164.             if (defined($name)) {
  165.                 return constant($name);
  166.             }
  168.             $value = $_SERVER[$name] ?? $default;
  169.             if ($define) {
  170.                 define($name, $value);
  171.             }
  173.             return $value;
  174.         };
  176.         // basic paths
  177.         $resolveConstant('PIMCORE_COMPOSER_PATH', PIMCORE_PROJECT_ROOT . '/vendor');
  178.         $resolveConstant('PIMCORE_COMPOSER_FILE_PATH', PIMCORE_PROJECT_ROOT);
  179.         $resolveConstant('PIMCORE_PATH', realpath(__DIR__ . '/..'));
  180.         $resolveConstant('PIMCORE_WEB_ROOT', PIMCORE_PROJECT_ROOT . '/public');
  181.         $resolveConstant('PIMCORE_PRIVATE_VAR', PIMCORE_PROJECT_ROOT . '/var');
  183.         // special directories for tests
  184.         // test mode can bei either controlled by a constant or an env variable
  185.         $testMode = (bool)$resolveConstant('PIMCORE_TEST', false, false);
  186.         if ($testMode) {
  187.             // override and initialize directories
  188.             $resolveConstant('PIMCORE_CLASS_DIRECTORY', PIMCORE_PATH . '/tests/_output/var/classes');
  190.             if (!defined('PIMCORE_TEST')) {
  191.                 define('PIMCORE_TEST', true);
  192.             }
  193.         }
  195.         // paths relying on basic paths above
  196.         $resolveConstant('PIMCORE_CUSTOM_CONFIGURATION_DIRECTORY', PIMCORE_PROJECT_ROOT . '/config/pimcore');
  197.         $resolveConstant('PIMCORE_CONFIGURATION_DIRECTORY', PIMCORE_PRIVATE_VAR . '/config');
  198.         $resolveConstant('PIMCORE_LOG_DIRECTORY', PIMCORE_PRIVATE_VAR . '/log');
  199.         $resolveConstant('PIMCORE_LOG_FILEOBJECT_DIRECTORY', PIMCORE_PRIVATE_VAR . '/application-logger');
  200.         $resolveConstant('PIMCORE_CACHE_DIRECTORY', PIMCORE_PRIVATE_VAR . '/cache/pimcore');
  201.         $resolveConstant('PIMCORE_SYMFONY_CACHE_DIRECTORY', PIMCORE_PRIVATE_VAR . '/cache');
  202.         $resolveConstant('PIMCORE_CLASS_DIRECTORY', PIMCORE_PRIVATE_VAR . '/classes');
  203.         $resolveConstant('PIMCORE_CLASS_DEFINITION_DIRECTORY', PIMCORE_CLASS_DIRECTORY);
  204.         $resolveConstant('PIMCORE_CUSTOMLAYOUT_DIRECTORY', PIMCORE_CLASS_DEFINITION_DIRECTORY . '/customlayouts');
  205.         $resolveConstant('PIMCORE_SYSTEM_TEMP_DIRECTORY', PIMCORE_PRIVATE_VAR . '/tmp');
  206.         $resolveConstant('PIMCORE_LOG_MAIL_PERMANENT', PIMCORE_PRIVATE_VAR . '/email');
  208.         // configure PHP's error logging
  209.         $resolveConstant('PIMCORE_PHP_ERROR_LOG', PIMCORE_LOG_DIRECTORY . '/php.log');
  210.         $resolveConstant('PIMCORE_KERNEL_CLASS', '\App\Kernel');
  211.     }
  213.     private static function autoload()
  214.     {
  215.         $loader = \Pimcore::getAutoloader();
  217.         // tell the autoloader where to find Pimcore's generated class stubs
  218.         // this is primarily necessary for tests and custom class directories, which are not covered in composer.json
  219.         $loader->addPsr4('Pimcore\\Model\\DataObject\\', PIMCORE_CLASS_DIRECTORY . '/DataObject');
  221.         if (defined('PIMCORE_APP_BUNDLE_CLASS_FILE')) {
  222.             require_once PIMCORE_APP_BUNDLE_CLASS_FILE;
  223.         }
  224.     }
  226.     /**
  227.      * @return KernelInterface
  228.      */
  229.     public static function kernel()
  230.     {
  231.         $environment = Config::getEnvironment();
  233.         $debug = (bool) ($_SERVER['APP_DEBUG'] ?? false);
  234.         if ($debug) {
  235.             umask(0000);
  236.             Debug::enable();
  237.             @ini_set('display_errors', 'On');
  238.         }
  240.         if (defined('PIMCORE_KERNEL_CLASS')) {
  241.             $kernelClass = PIMCORE_KERNEL_CLASS;
  242.         } else {
  243.             $kernelClass = '\App\Kernel';
  244.         }
  246.         if (!class_exists($kernelClass)) {
  247.             throw new \InvalidArgumentException(sprintf('Defined Kernel Class %s not found', $kernelClass));
  248.         }
  250.         if (!is_subclass_of($kernelClass, Kernel::class)) {
  251.             throw new \InvalidArgumentException(sprintf('Defined Kernel Class %s needs to extend the \Pimcore\Kernel Class', $kernelClass));
  252.         }
  254.         $kernel = new $kernelClass($environment, $debug);
  255.         \Pimcore::setKernel($kernel);
  256.         $kernel->boot();
  258.         $conf = \Pimcore::getContainer()->getParameter('pimcore.config');
  260.         if (isset($conf['general']['timezone']) && !empty($conf['general']['timezone'])) {
  261.             date_default_timezone_set($conf['general']['timezone']);
  262.         }
  264.         return $kernel;
  265.     }
  266. }