DrupalKernel.php 22.2 KB
Newer Older
1 2 3 4 5 6 7 8 9
<?php

/**
 * @file
 * Definition of Drupal\Core\DrupalKernel.
 */

namespace Drupal\Core;

10 11
use Drupal\Component\PhpStorage\PhpStorageFactory;
use Drupal\Core\Config\BootstrapConfigStorageFactory;
12
use Drupal\Core\CoreServiceProvider;
13
use Drupal\Core\DependencyInjection\ContainerBuilder;
14
use Drupal\Core\DependencyInjection\ServiceProviderInterface;
15
use Drupal\Core\DependencyInjection\YamlFileLoader;
16
use Drupal\Core\Extension\ExtensionDiscovery;
17
use Drupal\Core\Language\Language;
18 19
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
20
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
21 22 23 24
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Symfony\Component\HttpKernel\TerminableInterface;
25
use Composer\Autoload\ClassLoader;
26 27 28

/**
 * The DrupalKernel class is the core of Drupal itself.
29 30
 *
 * This class is responsible for building the Dependency Injection Container and
31 32 33 34 35 36 37 38
 * also deals with the registration of service providers. It allows registered
 * service providers to add their services to the container. Core provides the
 * CoreServiceProvider, which, in addition to registering any core services that
 * cannot be registered in the core.services.yaml file, adds any compiler passes
 * needed by core, e.g. for processing tagged services. Each module can add its
 * own service provider, i.e. a class implementing
 * Drupal\Core\DependencyInjection\ServiceProvider, to register services to the
 * container, or modify existing services.
39
 */
40 41
class DrupalKernel implements DrupalKernelInterface, TerminableInterface {

42
  const CONTAINER_BASE_CLASS = '\Drupal\Core\DependencyInjection\Container';
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

  /**
   * Holds the container instance.
   *
   * @var \Symfony\Component\DependencyInjection\ContainerInterface
   */
  protected $container;

  /**
   * The environment, e.g. 'testing', 'install'.
   *
   * @var string
   */
  protected $environment;

  /**
   * Whether the kernel has been booted.
   *
   * @var bool
   */
  protected $booted;
64

65 66 67 68
  /**
   * Holds the list of enabled modules.
   *
   * @var array
69 70
   *   An associative array whose keys are module names and whose values are
   *   ignored.
71 72 73 74
   */
  protected $moduleList;

  /**
75
   * Holds an updated list of enabled modules.
76
   *
77 78 79 80 81 82 83 84 85 86
   * @var array
   *   An associative array whose keys are module names and whose values are
   *   ignored.
   */
  protected $newModuleList;

  /**
   * An array of module data objects.
   *
   * The data objects have the same data structure as returned by
87
   * ExtensionDiscovery but only the uri property is used.
88 89
   *
   * @var array
90
   */
91
  protected $moduleData = array();
92 93 94 95 96 97 98 99

  /**
   * PHP code storage object to use for the compiled container.
   *
   * @var \Drupal\Component\PhpStorage\PhpStorageInterface
   */
  protected $storage;

100 101 102
  /**
   * The classloader object.
   *
103
   * @var \Composer\Autoload\ClassLoader
104 105 106
   */
  protected $classLoader;

107 108 109 110 111 112 113
  /**
   * Config storage object used for reading enabled modules configuration.
   *
   * @var \Drupal\Core\Config\StorageInterface
   */
  protected $configStorage;

114
  /**
115
   * The list of the classnames of the service providers in this kernel.
116 117 118
   *
   * @var array
   */
119
  protected $serviceProviderClasses;
120

121 122 123 124 125 126 127 128 129 130 131 132 133 134
  /**
   * Whether the container can be dumped.
   *
   * @var bool
   */
  protected $allowDumping;

  /**
   * Whether the container needs to be dumped once booting is complete.
   *
   * @var bool
   */
  protected $containerNeedsDumping;

135 136 137 138 139 140 141
  /**
   * Holds the list of YAML files containing service definitions.
   *
   * @var array
   */
  protected $serviceYamls;

142 143 144 145 146 147 148
  /**
   * The array of registered service providers.
   *
   * @var array
   */
  protected $serviceProviders;

149 150 151 152 153 154 155
  /**
   * Constructs a DrupalKernel object.
   *
   * @param string $environment
   *   String indicating the environment, e.g. 'prod' or 'dev'. Used by
   *   Symfony\Component\HttpKernel\Kernel::__construct(). Drupal does not use
   *   this value currently. Pass 'prod'.
156
   * @param \Composer\Autoload\ClassLoader $class_loader
157 158 159
   *   (optional) The classloader is only used if $storage is not given or
   *   the load from storage fails and a container rebuild is required. In
   *   this case, the loaded modules will be registered with this loader in
160
   *   order to be able to find the module serviceProviders.
161 162 163
   * @param bool $allow_dumping
   *   (optional) FALSE to stop the container from being written to or read
   *   from disk. Defaults to TRUE.
164
   */
165 166
  public function __construct($environment, ClassLoader $class_loader, $allow_dumping = TRUE) {
    $this->environment = $environment;
167
    $this->booted = FALSE;
168
    $this->classLoader = $class_loader;
169
    $this->allowDumping = $allow_dumping;
170 171
  }

172
  /**
173
   * {@inheritdoc}
174 175 176 177 178 179 180
   */
  public function boot() {
    if ($this->booted) {
      return;
    }
    $this->initializeContainer();
    $this->booted = TRUE;
181
    if ($this->containerNeedsDumping && !$this->dumpDrupalContainer($this->container, static::CONTAINER_BASE_CLASS)) {
182 183
      watchdog('DrupalKernel', 'Container cannot be written to disk');
    }
184 185
  }

186
  /**
187
   * {@inheritdoc}
188
   */
189 190 191 192 193
  public function shutdown() {
    if (FALSE === $this->booted) {
      return;
    }
    $this->booted = FALSE;
194
    $this->container = NULL;
195 196 197 198 199 200 201 202 203 204 205 206 207
  }

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

  /**
   * {@inheritdoc}
   */
  public function discoverServiceProviders() {
208
    $this->configStorage = BootstrapConfigStorageFactory::get();
209 210
    $serviceProviders = array(
      'CoreServiceProvider' => new CoreServiceProvider(),
211
    );
212 213 214
    $this->serviceYamls = array(
      'core/core.services.yml'
    );
215
    $this->serviceProviderClasses = array('Drupal\Core\CoreServiceProvider');
216 217 218

    // Ensure we know what modules are enabled and that their namespaces are
    // registered.
219
    if (!isset($this->moduleList)) {
220
      $module_list = $this->configStorage->read('system.module');
221 222
      $this->moduleList = isset($module_list['enabled']) ? $module_list['enabled'] : array();
    }
223 224
    $module_filenames = $this->getModuleFileNames();
    $this->registerNamespaces($this->getModuleNamespaces($module_filenames));
225

226
    // Load each module's serviceProvider class.
227
    foreach ($this->moduleList as $module => $weight) {
katbailey's avatar
katbailey committed
228
      $camelized = ContainerBuilder::camelize($module);
229 230
      $name = "{$camelized}ServiceProvider";
      $class = "Drupal\\{$module}\\{$name}";
231
      if (class_exists($class)) {
232 233
        $serviceProviders[$name] = new $class();
        $this->serviceProviderClasses[] = $class;
234
      }
235 236 237 238
      $filename = dirname($module_filenames[$module]) . "/$module.services.yml";
      if (file_exists($filename)) {
        $this->serviceYamls[] = $filename;
      }
239
    }
240

241 242 243 244 245
    // Add site specific or test service providers.
    if (!empty($GLOBALS['conf']['container_service_providers'])) {
      foreach ($GLOBALS['conf']['container_service_providers'] as $name => $class) {
        $serviceProviders[$name] = new $class();
        $this->serviceProviderClasses[] = $class;
246 247
      }
    }
248 249 250 251
    // Add site specific or test YAMLs.
    if (!empty($GLOBALS['conf']['container_yamls'])) {
      $this->serviceYamls = array_merge($this->serviceYamls, $GLOBALS['conf']['container_yamls']);
    }
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
    return $serviceProviders;
  }


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

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

    if ($this->getHttpKernel() instanceof TerminableInterface) {
      $this->getHttpKernel()->terminate($request, $response);
    }
  }

  /**
   * {@inheritdoc}
   */
279
  public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = TRUE) {
280 281 282 283 284
    if (FALSE === $this->booted) {
      $this->boot();
    }

    return $this->getHttpKernel()->handle($request, $type, $catch);
285
  }
286

287 288 289 290 291 292
  /**
   * Returns module data on the filesystem.
   *
   * @param $module
   *   The name of the module.
   *
293 294 295 296
   * @return \stdClass|bool
   *   Returns a stdClass object if the module data is found containing at
   *   least an uri property with the module path, for example
   *   core/modules/user/user.module.
297 298 299
   */
  protected function moduleData($module) {
    if (!$this->moduleData) {
300
      // First, find profiles.
301 302 303 304 305
      $listing = new ExtensionDiscovery();
      $listing->setProfileDirectories(array());
      $all_profiles = $listing->scan('profile');
      $profiles = array_intersect_key($all_profiles, $this->moduleList);

306 307
      // If a module is within a profile directory but specifies another
      // profile for testing, it needs to be found in the parent profile.
308 309 310
      $settings = $this->configStorage->read('simpletest.settings');
      $parent_profile = !empty($settings['parent_profile']) ? $settings['parent_profile'] : NULL;
      if ($parent_profile && !isset($profiles[$parent_profile])) {
311 312
        // In case both profile directories contain the same extension, the
        // actual profile always has precedence.
313
        $profiles = array($parent_profile => $all_profiles[$parent_profile]) + $profiles;
314
      }
315 316 317 318 319 320

      $profile_directories = array_map(function ($profile) {
        return $profile->getPath();
      }, $profiles);
      $listing->setProfileDirectories($profile_directories);

321
      // Now find modules.
322
      $this->moduleData = $profiles + $listing->scan('module');
323 324 325 326
    }
    return isset($this->moduleData[$module]) ? $this->moduleData[$module] : FALSE;
  }

327 328
  /**
   * Implements Drupal\Core\DrupalKernelInterface::updateModules().
329 330 331
   *
   * @todo Remove obsolete $module_list parameter. Only $module_filenames is
   *   needed.
332
   */
333
  public function updateModules(array $module_list, array $module_filenames = array()) {
334
    $this->newModuleList = $module_list;
335 336
    foreach ($module_filenames as $module => $filename) {
      $this->moduleData[$module] = (object) array('uri' => $filename);
337
    }
338 339
    // If we haven't yet booted, we don't need to do anything: the new module
    // list will take effect when boot() is called. If we have already booted,
340
    // then reboot in order to refresh the serviceProvider list and container.
341 342 343 344 345
    if ($this->booted) {
      $this->booted = FALSE;
      $this->boot();
    }
  }
346

347
  /**
348
   * Returns the classname based on environment.
349 350 351 352 353
   *
   * @return string
   *   The class name.
   */
  protected function getClassName() {
354
    $parts = array('service_container', $this->environment);
355 356 357
    return implode('_', $parts);
  }

358 359 360 361 362 363 364 365 366 367 368 369

  /**
   * Returns the kernel parameters.
   *
   * @return array An array of kernel parameters
   */
  protected function getKernelParameters() {
    return array(
      'kernel.environment' => $this->environment,
    );
  }

370 371 372
  /**
   * Initializes the service container.
   */
373
  protected function initializeContainer() {
374
    $this->containerNeedsDumping = FALSE;
375
    $persist = $this->getServicesToPersist();
376 377 378 379 380 381 382 383 384 385 386
    // The request service requires custom persisting logic, since it is also
    // potentially scoped. During Drupal installation, there is a request
    // service without a request scope.
    $request_scope = FALSE;
    if (isset($this->container)) {
      if ($this->container->isScopeActive('request')) {
        $request_scope = TRUE;
      }
      if ($this->container->initialized('request')) {
        $request = $this->container->get('request');
      }
387
    }
388
    $this->container = NULL;
389 390 391
    $class = $this->getClassName();
    $cache_file = $class . '.php';

392
    if ($this->allowDumping) {
393 394
      // First, try to load.
      if (!class_exists($class, FALSE)) {
395
        $this->storage()->load($cache_file);
396 397 398 399 400
      }
      // If the load succeeded or the class already existed, use it.
      if (class_exists($class, FALSE)) {
        $fully_qualified_class_name = '\\' . $class;
        $this->container = new $fully_qualified_class_name;
401
        $this->persistServices($persist);
402 403
      }
    }
404 405 406 407 408 409 410 411
    // First check whether the list of modules changed in this request.
    if (isset($this->newModuleList)) {
      if (isset($this->container) && isset($this->moduleList) && array_keys($this->moduleList) !== array_keys($this->newModuleList)) {
        unset($this->container);
      }
      $this->moduleList = $this->newModuleList;
      unset($this->newModuleList);
    }
412 413
    // Second, check if some other request -- for example on another web
    // frontend or during the installer -- changed the list of enabled modules.
414
    if (isset($this->container)) {
415 416
      // All namespaces must be registered before we attempt to use any service
      // from the container.
417
      $container_modules = $this->container->getParameter('container.modules');
418
      $namespaces_before = $this->classLoader->getPrefixes();
419
      $this->registerNamespaces($this->getModuleNamespaces($container_modules));
420 421 422

      // If 'container.modules' is wrong, the container must be rebuilt.
      if (!isset($this->moduleList)) {
423
        $this->moduleList = $this->container->get('config.factory')->get('system.module')->get('enabled');
424
      }
425
      if (array_keys($this->moduleList) !== array_keys($container_modules)) {
426
        $persist = $this->getServicesToPersist();
427
        unset($this->container);
428 429 430 431
        // Revert the class loader to its prior state. However,
        // registerNamespaces() performs a merge rather than replace, so to
        // effectively remove erroneous registrations, we must replace them with
        // empty arrays.
432
        $namespaces_after = $this->classLoader->getPrefixes();
433
        $namespaces_before += array_fill_keys(array_diff(array_keys($namespaces_after), array_keys($namespaces_before)), array());
434
        $this->registerNamespaces($namespaces_before);
435 436 437
      }
    }

438 439
    if (!isset($this->container)) {
      $this->container = $this->buildContainer();
440
      $this->persistServices($persist);
441 442 443 444 445 446 447 448

      // The namespaces are marked as persistent, so objects like the annotated
      // class discovery still has the right object. We may have updated the
      // list of modules, so set it.
      if ($this->container->initialized('container.namespaces')) {
        $this->container->get('container.namespaces')->exchangeArray($this->container->getParameter('container.namespaces'));
      }

449 450
      if ($this->allowDumping) {
        $this->containerNeedsDumping = TRUE;
451 452 453
      }
    }

454
    $this->container->set('kernel', $this);
455

456 457
    // Set the class loader which was registered as a synthetic service.
    $this->container->set('class_loader', $this->classLoader);
458
    // If we have a request set it back to the new container.
459
    if ($request_scope) {
460
      $this->container->enterScope('request');
461 462
    }
    if (isset($request)) {
463 464
      $this->container->set('request', $request);
    }
465
    \Drupal::setContainer($this->container);
466
  }
467

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
  /**
   * Returns service instances to persist from an old container to a new one.
   */
  protected function getServicesToPersist() {
    $persist = array();
    if (isset($this->container)) {
      foreach ($this->container->getParameter('persistIds') as $id) {
        // It's pointless to persist services not yet initialized.
        if ($this->container->initialized($id)) {
          $persist[$id] = $this->container->get($id);
        }
      }
    }
    return $persist;
  }

  /**
   * Moves persistent service instances into a new container.
   */
  protected function persistServices(array $persist) {
    foreach ($persist as $id => $object) {
      // Do not override services already set() on the new container, for
      // example 'service_container'.
      if (!$this->container->initialized($id)) {
        $this->container->set($id, $object);
      }
    }
  }

497 498 499 500 501
  /**
   * Builds the service container.
   *
   * @return ContainerBuilder The compiled service container
   */
502
  protected function buildContainer() {
503
    $this->initializeServiceProviders();
504
    $container = $this->getContainerBuilder();
505 506
    $container->set('kernel', $this);
    $container->setParameter('container.service_providers', $this->serviceProviderClasses);
507
    $container->setParameter('container.modules', $this->getModuleFileNames());
508 509 510

    // Get a list of namespaces and put it onto the container.
    $namespaces = $this->getModuleNamespaces($this->getModuleFileNames());
511 512 513 514 515
    // Add all components in \Drupal\Core and \Drupal\Component that have a
    // Plugin directory.
    foreach (array('Core', 'Component') as $parent_directory) {
      $path = DRUPAL_ROOT . '/core/lib/Drupal/' . $parent_directory;
      foreach (new \DirectoryIterator($path) as $component) {
516
        if (!$component->isDot() && $component->isDir() && is_dir($component->getPathname() . '/Plugin')) {
517
          $namespaces['Drupal\\' . $parent_directory . '\\' . $component->getFilename()] = DRUPAL_ROOT . '/core/lib';
518 519 520
        }
      }
    }
521 522
    $container->setParameter('container.namespaces', $namespaces);

523 524 525 526 527 528 529 530 531 532 533 534
    // Store the default language values on the container. This is so that the
    // default language can be configured using the configuration factory. This
    // avoids the circular dependencies that would created by
    // \Drupal\language\LanguageServiceProvider::alter() and allows the default
    // language to not be English in the installer.
    $system = BootstrapConfigStorageFactory::get()->read('system.site');
    $default_language_values = Language::$defaultValues;
    if ($default_language_values['id'] != $system['langcode']) {
      $default_language_values = array('id' => $system['langcode'], 'default' => TRUE);
    }
    $container->setParameter('language.default_values', $default_language_values);

535
    // Register synthetic services.
536
    $container->register('class_loader')->setSynthetic(TRUE);
537 538
    $container->register('kernel', 'Symfony\Component\HttpKernel\KernelInterface')->setSynthetic(TRUE);
    $container->register('service_container', 'Symfony\Component\DependencyInjection\ContainerInterface')->setSynthetic(TRUE);
539 540 541 542
    $yaml_loader = new YamlFileLoader($container);
    foreach ($this->serviceYamls as $filename) {
      $yaml_loader->load($filename);
    }
543
    foreach ($this->serviceProviders as $provider) {
544 545 546
      if ($provider instanceof ServiceProviderInterface) {
        $provider->register($container);
      }
547
    }
548 549 550 551 552 553 554 555 556 557 558 559 560

    // Identify all services whose instances should be persisted when rebuilding
    // the container during the lifetime of the kernel (e.g., during a kernel
    // reboot). Include synthetic services, because by definition, they cannot
    // be automatically reinstantiated. Also include services tagged to persist.
    $persist_ids = array();
    foreach ($container->getDefinitions() as $id => $definition) {
      if ($definition->isSynthetic() || $definition->getTag('persist')) {
        $persist_ids[] = $id;
      }
    }
    $container->setParameter('persistIds', $persist_ids);

561
    $container->compile();
562 563
    return $container;
  }
564

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
  /**
   * Registers all service providers to the kernel.
   *
   * @throws \LogicException
   */
  protected function initializeServiceProviders() {
    $this->serviceProviders = array();

    foreach ($this->discoverServiceProviders() as $name => $provider) {
      if (isset($this->serviceProviders[$name])) {
        throw new \LogicException(sprintf('Trying to register two service providers with the same name "%s"', $name));
      }
      $this->serviceProviders[$name] = $provider;
    }
  }

581 582 583 584 585
  /**
   * Gets a new ContainerBuilder instance used to build the service container.
   *
   * @return ContainerBuilder
   */
586
  protected function getContainerBuilder() {
587 588 589
    return new ContainerBuilder(new ParameterBag($this->getKernelParameters()));
  }

590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
  /**
   * Dumps the service container to PHP code in the config directory.
   *
   * This method is based on the dumpContainer method in the parent class, but
   * that method is reliant on the Config component which we do not use here.
   *
   * @param ContainerBuilder $container
   *   The service container.
   * @param string $baseClass
   *   The name of the container's base class
   *
   * @return bool
   *   TRUE if the container was successfully dumped to disk.
   */
  protected function dumpDrupalContainer(ContainerBuilder $container, $baseClass) {
605
    if (!$this->storage()->writeable()) {
606 607 608 609
      return FALSE;
    }
    // Cache the container.
    $dumper = new PhpDumper($container);
610 611
    $class = $this->getClassName();
    $content = $dumper->dump(array('class' => $class, 'base_class' => $baseClass));
612
    return $this->storage()->save($class . '.php', $content);
613 614
  }

615 616 617 618 619 620 621 622 623 624

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

katbailey's avatar
katbailey committed
625
  /**
Crell's avatar
Crell committed
626 627
   * Overrides and eliminates this method from the parent class. Do not use.
   *
katbailey's avatar
katbailey committed
628 629 630 631 632 633 634
   * This method is part of the KernelInterface interface, but takes an object
   * implementing LoaderInterface as its only parameter. This is part of the
   * Config compoment from Symfony, which is not provided by Drupal core.
   *
   * Modules wishing to provide an extension to this class which uses this
   * method are responsible for ensuring the Config component exists.
   */
635
  public function registerContainerConfiguration(LoaderInterface $loader) {
636
  }
637

638 639 640 641 642 643 644 645 646 647 648 649
  /**
   * Gets the PHP code storage object to use for the compiled container.
   *
   * @return \Drupal\Component\PhpStorage\PhpStorageInterface
   */
  protected function storage() {
    if (!isset($this->storage)) {
      $this->storage = PhpStorageFactory::get('service_container');
    }
    return $this->storage;
  }

650 651 652 653 654 655 656 657 658 659 660 661 662 663
  /**
   * Returns the file name for each enabled module.
   */
  protected function getModuleFileNames() {
    $filenames = array();
    foreach ($this->moduleList as $module => $weight) {
      if ($data = $this->moduleData($module)) {
        $filenames[$module] = $data->uri;
      }
    }
    return $filenames;
  }

  /**
664
   * Gets the namespaces of each enabled module.
665
   */
666 667
  protected function getModuleNamespaces($moduleFileNames) {
    $namespaces = array();
668
    foreach ($moduleFileNames as $module => $filename) {
669 670 671 672 673 674 675 676 677
      $namespaces["Drupal\\$module"] = DRUPAL_ROOT . '/' . dirname($filename) . '/lib';
    }
    return $namespaces;
  }

  /**
   * Registers a list of namespaces.
   */
  protected function registerNamespaces(array $namespaces = array()) {
678 679 680
    foreach ($namespaces as $prefix => $path) {
      $this->classLoader->add($prefix, $path);
    }
681
  }
682
}