You are here

Home » API reference » Zircon Profile 8.0 » Kernel.php

abstract class Kernel in Zircon Profile 8.0

Same name and namespace in other branches
  1. 8 vendor/symfony/http-kernel/Kernel.php \Symfony\Component\HttpKernel\Kernel

The Kernel is the heart of the Symfony system.

It manages an environment made of bundles.

@author Fabien Potencier <fabien@symfony.com>

Hierarchy

Expanded class hierarchy of Kernel

7 files declare their use of Kernel
AddClassesToCachePass.php in vendor/symfony/http-kernel/DependencyInjection/AddClassesToCachePass.php
ConfigDataCollector.php in vendor/symfony/http-kernel/DataCollector/ConfigDataCollector.php
ConfigDataCollectorTest.php in vendor/symfony/http-kernel/Tests/DataCollector/ConfigDataCollectorTest.php
KernelForOverrideName.php in vendor/symfony/http-kernel/Tests/Fixtures/KernelForOverrideName.php
KernelForTest.php in vendor/symfony/http-kernel/Tests/Fixtures/KernelForTest.php

... See full list

File

vendor/symfony/http-kernel/Kernel.php, line 44

Namespace

Symfony\Component\HttpKernel
View source 
abstract class Kernel implements KernelInterface, TerminableInterface {

  /**
   * @var BundleInterface[]
   */
  protected $bundles = array();
  protected $bundleMap;
  protected $container;
  protected $rootDir;
  protected $environment;
  protected $debug;
  protected $booted = false;
  protected $name;
  protected $startTime;
  protected $loadClassCache;
  const VERSION = '2.7.6';
  const VERSION_ID = 20706;
  const MAJOR_VERSION = 2;
  const MINOR_VERSION = 7;
  const RELEASE_VERSION = 6;
  const EXTRA_VERSION = '';
  const END_OF_MAINTENANCE = '05/2018';
  const END_OF_LIFE = '05/2019';

  /**
   * Constructor.
   *
   * @param string $environment The environment
   * @param bool   $debug       Whether to enable debugging or not
   */
  public function __construct($environment, $debug) {
    $this->environment = $environment;
    $this->debug = (bool) $debug;
    $this->rootDir = $this
      ->getRootDir();
    $this->name = $this
      ->getName();
    if ($this->debug) {
      $this->startTime = microtime(true);
    }
    $defClass = new \ReflectionMethod($this, 'init');
    $defClass = $defClass
      ->getDeclaringClass()->name;
    if (__CLASS__ !== $defClass) {
      @trigger_error(sprintf('Calling the %s::init() method is deprecated since version 2.3 and will be removed in 3.0. Move your logic to the constructor method instead.', $defClass), E_USER_DEPRECATED);
      $this
        ->init();
    }
  }

  /**
   * @deprecated since version 2.3, to be removed in 3.0. Move your logic in the constructor instead.
   */
  public function init() {
    @trigger_error('The ' . __METHOD__ . ' method is deprecated since version 2.3 and will be removed in 3.0. Move your logic to the constructor method instead.', E_USER_DEPRECATED);
  }
  public function __clone() {
    if ($this->debug) {
      $this->startTime = microtime(true);
    }
    $this->booted = false;
    $this->container = null;
  }

  /**
   * Boots the current kernel.
   */
  public function boot() {
    if (true === $this->booted) {
      return;
    }
    if ($this->loadClassCache) {
      $this
        ->doLoadClassCache($this->loadClassCache[0], $this->loadClassCache[1]);
    }

    // init bundles
    $this
      ->initializeBundles();

    // init container
    $this
      ->initializeContainer();
    foreach ($this
      ->getBundles() as $bundle) {
      $bundle
        ->setContainer($this->container);
      $bundle
        ->boot();
    }
    $this->booted = true;
  }

  /**
   * {@inheritdoc}
   */
  public function terminate(Request $request, Response $response) {
    if (false === $this->booted) {
      return;
    }
    if ($this
      ->getHttpKernel() instanceof TerminableInterface) {
      $this
        ->getHttpKernel()
        ->terminate($request, $response);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function shutdown() {
    if (false === $this->booted) {
      return;
    }
    $this->booted = false;
    foreach ($this
      ->getBundles() as $bundle) {
      $bundle
        ->shutdown();
      $bundle
        ->setContainer(null);
    }
    $this->container = null;
  }

  /**
   * {@inheritdoc}
   */
  public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true) {
    if (false === $this->booted) {
      $this
        ->boot();
    }
    return $this
      ->getHttpKernel()
      ->handle($request, $type, $catch);
  }

  /**
   * Gets a HTTP kernel from the container.
   *
   * @return HttpKernel
   */
  protected function getHttpKernel() {
    return $this->container
      ->get('http_kernel');
  }

  /**
   * {@inheritdoc}
   */
  public function getBundles() {
    return $this->bundles;
  }

  /**
   * {@inheritdoc}
   *
   * @deprecated since version 2.6, to be removed in 3.0.
   */
  public function isClassInActiveBundle($class) {
    @trigger_error('The ' . __METHOD__ . ' method is deprecated since version 2.6 and will be removed in version 3.0.', E_USER_DEPRECATED);
    foreach ($this
      ->getBundles() as $bundle) {
      if (0 === strpos($class, $bundle
        ->getNamespace())) {
        return true;
      }
    }
    return false;
  }

  /**
   * {@inheritdoc}
   */
  public function getBundle($name, $first = true) {
    if (!isset($this->bundleMap[$name])) {
      throw new \InvalidArgumentException(sprintf('Bundle "%s" does not exist or it is not enabled. Maybe you forgot to add it in the registerBundles() method of your %s.php file?', $name, get_class($this)));
    }
    if (true === $first) {
      return $this->bundleMap[$name][0];
    }
    return $this->bundleMap[$name];
  }

  /**
   * {@inheritdoc}
   *
   * @throws \RuntimeException if a custom resource is hidden by a resource in a derived bundle
   */
  public function locateResource($name, $dir = null, $first = true) {
    if ('@' !== $name[0]) {
      throw new \InvalidArgumentException(sprintf('A resource name must start with @ ("%s" given).', $name));
    }
    if (false !== strpos($name, '..')) {
      throw new \RuntimeException(sprintf('File name "%s" contains invalid characters (..).', $name));
    }
    $bundleName = substr($name, 1);
    $path = '';
    if (false !== strpos($bundleName, '/')) {
      list($bundleName, $path) = explode('/', $bundleName, 2);
    }
    $isResource = 0 === strpos($path, 'Resources') && null !== $dir;
    $overridePath = substr($path, 9);
    $resourceBundle = null;
    $bundles = $this
      ->getBundle($bundleName, false);
    $files = array();
    foreach ($bundles as $bundle) {
      if ($isResource && file_exists($file = $dir . '/' . $bundle
        ->getName() . $overridePath)) {
        if (null !== $resourceBundle) {
          throw new \RuntimeException(sprintf('"%s" resource is hidden by a resource from the "%s" derived bundle. Create a "%s" file to override the bundle resource.', $file, $resourceBundle, $dir . '/' . $bundles[0]
            ->getName() . $overridePath));
        }
        if ($first) {
          return $file;
        }
        $files[] = $file;
      }
      if (file_exists($file = $bundle
        ->getPath() . '/' . $path)) {
        if ($first && !$isResource) {
          return $file;
        }
        $files[] = $file;
        $resourceBundle = $bundle
          ->getName();
      }
    }
    if (count($files) > 0) {
      return $first && $isResource ? $files[0] : $files;
    }
    throw new \InvalidArgumentException(sprintf('Unable to find file "%s".', $name));
  }

  /**
   * {@inheritdoc}
   */
  public function getName() {
    if (null === $this->name) {
      $this->name = preg_replace('/[^a-zA-Z0-9_]+/', '', basename($this->rootDir));
    }
    return $this->name;
  }

  /**
   * {@inheritdoc}
   */
  public function getEnvironment() {
    return $this->environment;
  }

  /**
   * {@inheritdoc}
   */
  public function isDebug() {
    return $this->debug;
  }

  /**
   * {@inheritdoc}
   */
  public function getRootDir() {
    if (null === $this->rootDir) {
      $r = new \ReflectionObject($this);
      $this->rootDir = dirname($r
        ->getFileName());
    }
    return $this->rootDir;
  }

  /**
   * {@inheritdoc}
   */
  public function getContainer() {
    return $this->container;
  }

  /**
   * Loads the PHP class cache.
   *
   * This methods only registers the fact that you want to load the cache classes.
   * The cache will actually only be loaded when the Kernel is booted.
   *
   * That optimization is mainly useful when using the HttpCache class in which
   * case the class cache is not loaded if the Response is in the cache.
   *
   * @param string $name      The cache name prefix
   * @param string $extension File extension of the resulting file
   */
  public function loadClassCache($name = 'classes', $extension = '.php') {
    $this->loadClassCache = array(
      $name,
      $extension,
    );
  }

  /**
   * Used internally.
   */
  public function setClassCache(array $classes) {
    file_put_contents($this
      ->getCacheDir() . '/classes.map', sprintf('<?php return %s;', var_export($classes, true)));
  }

  /**
   * {@inheritdoc}
   */
  public function getStartTime() {
    return $this->debug ? $this->startTime : -INF;
  }

  /**
   * {@inheritdoc}
   */
  public function getCacheDir() {
    return $this->rootDir . '/cache/' . $this->environment;
  }

  /**
   * {@inheritdoc}
   */
  public function getLogDir() {
    return $this->rootDir . '/logs';
  }

  /**
   * {@inheritdoc}
   */
  public function getCharset() {
    return 'UTF-8';
  }
  protected function doLoadClassCache($name, $extension) {
    if (!$this->booted && is_file($this
      ->getCacheDir() . '/classes.map')) {
      ClassCollectionLoader::load(include $this
        ->getCacheDir() . '/classes.map', $this
        ->getCacheDir(), $name, $this->debug, false, $extension);
    }
  }

  /**
   * Initializes the data structures related to the bundle management.
   *
   *  - the bundles property maps a bundle name to the bundle instance,
   *  - the bundleMap property maps a bundle name to the bundle inheritance hierarchy (most derived bundle first).
   *
   * @throws \LogicException if two bundles share a common name
   * @throws \LogicException if a bundle tries to extend a non-registered bundle
   * @throws \LogicException if a bundle tries to extend itself
   * @throws \LogicException if two bundles extend the same ancestor
   */
  protected function initializeBundles() {

    // init bundles
    $this->bundles = array();
    $topMostBundles = array();
    $directChildren = array();
    foreach ($this
      ->registerBundles() as $bundle) {
      $name = $bundle
        ->getName();
      if (isset($this->bundles[$name])) {
        throw new \LogicException(sprintf('Trying to register two bundles with the same name "%s"', $name));
      }
      $this->bundles[$name] = $bundle;
      if ($parentName = $bundle
        ->getParent()) {
        if (isset($directChildren[$parentName])) {
          throw new \LogicException(sprintf('Bundle "%s" is directly extended by two bundles "%s" and "%s".', $parentName, $name, $directChildren[$parentName]));
        }
        if ($parentName == $name) {
          throw new \LogicException(sprintf('Bundle "%s" can not extend itself.', $name));
        }
        $directChildren[$parentName] = $name;
      }
      else {
        $topMostBundles[$name] = $bundle;
      }
    }

    // look for orphans
    if (!empty($directChildren) && count($diff = array_diff_key($directChildren, $this->bundles))) {
      $diff = array_keys($diff);
      throw new \LogicException(sprintf('Bundle "%s" extends bundle "%s", which is not registered.', $directChildren[$diff[0]], $diff[0]));
    }

    // inheritance
    $this->bundleMap = array();
    foreach ($topMostBundles as $name => $bundle) {
      $bundleMap = array(
        $bundle,
      );
      $hierarchy = array(
        $name,
      );
      while (isset($directChildren[$name])) {
        $name = $directChildren[$name];
        array_unshift($bundleMap, $this->bundles[$name]);
        $hierarchy[] = $name;
      }
      foreach ($hierarchy as $bundle) {
        $this->bundleMap[$bundle] = $bundleMap;
        array_pop($bundleMap);
      }
    }
  }

  /**
   * Gets the container class.
   *
   * @return string The container class
   */
  protected function getContainerClass() {
    return $this->name . ucfirst($this->environment) . ($this->debug ? 'Debug' : '') . 'ProjectContainer';
  }

  /**
   * Gets the container's base class.
   *
   * All names except Container must be fully qualified.
   *
   * @return string
   */
  protected function getContainerBaseClass() {
    return 'Container';
  }

  /**
   * Initializes the service container.
   *
   * The cached version of the service container is used when fresh, otherwise the
   * container is built.
   */
  protected function initializeContainer() {
    $class = $this
      ->getContainerClass();
    $cache = new ConfigCache($this
      ->getCacheDir() . '/' . $class . '.php', $this->debug);
    $fresh = true;
    if (!$cache
      ->isFresh()) {
      $container = $this
        ->buildContainer();
      $container
        ->compile();
      $this
        ->dumpContainer($cache, $container, $class, $this
        ->getContainerBaseClass());
      $fresh = false;
    }
    require_once $cache
      ->getPath();
    $this->container = new $class();
    $this->container
      ->set('kernel', $this);
    if (!$fresh && $this->container
      ->has('cache_warmer')) {
      $this->container
        ->get('cache_warmer')
        ->warmUp($this->container
        ->getParameter('kernel.cache_dir'));
    }
  }

  /**
   * Returns the kernel parameters.
   *
   * @return array An array of kernel parameters
   */
  protected function getKernelParameters() {
    $bundles = array();
    foreach ($this->bundles as $name => $bundle) {
      $bundles[$name] = get_class($bundle);
    }
    return array_merge(array(
      'kernel.root_dir' => realpath($this->rootDir) ?: $this->rootDir,
      'kernel.environment' => $this->environment,
      'kernel.debug' => $this->debug,
      'kernel.name' => $this->name,
      'kernel.cache_dir' => realpath($this
        ->getCacheDir()) ?: $this
        ->getCacheDir(),
      'kernel.logs_dir' => realpath($this
        ->getLogDir()) ?: $this
        ->getLogDir(),
      'kernel.bundles' => $bundles,
      'kernel.charset' => $this
        ->getCharset(),
      'kernel.container_class' => $this
        ->getContainerClass(),
    ), $this
      ->getEnvParameters());
  }

  /**
   * Gets the environment parameters.
   *
   * Only the parameters starting with "SYMFONY__" are considered.
   *
   * @return array An array of parameters
   */
  protected function getEnvParameters() {
    $parameters = array();
    foreach ($_SERVER as $key => $value) {
      if (0 === strpos($key, 'SYMFONY__')) {
        $parameters[strtolower(str_replace('__', '.', substr($key, 9)))] = $value;
      }
    }
    return $parameters;
  }

  /**
   * Builds the service container.
   *
   * @return ContainerBuilder The compiled service container
   *
   * @throws \RuntimeException
   */
  protected function buildContainer() {
    foreach (array(
      'cache' => $this
        ->getCacheDir(),
      'logs' => $this
        ->getLogDir(),
    ) as $name => $dir) {
      if (!is_dir($dir)) {
        if (false === @mkdir($dir, 0777, true) && !is_dir($dir)) {
          throw new \RuntimeException(sprintf("Unable to create the %s directory (%s)\n", $name, $dir));
        }
      }
      elseif (!is_writable($dir)) {
        throw new \RuntimeException(sprintf("Unable to write in the %s directory (%s)\n", $name, $dir));
      }
    }
    $container = $this
      ->getContainerBuilder();
    $container
      ->addObjectResource($this);
    $this
      ->prepareContainer($container);
    if (null !== ($cont = $this
      ->registerContainerConfiguration($this
      ->getContainerLoader($container)))) {
      $container
        ->merge($cont);
    }
    $container
      ->addCompilerPass(new AddClassesToCachePass($this));
    $container
      ->addResource(new EnvParametersResource('SYMFONY__'));
    return $container;
  }

  /**
   * Prepares the ContainerBuilder before it is compiled.
   *
   * @param ContainerBuilder $container A ContainerBuilder instance
   */
  protected function prepareContainer(ContainerBuilder $container) {
    $extensions = array();
    foreach ($this->bundles as $bundle) {
      if ($extension = $bundle
        ->getContainerExtension()) {
        $container
          ->registerExtension($extension);
        $extensions[] = $extension
          ->getAlias();
      }
      if ($this->debug) {
        $container
          ->addObjectResource($bundle);
      }
    }
    foreach ($this->bundles as $bundle) {
      $bundle
        ->build($container);
    }

    // ensure these extensions are implicitly loaded
    $container
      ->getCompilerPassConfig()
      ->setMergePass(new MergeExtensionConfigurationPass($extensions));
  }

  /**
   * Gets a new ContainerBuilder instance used to build the service container.
   *
   * @return ContainerBuilder
   */
  protected function getContainerBuilder() {
    $container = new ContainerBuilder(new ParameterBag($this
      ->getKernelParameters()));
    if (class_exists('ProxyManager\\Configuration') && class_exists('Symfony\\Bridge\\ProxyManager\\LazyProxy\\Instantiator\\RuntimeInstantiator')) {
      $container
        ->setProxyInstantiator(new RuntimeInstantiator());
    }
    return $container;
  }

  /**
   * Dumps the service container to PHP code in the cache.
   *
   * @param ConfigCache      $cache     The config cache
   * @param ContainerBuilder $container The service container
   * @param string           $class     The name of the class to generate
   * @param string           $baseClass The name of the container's base class
   */
  protected function dumpContainer(ConfigCache $cache, ContainerBuilder $container, $class, $baseClass) {

    // cache the container
    $dumper = new PhpDumper($container);
    if (class_exists('ProxyManager\\Configuration') && class_exists('Symfony\\Bridge\\ProxyManager\\LazyProxy\\PhpDumper\\ProxyDumper')) {
      $dumper
        ->setProxyDumper(new ProxyDumper(md5($cache
        ->getPath())));
    }
    $content = $dumper
      ->dump(array(
      'class' => $class,
      'base_class' => $baseClass,
      'file' => $cache
        ->getPath(),
    ));
    if (!$this->debug) {
      $content = static::stripComments($content);
    }
    $cache
      ->write($content, $container
      ->getResources());
  }

  /**
   * Returns a loader for the container.
   *
   * @param ContainerInterface $container The service container
   *
   * @return DelegatingLoader The loader
   */
  protected function getContainerLoader(ContainerInterface $container) {
    $locator = new FileLocator($this);
    $resolver = new LoaderResolver(array(
      new XmlFileLoader($container, $locator),
      new YamlFileLoader($container, $locator),
      new IniFileLoader($container, $locator),
      new PhpFileLoader($container, $locator),
      new ClosureLoader($container),
    ));
    return new DelegatingLoader($resolver);
  }

  /**
   * Removes comments from a PHP source string.
   *
   * We don't use the PHP php_strip_whitespace() function
   * as we want the content to be readable and well-formatted.
   *
   * @param string $source A PHP string
   *
   * @return string The PHP string with the comments removed
   */
  public static function stripComments($source) {
    if (!function_exists('token_get_all')) {
      return $source;
    }
    $rawChunk = '';
    $output = '';
    $tokens = token_get_all($source);
    $ignoreSpace = false;
    for (reset($tokens); false !== ($token = current($tokens)); next($tokens)) {
      if (is_string($token)) {
        $rawChunk .= $token;
      }
      elseif (T_START_HEREDOC === $token[0]) {
        $output .= $rawChunk . $token[1];
        do {
          $token = next($tokens);
          $output .= $token[1];
        } while ($token[0] !== T_END_HEREDOC);
        $rawChunk = '';
      }
      elseif (T_WHITESPACE === $token[0]) {
        if ($ignoreSpace) {
          $ignoreSpace = false;
          continue;
        }

        // replace multiple new lines with a single newline
        $rawChunk .= preg_replace(array(
          '/\\n{2,}/S',
        ), "\n", $token[1]);
      }
      elseif (in_array($token[0], array(
        T_COMMENT,
        T_DOC_COMMENT,
      ))) {
        $ignoreSpace = true;
      }
      else {
        $rawChunk .= $token[1];

        // The PHP-open tag already has a new-line
        if (T_OPEN_TAG === $token[0]) {
          $ignoreSpace = true;
        }
      }
    }
    $output .= $rawChunk;
    return $output;
  }
  public function serialize() {
    return serialize(array(
      $this->environment,
      $this->debug,
    ));
  }
  public function unserialize($data) {
    list($environment, $debug) = unserialize($data);
    $this
      ->__construct($environment, $debug);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
HttpKernelInterface::MASTER_REQUEST constant
HttpKernelInterface::SUB_REQUEST constant
Kernel::$booted protected property
Kernel::$bundleMap protected property
Kernel::$bundles protected property
Kernel::$container protected property
Kernel::$debug protected property
Kernel::$environment protected property
Kernel::$loadClassCache protected property
Kernel::$name protected property 1
Kernel::$rootDir protected property
Kernel::$startTime protected property
Kernel::boot public function Boots the current kernel. Overrides KernelInterface::boot
Kernel::buildContainer protected function Builds the service container.
Kernel::doLoadClassCache protected function
Kernel::dumpContainer protected function Dumps the service container to PHP code in the cache.
Kernel::END_OF_LIFE constant
Kernel::END_OF_MAINTENANCE constant
Kernel::EXTRA_VERSION constant
Kernel::getBundle public function Returns a bundle and optionally its descendants by its name. Overrides KernelInterface::getBundle
Kernel::getBundles public function Gets the registered bundle instances. Overrides KernelInterface::getBundles 1
Kernel::getCacheDir public function Gets the cache directory. Overrides KernelInterface::getCacheDir
Kernel::getCharset public function Gets the charset of the application. Overrides KernelInterface::getCharset
Kernel::getContainer public function Gets the current container. Overrides KernelInterface::getContainer
Kernel::getContainerBaseClass protected function Gets the container's base class.
Kernel::getContainerBuilder protected function Gets a new ContainerBuilder instance used to build the service container.
Kernel::getContainerClass protected function Gets the container class.
Kernel::getContainerLoader protected function Returns a loader for the container.
Kernel::getEnvironment public function Gets the environment. Overrides KernelInterface::getEnvironment
Kernel::getEnvParameters protected function Gets the environment parameters.
Kernel::getHttpKernel protected function Gets a HTTP kernel from the container.
Kernel::getKernelParameters protected function Returns the kernel parameters.
Kernel::getLogDir public function Gets the log directory. Overrides KernelInterface::getLogDir
Kernel::getName public function Gets the name of the kernel. Overrides KernelInterface::getName 1
Kernel::getRootDir public function Gets the application root dir. Overrides KernelInterface::getRootDir
Kernel::getStartTime public function Gets the request start time (not available if debug is disabled). Overrides KernelInterface::getStartTime
Kernel::handle public function Handles a Request to convert it to a Response. Overrides HttpKernelInterface::handle
Kernel::init Deprecated public function
Kernel::initializeBundles protected function Initializes the data structures related to the bundle management.
Kernel::initializeContainer protected function Initializes the service container.
Kernel::isClassInActiveBundle Deprecated public function Overrides KernelInterface::isClassInActiveBundle
Kernel::isDebug public function Checks if debug mode is enabled. Overrides KernelInterface::isDebug
Kernel::loadClassCache public function Loads the PHP class cache.
Kernel::locateResource public function Overrides KernelInterface::locateResource
Kernel::MAJOR_VERSION constant
Kernel::MINOR_VERSION constant
Kernel::prepareContainer protected function Prepares the ContainerBuilder before it is compiled.
Kernel::RELEASE_VERSION constant
Kernel::serialize public function
Kernel::setClassCache public function Used internally.
Kernel::shutdown public function Shutdowns the kernel. Overrides KernelInterface::shutdown
Kernel::stripComments public static function Removes comments from a PHP source string.
Kernel::terminate public function Terminates a request/response cycle. Overrides TerminableInterface::terminate
Kernel::unserialize public function
Kernel::VERSION constant
Kernel::VERSION_ID constant
Kernel::__clone public function
Kernel::__construct public function Constructor.
KernelInterface::registerBundles public function Returns an array of bundles to register. 3
KernelInterface::registerContainerConfiguration public function Loads the container configuration. 3