Drupal.php 22.6 KB
Newer Older
1
2
<?php

3
use Drupal\Core\DependencyInjection\ContainerNotInitializedException;
4
use Symfony\Component\DependencyInjection\ContainerInterface;
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * Static Service Container wrapper.
 *
 * Generally, code in Drupal should accept its dependencies via either
 * constructor injection or setter method injection. However, there are cases,
 * particularly in legacy procedural code, where that is infeasible. This
 * class acts as a unified global accessor to arbitrary services within the
 * system in order to ease the transition from procedural code to injected OO
 * code.
 *
 * The container is built by the kernel and passed in to this class which stores
 * it statically. The container always contains the services from
18
19
 * \Drupal\Core\CoreServiceProvider, the service providers of enabled modules and any other
 * service providers defined in $GLOBALS['conf']['container_service_providers'].
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 *
 * This class exists only to support legacy code that cannot be dependency
 * injected. If your code needs it, consider refactoring it to be object
 * oriented, if possible. When this is not possible, for instance in the case of
 * hook implementations, and your code is more than a few non-reusable lines, it
 * is recommended to instantiate an object implementing the actual logic.
 *
 * @code
 *   // Legacy procedural code.
 *   function hook_do_stuff() {
 *     $lock = lock()->acquire('stuff_lock');
 *     // ...
 *   }
 *
 *   // Correct procedural code.
 *   function hook_do_stuff() {
36
 *     $lock = \Drupal::lock()->acquire('stuff_lock');
37
38
39
40
41
42
 *     // ...
 *   }
 *
 *   // The preferred way: dependency injected code.
 *   function hook_do_stuff() {
 *     // Move the actual implementation to a class and instantiate it.
43
 *     $instance = new StuffDoingClass(\Drupal::lock());
44
45
46
47
48
49
 *     $instance->doStuff();
 *
 *     // Or, even better, rely on the service container to avoid hard coding a
 *     // specific interface implementation, so that the actual logic can be
 *     // swapped. This might not always make sense, but in general it is a good
 *     // practice.
50
 *     \Drupal::service('stuff.doing')->doStuff();
51
52
53
54
55
56
57
58
59
 *   }
 *
 *   interface StuffDoingInterface {
 *     public function doStuff();
 *   }
 *
 *   class StuffDoingClass implements StuffDoingInterface {
 *     protected $lockBackend;
 *
60
61
 *     public function __construct(LockBackendInterface $lock_backend) {
 *       $this->lockBackend = $lock_backend;
62
63
64
65
66
67
68
69
70
71
72
73
74
 *     }
 *
 *     public function doStuff() {
 *       $lock = $this->lockBackend->acquire('stuff_lock');
 *       // ...
 *     }
 *   }
 * @endcode
 *
 * @see \Drupal\Core\DrupalKernel
 */
class Drupal {

75
76
77
  /**
   * The current system version.
   */
catch's avatar
catch committed
78
  const VERSION = '9.2.3';
79
80
81
82
83
84

  /**
   * Core API compatibility.
   */
  const CORE_COMPATIBILITY = '8.x';

85
86
87
88
89
  /**
   * Core minimum schema version.
   */
  const CORE_MINIMUM_SCHEMA_VERSION = 8000;

90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
  /**
   * Minimum supported version of PHP.
   *
   * Below this version:
   * - New sites cannot be installed, except from within tests.
   * - Updates from previous Drupal versions can be run, but users are warned
   *   that Drupal no longer supports that PHP version.
   * - An error is shown in the status report that the PHP version is too old.
   */
  const MINIMUM_SUPPORTED_PHP = '7.3.0';

  /**
   * Minimum allowed version of PHP for Drupal to be bootstrapped.
   *
   * Below this version:
   * - The installer cannot be run.
   * - Updates cannot be run.
   * - Modules and themes cannot be enabled.
   * - If a site managed to bypass all of the above, then an error is shown in
   *   the status report and various fatal errors occur on various pages.
   *
   * Note: To prevent the installer from having fatal errors on older versions
   * of PHP, the value of this constant is hardcoded twice in core/install.php:
   * - Once as a parameter of version_compare()
   * - Once in the error message printed to the user immediately after.
   * Remember to update both whenever this constant is updated.
   */
  const MINIMUM_PHP = '7.3.0';

  /**
   * Minimum recommended value of PHP memory_limit.
   *
   * 64M was chosen as a minimum requirement in order to allow for additional
   * contributed modules to be installed prior to hitting the limit. However,
   * 40M is the target for the Standard installation profile.
   */
  const MINIMUM_PHP_MEMORY_LIMIT = '64M';

  /**
   * Minimum recommended version of PHP.
   *
   * Sites installing Drupal on PHP versions lower than this will see a warning
   * message, but Drupal can still be installed. Used for (e.g.) PHP versions
   * that have reached their EOL or will in the near future.
   */
135
  const RECOMMENDED_PHP = '7.4';
136

137
  /**
138
   * The currently active container object, or NULL if not initialized yet.
139
   *
140
   * @var \Symfony\Component\DependencyInjection\ContainerInterface|null
141
142
143
144
145
146
147
   */
  protected static $container;

  /**
   * Sets a new global container.
   *
   * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
148
   *   A new container instance to replace the current.
149
   */
150
  public static function setContainer(ContainerInterface $container) {
151
152
153
    static::$container = $container;
  }

154
155
156
157
158
159
160
  /**
   * Unsets the global container.
   */
  public static function unsetContainer() {
    static::$container = NULL;
  }

161
162
163
  /**
   * Returns the currently active global container.
   *
164
   * @return \Symfony\Component\DependencyInjection\ContainerInterface
165
166
   *
   * @throws \Drupal\Core\DependencyInjection\ContainerNotInitializedException
167
168
   */
  public static function getContainer() {
169
170
171
    if (static::$container === NULL) {
      throw new ContainerNotInitializedException('\Drupal::$container is not initialized yet. \Drupal::setContainer() must be called with a real container.');
    }
172
173
174
    return static::$container;
  }

175
176
177
178
179
180
181
182
183
  /**
   * Returns TRUE if the container has been initialized, FALSE otherwise.
   *
   * @return bool
   */
  public static function hasContainer() {
    return static::$container !== NULL;
  }

184
185
186
187
188
189
190
191
192
  /**
   * Retrieves a service from the container.
   *
   * Use this method if the desired service is not one of those with a dedicated
   * accessor method below. If it is listed below, those methods are preferred
   * as they can return useful type hints.
   *
   * @param string $id
   *   The ID of the service to retrieve.
193
   *
194
195
196
197
   * @return mixed
   *   The specified service.
   */
  public static function service($id) {
198
    return static::getContainer()->get($id);
199
200
  }

201
202
203
204
205
206
207
208
209
210
  /**
   * Indicates if a service is defined in the container.
   *
   * @param string $id
   *   The ID of the service to check.
   *
   * @return bool
   *   TRUE if the specified service exists, FALSE otherwise.
   */
  public static function hasService($id) {
211
212
    // Check hasContainer() first in order to always return a Boolean.
    return static::hasContainer() && static::getContainer()->has($id);
213
214
  }

215
216
217
218
219
220
  /**
   * Gets the app root.
   *
   * @return string
   */
  public static function root() {
221
    return static::getContainer()->getParameter('app.root');
222
223
  }

224
225
226
227
228
229
230
231
232
233
  /**
   * Gets the active install profile.
   *
   * @return string|null
   *   The name of the active install profile.
   */
  public static function installProfile() {
    return static::getContainer()->getParameter('install_profile');
  }

234
235
236
237
238
239
240
  /**
   * Indicates if there is a currently active request object.
   *
   * @return bool
   *   TRUE if there is a currently active request object, FALSE otherwise.
   */
  public static function hasRequest() {
241
242
    // Check hasContainer() first in order to always return a Boolean.
    return static::hasContainer() && static::getContainer()->has('request_stack') && static::getContainer()->get('request_stack')->getCurrentRequest() !== NULL;
243
244
  }

245
246
247
  /**
   * Retrieves the currently active request object.
   *
248
   * Note: The use of this wrapper in particular is especially discouraged. Most
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
   * code should not need to access the request directly.  Doing so means it
   * will only function when handling an HTTP request, and will require special
   * modification or wrapping when run from a command line tool, from certain
   * queue processors, or from automated tests.
   *
   * If code must access the request, it is considerably better to register
   * an object with the Service Container and give it a setRequest() method
   * that is configured to run when the service is created.  That way, the
   * correct request object can always be provided by the container and the
   * service can still be unit tested.
   *
   * If this method must be used, never save the request object that is
   * returned.  Doing so may lead to inconsistencies as the request object is
   * volatile and may change at various times, such as during a subrequest.
   *
   * @return \Symfony\Component\HttpFoundation\Request
   *   The currently active request object.
   */
  public static function request() {
268
    return static::getContainer()->get('request_stack')->getCurrentRequest();
269
270
  }

271
  /**
272
   * Retrieves the request stack.
273
274
275
276
277
   *
   * @return \Symfony\Component\HttpFoundation\RequestStack
   *   The request stack
   */
  public static function requestStack() {
278
    return static::getContainer()->get('request_stack');
279
280
  }

281
282
283
284
285
286
287
  /**
   * Retrieves the currently active route match object.
   *
   * @return \Drupal\Core\Routing\RouteMatchInterface
   *   The currently active route match object.
   */
  public static function routeMatch() {
288
    return static::getContainer()->get('current_route_match');
289
290
  }

291
292
293
  /**
   * Gets the current active user.
   *
294
295
296
297
298
299
300
   * This method will return the \Drupal\Core\Session\AccountProxy object of the
   * current user. You can use the \Drupal\user\Entity\User::load() method to
   * load the full user entity object. For example:
   * @code
   *   $user = \Drupal\user\Entity\User::load(\Drupal::currentUser()->id());
   * @endcode
   *
301
   * @return \Drupal\Core\Session\AccountProxyInterface
302
303
   */
  public static function currentUser() {
304
    return static::getContainer()->get('current_user');
305
306
  }

307
308
309
310
311
312
313
314
315
316
  /**
   * Retrieves the entity type manager.
   *
   * @return \Drupal\Core\Entity\EntityTypeManagerInterface
   *   The entity type manager.
   */
  public static function entityTypeManager() {
    return static::getContainer()->get('entity_type.manager');
  }

317
318
319
320
321
322
323
  /**
   * Returns the current primary database.
   *
   * @return \Drupal\Core\Database\Connection
   *   The current active database's master connection.
   */
  public static function database() {
324
    return static::getContainer()->get('database');
325
326
  }

327
328
329
330
331
  /**
   * Returns the requested cache bin.
   *
   * @param string $bin
   *   (optional) The cache bin for which the cache object should be returned,
332
   *   defaults to 'default'.
333
   *
334
   * @return \Drupal\Core\Cache\CacheBackendInterface
335
   *   The cache object associated with the specified bin.
336
337
   *
   * @ingroup cache
338
   */
339
  public static function cache($bin = 'default') {
340
    return static::getContainer()->get('cache.' . $bin);
341
342
  }

343
344
345
346
347
348
349
350
351
352
  /**
   * Retrieves the class resolver.
   *
   * This is to be used in procedural code such as module files to instantiate
   * an object of a class that implements
   * \Drupal\Core\DependencyInjection\ContainerInjectionInterface.
   *
   * One common usecase is to provide a class which contains the actual code
   * of a hook implementation, without having to create a service.
   *
353
354
355
356
357
358
359
360
361
   * @param string $class
   *   (optional) A class name to instantiate.
   *
   * @return \Drupal\Core\DependencyInjection\ClassResolverInterface|object
   *   The class resolver or if $class is provided, a class instance with a
   *   given class definition.
   *
   * @throws \InvalidArgumentException
   *   If $class does not exist.
362
   */
363
364
365
366
  public static function classResolver($class = NULL) {
    if ($class) {
      return static::getContainer()->get('class_resolver')->getInstanceFromDefinition($class);
    }
367
368
369
    return static::getContainer()->get('class_resolver');
  }

370
371
372
373
374
375
376
377
378
379
  /**
   * Returns an expirable key value store collection.
   *
   * @param string $collection
   *   The name of the collection holding key and value pairs.
   *
   * @return \Drupal\Core\KeyValueStore\KeyValueStoreExpirableInterface
   *   An expirable key value store collection.
   */
  public static function keyValueExpirable($collection) {
380
    return static::getContainer()->get('keyvalue.expirable')->get($collection);
381
382
  }

383
384
385
386
  /**
   * Returns the locking layer instance.
   *
   * @return \Drupal\Core\Lock\LockBackendInterface
387
388
   *
   * @ingroup lock
389
390
   */
  public static function lock() {
391
    return static::getContainer()->get('lock');
392
393
  }

394
395
396
397
  /**
   * Retrieves a configuration object.
   *
   * This is the main entry point to the configuration API. Calling
398
   * @code \Drupal::config('book.admin') @endcode will return a configuration
399
   * object the Book module can use to read its administrative settings.
400
401
   *
   * @param string $name
402
403
404
405
406
   *   The name of the configuration object to retrieve, which typically
   *   corresponds to a configuration file. For
   *   @code \Drupal::config('book.admin') @endcode, the configuration
   *   object returned will contain the content of the book.admin
   *   configuration file.
407
   *
408
409
   * @return \Drupal\Core\Config\ImmutableConfig
   *   An immutable configuration object.
410
411
   */
  public static function config($name) {
412
    return static::getContainer()->get('config.factory')->get($name);
413
414
  }

415
416
417
418
419
420
421
  /**
   * Retrieves the configuration factory.
   *
   * This is mostly used to change the override settings on the configuration
   * factory. For example, changing the language, or turning all overrides on
   * or off.
   *
422
   * @return \Drupal\Core\Config\ConfigFactoryInterface
423
   *   The configuration factory service.
424
425
   */
  public static function configFactory() {
426
    return static::getContainer()->get('config.factory');
427
428
  }

429
430
431
  /**
   * Returns a queue for the given queue name.
   *
432
433
434
435
436
437
438
439
   * The following values can be set in your settings.php file's $settings
   * array to define which services are used for queues:
   * - queue_reliable_service_$name: The container service to use for the
   *   reliable queue $name.
   * - queue_service_$name: The container service to use for the
   *   queue $name.
   * - queue_default: The container service to use by default for queues
   *   without overrides. This defaults to 'queue.database'.
440
441
442
443
444
445
446
447
448
449
450
451
   *
   * @param string $name
   *   The name of the queue to work with.
   * @param bool $reliable
   *   (optional) TRUE if the ordering of items and guaranteeing every item
   *   executes at least once is important, FALSE if scalability is the main
   *   concern. Defaults to FALSE.
   *
   * @return \Drupal\Core\Queue\QueueInterface
   *   The queue object for a given name.
   */
  public static function queue($name, $reliable = FALSE) {
452
    return static::getContainer()->get('queue')->get($name, $reliable);
453
454
455
456
457
  }

  /**
   * Returns a key/value storage collection.
   *
458
   * @param string $collection
459
460
461
462
463
   *   Name of the key/value collection to return.
   *
   * @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface
   */
  public static function keyValue($collection) {
464
    return static::getContainer()->get('keyvalue')->get($collection);
465
466
467
468
469
470
471
472
473
  }

  /**
   * Returns the state storage service.
   *
   * Use this to store machine-generated data, local to a specific environment
   * that does not need deploying and does not need human editing; for example,
   * the last time cron was run. Data which needs to be edited by humans and
   * needs to be the same across development, production, etc. environments
474
   * (for example, the system maintenance message) should use \Drupal::config() instead.
475
   *
476
   * @return \Drupal\Core\State\StateInterface
477
478
   */
  public static function state() {
479
    return static::getContainer()->get('state');
480
481
482
483
484
  }

  /**
   * Returns the default http client.
   *
485
   * @return \GuzzleHttp\Client
486
487
488
   *   A guzzle http client instance.
   */
  public static function httpClient() {
489
    return static::getContainer()->get('http_client');
490
491
492
493
494
495
  }

  /**
   * Returns the entity query object for this entity type.
   *
   * @param string $entity_type
496
   *   The entity type (for example, node) for which the query object should be
497
498
   *   returned.
   * @param string $conjunction
499
500
   *   (optional) Either 'AND' if all conditions in the query need to apply, or
   *   'OR' if any of them is sufficient. Defaults to 'AND'.
501
502
503
504
505
   *
   * @return \Drupal\Core\Entity\Query\QueryInterface
   *   The query object that can query the given entity type.
   */
  public static function entityQuery($entity_type, $conjunction = 'AND') {
506
    return static::entityTypeManager()->getStorage($entity_type)->getQuery($conjunction);
507
508
  }

509
510
511
  /**
   * Returns the entity query aggregate object for this entity type.
   *
512
   * @param string $entity_type
513
   *   The entity type (for example, node) for which the query object should be
514
   *   returned.
515
   * @param string $conjunction
516
517
   *   (optional) Either 'AND' if all conditions in the query need to apply, or
   *   'OR' if any of them is sufficient. Defaults to 'AND'.
518
   *
519
   * @return \Drupal\Core\Entity\Query\QueryAggregateInterface
520
521
522
   *   The query object that can query the given entity type.
   */
  public static function entityQueryAggregate($entity_type, $conjunction = 'AND') {
523
    return static::entityTypeManager()->getStorage($entity_type)->getAggregateQuery($conjunction);
524
525
  }

526
527
528
529
530
531
  /**
   * Returns the flood instance.
   *
   * @return \Drupal\Core\Flood\FloodInterface
   */
  public static function flood() {
532
    return static::getContainer()->get('flood');
533
534
535
536
537
  }

  /**
   * Returns the module handler.
   *
538
   * @return \Drupal\Core\Extension\ModuleHandlerInterface
539
540
   */
  public static function moduleHandler() {
541
    return static::getContainer()->get('module_handler');
542
543
544
545
546
547
548
  }

  /**
   * Returns the typed data manager service.
   *
   * Use the typed data manager service for creating typed data objects.
   *
549
   * @return \Drupal\Core\TypedData\TypedDataManagerInterface
550
551
552
553
   *   The typed data manager.
   *
   * @see \Drupal\Core\TypedData\TypedDataManager::create()
   */
554
  public static function typedDataManager() {
555
    return static::getContainer()->get('typed_data_manager');
556
557
  }

558
559
560
561
562
563
564
  /**
   * Returns the token service.
   *
   * @return \Drupal\Core\Utility\Token
   *   The token service.
   */
  public static function token() {
565
    return static::getContainer()->get('token');
566
567
  }

568
569
570
  /**
   * Returns the url generator service.
   *
571
   * @return \Drupal\Core\Routing\UrlGeneratorInterface
572
573
574
   *   The url generator service.
   */
  public static function urlGenerator() {
575
    return static::getContainer()->get('url_generator');
576
577
578
579
580
581
582
583
  }

  /**
   * Returns the link generator service.
   *
   * @return \Drupal\Core\Utility\LinkGeneratorInterface
   */
  public static function linkGenerator() {
584
    return static::getContainer()->get('link_generator');
585
586
  }

587
588
589
  /**
   * Returns the string translation service.
   *
590
   * @return \Drupal\Core\StringTranslation\TranslationManager
591
592
593
   *   The string translation manager.
   */
  public static function translation() {
594
    return static::getContainer()->get('string_translation');
595
596
  }

597
598
599
  /**
   * Returns the language manager service.
   *
600
   * @return \Drupal\Core\Language\LanguageManagerInterface
601
602
603
   *   The language manager.
   */
  public static function languageManager() {
604
    return static::getContainer()->get('language_manager');
605
606
  }

607
608
609
  /**
   * Returns the CSRF token manager service.
   *
610
611
612
613
614
   * The generated token is based on the session ID of the current user. Normally,
   * anonymous users do not have a session, so the generated token will be
   * different on every page request. To generate a token for users without a
   * session, manually start a session prior to calling this function.
   *
615
616
   * @return \Drupal\Core\Access\CsrfTokenGenerator
   *   The CSRF token manager.
617
   *
618
   * @see \Drupal\Core\Session\SessionManager::start()
619
620
   */
  public static function csrfToken() {
621
    return static::getContainer()->get('csrf_token');
622
623
  }

624
625
626
  /**
   * Returns the transliteration service.
   *
627
   * @return \Drupal\Core\Transliteration\PhpTransliteration
628
629
630
   *   The transliteration manager.
   */
  public static function transliteration() {
631
    return static::getContainer()->get('transliteration');
632
633
  }

634
635
636
637
638
639
640
  /**
   * Returns the form builder service.
   *
   * @return \Drupal\Core\Form\FormBuilderInterface
   *   The form builder.
   */
  public static function formBuilder() {
641
    return static::getContainer()->get('form_builder');
642
643
  }

644
645
646
647
648
649
  /**
   * Gets the theme service.
   *
   * @return \Drupal\Core\Theme\ThemeManagerInterface
   */
  public static function theme() {
650
    return static::getContainer()->get('theme.manager');
651
652
  }

653
654
655
656
657
658
  /**
   * Gets the syncing state.
   *
   * @return bool
   *   Returns TRUE is syncing flag set.
   */
659
  public static function isConfigSyncing() {
660
    return static::getContainer()->get('config.installer')->isSyncing();
661
662
  }

663
664
665
666
667
668
669
  /**
   * Returns a channel logger object.
   *
   * @param string $channel
   *   The name of the channel. Can be any string, but the general practice is
   *   to use the name of the subsystem calling this.
   *
670
   * @return \Psr\Log\LoggerInterface
671
672
673
   *   The logger for this channel.
   */
  public static function logger($channel) {
674
    return static::getContainer()->get('logger.factory')->get($channel);
675
676
  }

677
678
679
680
681
682
683
  /**
   * Returns the menu tree.
   *
   * @return \Drupal\Core\Menu\MenuLinkTreeInterface
   *   The menu tree.
   */
  public static function menuTree() {
684
    return static::getContainer()->get('menu.link_tree');
685
686
  }

687
688
689
690
691
692
  /**
   * Returns the path validator.
   *
   * @return \Drupal\Core\Path\PathValidatorInterface
   */
  public static function pathValidator() {
693
    return static::getContainer()->get('path.validator');
694
695
  }

696
697
698
699
700
701
702
  /**
   * Returns the access manager service.
   *
   * @return \Drupal\Core\Access\AccessManagerInterface
   *   The access manager service.
   */
  public static function accessManager() {
703
    return static::getContainer()->get('access_manager');
704
705
  }

706
707
708
709
710
711
712
713
714
715
  /**
   * Returns the redirect destination helper.
   *
   * @return \Drupal\Core\Routing\RedirectDestinationInterface
   *   The redirect destination helper.
   */
  public static function destination() {
    return static::getContainer()->get('redirect.destination');
  }

716
717
718
719
720
721
722
723
724
725
  /**
   * Returns the entity definition update manager.
   *
   * @return \Drupal\Core\Entity\EntityDefinitionUpdateManagerInterface
   *   The entity definition update manager.
   */
  public static function entityDefinitionUpdateManager() {
    return static::getContainer()->get('entity.definition_update_manager');
  }

726
727
728
729
730
731
732
733
734
735
  /**
   * Returns the time service.
   *
   * @return \Drupal\Component\Datetime\TimeInterface
   *   The time service.
   */
  public static function time() {
    return static::getContainer()->get('datetime.time');
  }

736
737
738
739
740
741
742
  /**
   * Returns the messenger.
   *
   * @return \Drupal\Core\Messenger\MessengerInterface
   *   The messenger.
   */
  public static function messenger() {
743
    return static::getContainer()->get('messenger');
744
745
  }

746
}