DrupalKernel.php 17.1 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\CoreBundle;
13
use Drupal\Core\DependencyInjection\ContainerBuilder;
14
use Drupal\Core\DependencyInjection\YamlFileLoader;
15
use Symfony\Component\ClassLoader\ClassLoader;
16
17
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
18
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
19
use Symfony\Component\HttpKernel\Kernel;
20
21
22

/**
 * The DrupalKernel class is the core of Drupal itself.
23
24
25
26
27
28
29
 *
 * This class is responsible for building the Dependency Injection Container and
 * also deals with the registration of bundles. It allows registered bundles to
 * add their services to the container. Core provides the CoreBundle, which adds
 * the services required for all core subsystems. Each module can then add its
 * own bundle, i.e. a subclass of Symfony\Component\HttpKernel\Bundle, to
 * register services to the container.
30
 */
31
class DrupalKernel extends Kernel implements DrupalKernelInterface {
32

33
34
35
36
  /**
   * Holds the list of enabled modules.
   *
   * @var array
37
38
   *   An associative array whose keys are module names and whose values are
   *   ignored.
39
40
41
42
   */
  protected $moduleList;

  /**
43
   * Holds an updated list of enabled modules.
44
   *
45
46
47
48
49
50
51
52
53
54
55
56
57
   * @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
   * file_scan_directory() but only the uri property is used.
   *
   * @var array
58
   */
59
  protected $moduleData = array();
60
61
62
63
64
65
66
67

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

68
69
70
  /**
   * The classloader object.
   *
71
   * @var \Symfony\Component\ClassLoader\ClassLoader
72
73
74
   */
  protected $classLoader;

75
76
77
78
79
80
81
  /**
   * Config storage object used for reading enabled modules configuration.
   *
   * @var \Drupal\Core\Config\StorageInterface
   */
  protected $configStorage;

82
83
84
85
86
87
88
  /**
   * The list of the classnames of the bundles in this kernel.
   *
   * @var array
   */
  protected $bundleClasses;

89
90
91
92
93
94
95
96
97
98
99
100
101
102
  /**
   * 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;

103
104
105
106
107
108
109
  /**
   * Holds the list of YAML files containing service definitions.
   *
   * @var array
   */
  protected $serviceYamls;

110
111
112
113
114
115
116
117
118
119
120
  /**
   * 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'.
   * @param bool $debug
   *   Boolean indicating whether we are in debug mode. Used by
   *   Symfony\Component\HttpKernel\Kernel::__construct(). Drupal does not use
   *   this value currently. Pass TRUE.
121
   * @param \Symfony\Component\ClassLoader\ClassLoader $class_loader
122
123
124
125
   *   (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
   *   order to be able to find the module bundles.
126
127
128
   * @param bool $allow_dumping
   *   (optional) FALSE to stop the container from being written to or read
   *   from disk. Defaults to TRUE.
129
   */
130
  public function __construct($environment, $debug, ClassLoader $class_loader, $allow_dumping = TRUE) {
131
    parent::__construct($environment, $debug);
132
    $this->classLoader = $class_loader;
133
    $this->allowDumping = $allow_dumping;
134
135
  }

136
137
138
139
140
141
142
143
144
145
  /**
   * Overrides Kernel::init().
   */
  public function init() {
    // Intentionally empty. The sole purpose is to not execute Kernel::init(),
    // since that overrides/breaks Drupal's current error handling.
    // @todo Investigate whether it is possible to migrate Drupal's error
    //   handling to the one of Kernel without losing functionality.
  }

146
147
148
149
150
151
152
153
154
  /**
   * Overrides Kernel::boot().
   */
  public function boot() {
    if ($this->booted) {
      return;
    }
    $this->initializeContainer();
    $this->booted = TRUE;
155
156
157
    if ($this->containerNeedsDumping && !$this->dumpDrupalContainer($this->container, $this->getContainerBaseClass())) {
      watchdog('DrupalKernel', 'Container cannot be written to disk');
    }
158
159
  }

160
161
  /**
   * Returns an array of available bundles.
162
163
164
   *
   * @return array
   *   The available bundles.
165
   */
166
  public function registerBundles() {
167
    $this->configStorage = BootstrapConfigStorageFactory::get();
168
    $bundles = array(
169
      new CoreBundle(),
170
    );
171
172
173
    $this->serviceYamls = array(
      'core/core.services.yml'
    );
174
    $this->bundleClasses = array('Drupal\Core\CoreBundle');
175
176
177

    // Ensure we know what modules are enabled and that their namespaces are
    // registered.
178
    if (!isset($this->moduleList)) {
179
      $module_list = $this->configStorage->read('system.module');
180
181
      $this->moduleList = isset($module_list['enabled']) ? $module_list['enabled'] : array();
    }
182
183
    $module_filenames = $this->getModuleFileNames();
    $this->registerNamespaces($this->getModuleNamespaces($module_filenames));
184

185
    // Load each module's bundle class.
186
    foreach ($this->moduleList as $module => $weight) {
katbailey's avatar
katbailey committed
187
      $camelized = ContainerBuilder::camelize($module);
188
      $class = "Drupal\\{$module}\\{$camelized}Bundle";
189
190
      if (class_exists($class)) {
        $bundles[] = new $class();
191
        $this->bundleClasses[] = $class;
192
      }
193
194
195
196
      $filename = dirname($module_filenames[$module]) . "/$module.services.yml";
      if (file_exists($filename)) {
        $this->serviceYamls[] = $filename;
      }
197
    }
198

199
200
201
202
203
204
205
    // Add site specific or test bundles.
    if (!empty($GLOBALS['conf']['container_bundles'])) {
      foreach ($GLOBALS['conf']['container_bundles'] as $class) {
        $bundles[] = new $class();
        $this->bundleClasses[] = $class;
      }
    }
206
207
208
209
    // Add site specific or test YAMLs.
    if (!empty($GLOBALS['conf']['container_yamls'])) {
      $this->serviceYamls = array_merge($this->serviceYamls, $GLOBALS['conf']['container_yamls']);
    }
210
211
    return $bundles;
  }
212

213
214
215
216
217
218
219
220
221
222
223
224
225
  /**
   * Returns module data on the filesystem.
   *
   * @param $module
   *   The name of the module.
   *
   * @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.
   */
  protected function moduleData($module) {
    if (!$this->moduleData) {
226
      // First, find profiles.
227
228
229
230
231
      $profiles_scanner = new SystemListing();
      $all_profiles = $profiles_scanner->scan('/^' . DRUPAL_PHP_FUNCTION_PATTERN . '\.profile$/', 'profiles');
      $profiles = array_keys(array_intersect_key($this->moduleList, $all_profiles));
      // If a module is within a profile directory but specifies another
      // profile for testing, it needs to be found in the parent profile.
232
      if (($parent_profile_config = $this->configStorage->read('simpletest.settings')) && isset($parent_profile_config['parent_profile']) && $parent_profile_config['parent_profile'] != $profiles[0]) {
233
234
235
236
237
238
239
240
241
242
243
        // In case both profile directories contain the same extension, the
        // actual profile always has precedence.
        array_unshift($profiles, $parent_profile_config['parent_profile']);
      }
      // Now find modules.
      $modules_scanner = new SystemListing($profiles);
      $this->moduleData = $all_profiles + $modules_scanner->scan('/^' . DRUPAL_PHP_FUNCTION_PATTERN . '\.module$/', 'modules');
    }
    return isset($this->moduleData[$module]) ? $this->moduleData[$module] : FALSE;
  }

244
245
  /**
   * Implements Drupal\Core\DrupalKernelInterface::updateModules().
246
247
248
   *
   * @todo Remove obsolete $module_list parameter. Only $module_filenames is
   *   needed.
249
   */
250
  public function updateModules(array $module_list, array $module_filenames = array()) {
251
    $this->newModuleList = $module_list;
252
253
    foreach ($module_filenames as $module => $filename) {
      $this->moduleData[$module] = (object) array('uri' => $filename);
254
    }
255
256
257
258
259
260
261
262
    // 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,
    // then reboot in order to refresh the bundle list and container.
    if ($this->booted) {
      $this->booted = FALSE;
      $this->boot();
    }
  }
263

264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
  /**
   * Returns the classname based on environment, debug and testing prefix.
   *
   * @return string
   *   The class name.
   */
  protected function getClassName() {
    $parts = array('service_container', $this->environment, $this->debug);
    // Make sure to use a testing-specific container even in the parent site.
    if (!empty($GLOBALS['drupal_test_info']['test_run_id'])) {
      $parts[] = $GLOBALS['drupal_test_info']['test_run_id'];
    }
    elseif ($prefix = drupal_valid_test_ua()) {
      $parts[] = $prefix;
    }
    return implode('_', $parts);
  }

282
283
284
  /**
   * Initializes the service container.
   */
285
  protected function initializeContainer() {
286
    $persist = $this->getServicesToPersist();
287
    $this->container = NULL;
288
289
290
    $class = $this->getClassName();
    $cache_file = $class . '.php';

291
    if ($this->allowDumping) {
292
293
      // First, try to load.
      if (!class_exists($class, FALSE)) {
294
        $this->storage()->load($cache_file);
295
296
297
298
299
      }
      // 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;
300
        $this->persistServices($persist);
301
302
      }
    }
303
304
305
306
307
308
309
310
    // 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);
    }
311
312
    // Second, check if some other request -- for example on another web
    // frontend or during the installer -- changed the list of enabled modules.
313
    if (isset($this->container)) {
314
315
      // All namespaces must be registered before we attempt to use any service
      // from the container.
316
      $container_modules = $this->container->getParameter('container.modules');
317
      $namespaces_before = $this->classLoader->getPrefixes();
318
      $this->registerNamespaces($this->getModuleNamespaces($container_modules));
319
320
321
322

      // If 'container.modules' is wrong, the container must be rebuilt.
      if (!isset($this->moduleList)) {
        $this->moduleList = $this->container->get('config.factory')->get('system.module')->load()->get('enabled');
323
      }
324
      if (array_keys($this->moduleList) !== array_keys($container_modules)) {
325
        $persist = $this->getServicesToPersist();
326
        unset($this->container);
327
328
329
330
        // 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.
331
        $namespaces_after = $this->classLoader->getPrefixes();
332
        $namespaces_before += array_fill_keys(array_diff(array_keys($namespaces_after), array_keys($namespaces_before)), array());
333
        $this->registerNamespaces($namespaces_before);
334
335
336
      }
    }

337
338
    if (!isset($this->container)) {
      $this->container = $this->buildContainer();
339
      $this->persistServices($persist);
340
341
      if ($this->allowDumping) {
        $this->containerNeedsDumping = TRUE;
342
343
344
      }
    }

345
    $this->container->set('kernel', $this);
346
347
    // Set the class loader which was registered as a synthetic service.
    $this->container->set('class_loader', $this->classLoader);
348

349
    \Drupal::setContainer($this->container);
350
  }
351

352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
  /**
   * 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);
      }
    }
  }

381
382
383
384
385
  /**
   * Builds the service container.
   *
   * @return ContainerBuilder The compiled service container
   */
386
  protected function buildContainer() {
387
    $this->initializeBundles();
388
    $container = $this->getContainerBuilder();
389
    $container->setParameter('container.bundles', $this->bundleClasses);
390
    $container->setParameter('container.modules', $this->getModuleFileNames());
391
392
393
394
395
396
397

    // Get a list of namespaces and put it onto the container.
    $namespaces = $this->getModuleNamespaces($this->getModuleFileNames());
    $namespaces['Drupal\Core'] = DRUPAL_ROOT . '/core/lib';
    $namespaces['Drupal\Component'] = DRUPAL_ROOT . '/core/lib';
    $container->setParameter('container.namespaces', $namespaces);

398
    // Register synthetic services.
399
    $container->register('class_loader', 'Symfony\Component\ClassLoader\ClassLoader')->setSynthetic(TRUE);
400
401
    $container->register('kernel', 'Symfony\Component\HttpKernel\KernelInterface')->setSynthetic(TRUE);
    $container->register('service_container', 'Symfony\Component\DependencyInjection\ContainerInterface')->setSynthetic(TRUE);
402
403
404
405
    $yaml_loader = new YamlFileLoader($container);
    foreach ($this->serviceYamls as $filename) {
      $yaml_loader->load($filename);
    }
406
407
    foreach ($this->bundles as $bundle) {
      $bundle->build($container);
408
    }
409
    $container->setParameter('persistIds', array_keys($container->findTaggedServiceIds('persist')));
410
    $container->compile();
411
412
    return $container;
  }
413

414
415
416
417
418
  /**
   * Gets a new ContainerBuilder instance used to build the service container.
   *
   * @return ContainerBuilder
   */
419
  protected function getContainerBuilder() {
420
421
422
    return new ContainerBuilder(new ParameterBag($this->getKernelParameters()));
  }

423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
  /**
   * 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) {
438
    if (!$this->storage()->writeable()) {
439
440
441
442
      return FALSE;
    }
    // Cache the container.
    $dumper = new PhpDumper($container);
443
444
    $class = $this->getClassName();
    $content = $dumper->dump(array('class' => $class, 'base_class' => $baseClass));
445
    return $this->storage()->save($class . '.php', $content);
446
447
  }

katbailey's avatar
katbailey committed
448
  /**
Crell's avatar
Crell committed
449
450
   * Overrides and eliminates this method from the parent class. Do not use.
   *
katbailey's avatar
katbailey committed
451
452
453
454
455
456
457
   * 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.
   */
458
  public function registerContainerConfiguration(LoaderInterface $loader) {
459
  }
460

461
462
463
464
465
466
467
468
469
470
471
472
  /**
   * 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;
  }

473
474
475
476
477
478
479
480
481
482
483
484
485
486
  /**
   * 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;
  }

  /**
487
   * Gets the namespaces of each enabled module.
488
   */
489
490
  protected function getModuleNamespaces($moduleFileNames) {
    $namespaces = array();
491
    foreach ($moduleFileNames as $module => $filename) {
492
493
494
495
496
497
498
499
500
      $namespaces["Drupal\\$module"] = DRUPAL_ROOT . '/' . dirname($filename) . '/lib';
    }
    return $namespaces;
  }

  /**
   * Registers a list of namespaces.
   */
  protected function registerNamespaces(array $namespaces = array()) {
501
    $this->classLoader->addPrefixes($namespaces);
502
  }
503
}