Drupal.php 25 KB
Newer Older
1
2
3
4
<?php

/**
 * @file
5
 * Contains \Drupal.
6
7
 */

8
use Drupal\Core\DependencyInjection\ContainerNotInitializedException;
9
use Drupal\Core\Messenger\LegacyMessenger;
10
use Drupal\Core\Url;
11
use Symfony\Component\DependencyInjection\ContainerInterface;
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
 * 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
25
26
 * \Drupal\Core\CoreServiceProvider, the service providers of enabled modules and any other
 * service providers defined in $GLOBALS['conf']['container_service_providers'].
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 *
 * 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() {
43
 *     $lock = \Drupal::lock()->acquire('stuff_lock');
44
45
46
47
48
49
 *     // ...
 *   }
 *
 *   // The preferred way: dependency injected code.
 *   function hook_do_stuff() {
 *     // Move the actual implementation to a class and instantiate it.
50
 *     $instance = new StuffDoingClass(\Drupal::lock());
51
52
53
54
55
56
 *     $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.
57
 *     \Drupal::service('stuff.doing')->doStuff();
58
59
60
61
62
63
64
65
66
 *   }
 *
 *   interface StuffDoingInterface {
 *     public function doStuff();
 *   }
 *
 *   class StuffDoingClass implements StuffDoingInterface {
 *     protected $lockBackend;
 *
67
68
 *     public function __construct(LockBackendInterface $lock_backend) {
 *       $this->lockBackend = $lock_backend;
69
70
71
72
73
74
75
76
77
78
79
80
81
 *     }
 *
 *     public function doStuff() {
 *       $lock = $this->lockBackend->acquire('stuff_lock');
 *       // ...
 *     }
 *   }
 * @endcode
 *
 * @see \Drupal\Core\DrupalKernel
 */
class Drupal {

82
83
84
  /**
   * The current system version.
   */
xjm's avatar
xjm committed
85
  const VERSION = '8.9.2';
86
87
88
89
90
91

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

92
93
94
95
96
  /**
   * Core minimum schema version.
   */
  const CORE_MINIMUM_SCHEMA_VERSION = 8000;

97
  /**
98
   * The currently active container object, or NULL if not initialized yet.
99
   *
100
   * @var \Symfony\Component\DependencyInjection\ContainerInterface|null
101
102
103
104
105
106
107
   */
  protected static $container;

  /**
   * Sets a new global container.
   *
   * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
108
   *   A new container instance to replace the current.
109
   */
110
  public static function setContainer(ContainerInterface $container) {
111
112
113
    static::$container = $container;
  }

114
115
116
117
118
119
120
  /**
   * Unsets the global container.
   */
  public static function unsetContainer() {
    static::$container = NULL;
  }

121
122
123
  /**
   * Returns the currently active global container.
   *
124
   * @return \Symfony\Component\DependencyInjection\ContainerInterface
125
126
   *
   * @throws \Drupal\Core\DependencyInjection\ContainerNotInitializedException
127
128
   */
  public static function getContainer() {
129
130
131
    if (static::$container === NULL) {
      throw new ContainerNotInitializedException('\Drupal::$container is not initialized yet. \Drupal::setContainer() must be called with a real container.');
    }
132
133
134
    return static::$container;
  }

135
136
137
138
139
140
141
142
143
  /**
   * Returns TRUE if the container has been initialized, FALSE otherwise.
   *
   * @return bool
   */
  public static function hasContainer() {
    return static::$container !== NULL;
  }

144
145
146
147
148
149
150
151
152
  /**
   * 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.
153
   *
154
155
156
157
   * @return mixed
   *   The specified service.
   */
  public static function service($id) {
158
    return static::getContainer()->get($id);
159
160
  }

161
162
163
164
165
166
167
168
169
170
  /**
   * 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) {
171
172
    // Check hasContainer() first in order to always return a Boolean.
    return static::hasContainer() && static::getContainer()->has($id);
173
174
  }

175
176
177
178
179
180
  /**
   * Gets the app root.
   *
   * @return string
   */
  public static function root() {
181
    return static::getContainer()->get('app.root');
182
183
  }

184
185
186
187
188
189
190
191
192
193
  /**
   * 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');
  }

194
195
196
197
198
199
200
  /**
   * 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() {
201
202
    // 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;
203
204
  }

205
206
207
  /**
   * Retrieves the currently active request object.
   *
208
   * Note: The use of this wrapper in particular is especially discouraged. Most
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
   * 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() {
228
    return static::getContainer()->get('request_stack')->getCurrentRequest();
229
230
  }

231
  /**
232
   * Retrieves the request stack.
233
234
235
236
237
   *
   * @return \Symfony\Component\HttpFoundation\RequestStack
   *   The request stack
   */
  public static function requestStack() {
238
    return static::getContainer()->get('request_stack');
239
240
  }

241
242
243
244
245
246
247
  /**
   * Retrieves the currently active route match object.
   *
   * @return \Drupal\Core\Routing\RouteMatchInterface
   *   The currently active route match object.
   */
  public static function routeMatch() {
248
    return static::getContainer()->get('current_route_match');
249
250
  }

251
252
253
  /**
   * Gets the current active user.
   *
254
255
256
257
258
259
260
   * 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
   *
261
   * @return \Drupal\Core\Session\AccountProxyInterface
262
263
   */
  public static function currentUser() {
264
    return static::getContainer()->get('current_user');
265
266
  }

267
268
269
  /**
   * Retrieves the entity manager service.
   *
270
   * @return \Drupal\Core\Entity\EntityManagerInterface
271
   *   The entity manager service.
272
   *
273
   * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0.
274
275
276
277
   *   Use \Drupal::entityTypeManager() instead in most cases. If the needed
   *   method is not on \Drupal\Core\Entity\EntityTypeManagerInterface, see the
   *   deprecated \Drupal\Core\Entity\EntityManager to find the
   *   correct interface or service.
278
279
   */
  public static function entityManager() {
280
    @trigger_error("\Drupal::entityManager() is deprecated in Drupal 8.0.0 and will be removed before Drupal 9.0.0. Use \Drupal::entityTypeManager() instead in most cases. If the needed method is not on \Drupal\Core\Entity\EntityTypeManagerInterface, see the deprecated \Drupal\Core\Entity\EntityManager to find the correct interface or service. See https://www.drupal.org/node/2549139", E_USER_DEPRECATED);
281
    return static::getContainer()->get('entity.manager');
282
283
  }

284
285
286
287
288
289
290
291
292
293
  /**
   * 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');
  }

294
295
296
297
298
299
300
  /**
   * Returns the current primary database.
   *
   * @return \Drupal\Core\Database\Connection
   *   The current active database's master connection.
   */
  public static function database() {
301
    return static::getContainer()->get('database');
302
303
  }

304
305
306
307
308
  /**
   * Returns the requested cache bin.
   *
   * @param string $bin
   *   (optional) The cache bin for which the cache object should be returned,
309
   *   defaults to 'default'.
310
   *
311
   * @return \Drupal\Core\Cache\CacheBackendInterface
312
   *   The cache object associated with the specified bin.
313
314
   *
   * @ingroup cache
315
   */
316
  public static function cache($bin = 'default') {
317
    return static::getContainer()->get('cache.' . $bin);
318
319
  }

320
321
322
323
324
325
326
327
328
329
  /**
   * 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.
   *
330
331
332
333
334
335
336
337
338
   * @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.
339
   */
340
341
342
343
  public static function classResolver($class = NULL) {
    if ($class) {
      return static::getContainer()->get('class_resolver')->getInstanceFromDefinition($class);
    }
344
345
346
    return static::getContainer()->get('class_resolver');
  }

347
348
349
350
351
352
353
354
355
356
  /**
   * 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) {
357
    return static::getContainer()->get('keyvalue.expirable')->get($collection);
358
359
  }

360
361
362
363
  /**
   * Returns the locking layer instance.
   *
   * @return \Drupal\Core\Lock\LockBackendInterface
364
365
   *
   * @ingroup lock
366
367
   */
  public static function lock() {
368
    return static::getContainer()->get('lock');
369
370
  }

371
372
373
374
  /**
   * Retrieves a configuration object.
   *
   * This is the main entry point to the configuration API. Calling
375
   * @code \Drupal::config('book.admin') @endcode will return a configuration
376
   * object the Book module can use to read its administrative settings.
377
378
   *
   * @param string $name
379
380
381
382
383
   *   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.
384
   *
385
386
   * @return \Drupal\Core\Config\ImmutableConfig
   *   An immutable configuration object.
387
388
   */
  public static function config($name) {
389
    return static::getContainer()->get('config.factory')->get($name);
390
391
  }

392
393
394
395
396
397
398
  /**
   * 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.
   *
399
   * @return \Drupal\Core\Config\ConfigFactoryInterface
400
   *   The configuration factory service.
401
402
   */
  public static function configFactory() {
403
    return static::getContainer()->get('config.factory');
404
405
  }

406
407
408
  /**
   * Returns a queue for the given queue name.
   *
409
410
411
412
413
414
415
416
   * 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'.
417
418
419
420
421
422
423
424
425
426
427
428
   *
   * @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) {
429
    return static::getContainer()->get('queue')->get($name, $reliable);
430
431
432
433
434
  }

  /**
   * Returns a key/value storage collection.
   *
435
   * @param string $collection
436
437
438
439
440
   *   Name of the key/value collection to return.
   *
   * @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface
   */
  public static function keyValue($collection) {
441
    return static::getContainer()->get('keyvalue')->get($collection);
442
443
444
445
446
447
448
449
450
  }

  /**
   * 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
451
   * (for example, the system maintenance message) should use \Drupal::config() instead.
452
   *
453
   * @return \Drupal\Core\State\StateInterface
454
455
   */
  public static function state() {
456
    return static::getContainer()->get('state');
457
458
459
460
461
  }

  /**
   * Returns the default http client.
   *
462
   * @return \GuzzleHttp\Client
463
464
465
   *   A guzzle http client instance.
   */
  public static function httpClient() {
466
    return static::getContainer()->get('http_client');
467
468
469
470
471
472
  }

  /**
   * Returns the entity query object for this entity type.
   *
   * @param string $entity_type
473
   *   The entity type (for example, node) for which the query object should be
474
475
   *   returned.
   * @param string $conjunction
476
477
   *   (optional) Either 'AND' if all conditions in the query need to apply, or
   *   'OR' if any of them is sufficient. Defaults to 'AND'.
478
479
480
481
482
   *
   * @return \Drupal\Core\Entity\Query\QueryInterface
   *   The query object that can query the given entity type.
   */
  public static function entityQuery($entity_type, $conjunction = 'AND') {
483
    return static::entityTypeManager()->getStorage($entity_type)->getQuery($conjunction);
484
485
  }

486
487
488
  /**
   * Returns the entity query aggregate object for this entity type.
   *
489
   * @param string $entity_type
490
   *   The entity type (for example, node) for which the query object should be
491
   *   returned.
492
   * @param string $conjunction
493
494
   *   (optional) Either 'AND' if all conditions in the query need to apply, or
   *   'OR' if any of them is sufficient. Defaults to 'AND'.
495
   *
496
   * @return \Drupal\Core\Entity\Query\QueryAggregateInterface
497
498
499
   *   The query object that can query the given entity type.
   */
  public static function entityQueryAggregate($entity_type, $conjunction = 'AND') {
500
    return static::entityTypeManager()->getStorage($entity_type)->getAggregateQuery($conjunction);
501
502
  }

503
504
505
506
507
508
  /**
   * Returns the flood instance.
   *
   * @return \Drupal\Core\Flood\FloodInterface
   */
  public static function flood() {
509
    return static::getContainer()->get('flood');
510
511
512
513
514
  }

  /**
   * Returns the module handler.
   *
515
   * @return \Drupal\Core\Extension\ModuleHandlerInterface
516
517
   */
  public static function moduleHandler() {
518
    return static::getContainer()->get('module_handler');
519
520
521
522
523
524
525
  }

  /**
   * Returns the typed data manager service.
   *
   * Use the typed data manager service for creating typed data objects.
   *
526
   * @return \Drupal\Core\TypedData\TypedDataManagerInterface
527
528
529
530
   *   The typed data manager.
   *
   * @see \Drupal\Core\TypedData\TypedDataManager::create()
   */
531
  public static function typedDataManager() {
532
    return static::getContainer()->get('typed_data_manager');
533
534
  }

535
536
537
538
539
540
541
  /**
   * Returns the token service.
   *
   * @return \Drupal\Core\Utility\Token
   *   The token service.
   */
  public static function token() {
542
    return static::getContainer()->get('token');
543
544
  }

545
546
547
  /**
   * Returns the url generator service.
   *
548
   * @return \Drupal\Core\Routing\UrlGeneratorInterface
549
550
551
   *   The url generator service.
   */
  public static function urlGenerator() {
552
    return static::getContainer()->get('url_generator');
553
554
  }

555
  /**
556
557
558
559
560
561
562
   * Generates a URL string for a specific route based on the given parameters.
   *
   * This method is a convenience wrapper for generating URL strings for URLs
   * that have Drupal routes (that is, most pages generated by Drupal) using
   * the \Drupal\Core\Url object. See \Drupal\Core\Url::fromRoute() for
   * detailed documentation. For non-routed local URIs relative to
   * the base path (like robots.txt) use Url::fromUri()->toString() with the
563
   * base: scheme.
564
   *
565
566
567
568
569
570
   * @param string $route_name
   *   The name of the route.
   * @param array $route_parameters
   *   (optional) An associative array of parameter names and values.
   * @param array $options
   *   (optional) An associative array of additional options.
571
   * @param bool $collect_bubbleable_metadata
572
   *   (optional) Defaults to FALSE. When TRUE, both the generated URL and its
573
   *   associated bubbleable metadata are returned.
574
   *
575
576
   * @return string|\Drupal\Core\GeneratedUrl
   *   A string containing a URL to the given path.
577
578
   *   When $collect_bubbleable_metadata is TRUE, a GeneratedUrl object is
   *   returned, containing the generated URL plus bubbleable metadata.
579
580
   *
   * @see \Drupal\Core\Routing\UrlGeneratorInterface::generateFromRoute()
581
582
583
   * @see \Drupal\Core\Url
   * @see \Drupal\Core\Url::fromRoute()
   * @see \Drupal\Core\Url::fromUri()
584
   *
585
   * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0.
586
587
   *   Instead create a \Drupal\Core\Url object directly, for example using
   *   Url::fromRoute().
588
   */
589
  public static function url($route_name, $route_parameters = [], $options = [], $collect_bubbleable_metadata = FALSE) {
590
    @trigger_error('Drupal::url() is deprecated as of Drupal 8.0.x, will be removed before Drupal 9.0.0. Instead create a \Drupal\Core\Url object directly, for example using Url::fromRoute()', E_USER_DEPRECATED);
591
    return static::getContainer()->get('url_generator')->generateFromRoute($route_name, $route_parameters, $options, $collect_bubbleable_metadata);
592
593
  }

594
595
596
597
598
599
  /**
   * Returns the link generator service.
   *
   * @return \Drupal\Core\Utility\LinkGeneratorInterface
   */
  public static function linkGenerator() {
600
    return static::getContainer()->get('link_generator');
601
602
603
  }

  /**
604
605
606
   * Renders a link with a given link text and Url object.
   *
   * This method is a convenience wrapper for the link generator service's
607
   * generate() method.
608
   *
609
610
611
612
613
   * @param string $text
   *   The link text for the anchor tag.
   * @param \Drupal\Core\Url $url
   *   The URL object used for the link.
   *
614
615
616
   * @return \Drupal\Core\GeneratedLink
   *   A GeneratedLink object containing a link to the given route and
   *   parameters and bubbleable metadata.
617
   *
618
619
620
621
   * @deprecated in drupal:8.0.0 and is removed from drupal:9.0.0. Use
   * \Drupal\Core\Link::fromTextAndUrl() instead.
   *
   * @see https://www.drupal.org/node/2614344
622
   * @see \Drupal\Core\Utility\LinkGeneratorInterface::generate()
623
   * @see \Drupal\Core\Url
624
   */
625
  public static function l($text, Url $url) {
626
    @trigger_error('\Drupal::l() is deprecated in drupal:8.0.0 and is removed from drupal:9.0.0. Use \Drupal\Core\Link::fromTextAndUrl() instead. See https://www.drupal.org/node/2614344', E_USER_DEPRECATED);
627
    return static::getContainer()->get('link_generator')->generate($text, $url);
628
629
  }

630
631
632
  /**
   * Returns the string translation service.
   *
633
   * @return \Drupal\Core\StringTranslation\TranslationManager
634
635
636
   *   The string translation manager.
   */
  public static function translation() {
637
    return static::getContainer()->get('string_translation');
638
639
  }

640
641
642
  /**
   * Returns the language manager service.
   *
643
   * @return \Drupal\Core\Language\LanguageManagerInterface
644
645
646
   *   The language manager.
   */
  public static function languageManager() {
647
    return static::getContainer()->get('language_manager');
648
649
  }

650
651
652
  /**
   * Returns the CSRF token manager service.
   *
653
654
655
656
657
   * 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.
   *
658
659
   * @return \Drupal\Core\Access\CsrfTokenGenerator
   *   The CSRF token manager.
660
   *
661
   * @see \Drupal\Core\Session\SessionManager::start()
662
663
   */
  public static function csrfToken() {
664
    return static::getContainer()->get('csrf_token');
665
666
  }

667
668
669
  /**
   * Returns the transliteration service.
   *
670
   * @return \Drupal\Core\Transliteration\PhpTransliteration
671
672
673
   *   The transliteration manager.
   */
  public static function transliteration() {
674
    return static::getContainer()->get('transliteration');
675
676
  }

677
678
679
680
681
682
683
  /**
   * Returns the form builder service.
   *
   * @return \Drupal\Core\Form\FormBuilderInterface
   *   The form builder.
   */
  public static function formBuilder() {
684
    return static::getContainer()->get('form_builder');
685
686
  }

687
688
689
690
691
692
  /**
   * Gets the theme service.
   *
   * @return \Drupal\Core\Theme\ThemeManagerInterface
   */
  public static function theme() {
693
    return static::getContainer()->get('theme.manager');
694
695
  }

696
697
698
699
700
701
  /**
   * Gets the syncing state.
   *
   * @return bool
   *   Returns TRUE is syncing flag set.
   */
702
  public static function isConfigSyncing() {
703
    return static::getContainer()->get('config.installer')->isSyncing();
704
705
  }

706
707
708
709
710
711
712
  /**
   * 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.
   *
713
   * @return \Psr\Log\LoggerInterface
714
715
716
   *   The logger for this channel.
   */
  public static function logger($channel) {
717
    return static::getContainer()->get('logger.factory')->get($channel);
718
719
  }

720
721
722
723
724
725
726
  /**
   * Returns the menu tree.
   *
   * @return \Drupal\Core\Menu\MenuLinkTreeInterface
   *   The menu tree.
   */
  public static function menuTree() {
727
    return static::getContainer()->get('menu.link_tree');
728
729
  }

730
731
732
733
734
735
  /**
   * Returns the path validator.
   *
   * @return \Drupal\Core\Path\PathValidatorInterface
   */
  public static function pathValidator() {
736
    return static::getContainer()->get('path.validator');
737
738
  }

739
740
741
742
743
744
745
  /**
   * Returns the access manager service.
   *
   * @return \Drupal\Core\Access\AccessManagerInterface
   *   The access manager service.
   */
  public static function accessManager() {
746
    return static::getContainer()->get('access_manager');
747
748
  }

749
750
751
752
753
754
755
756
757
758
  /**
   * Returns the redirect destination helper.
   *
   * @return \Drupal\Core\Routing\RedirectDestinationInterface
   *   The redirect destination helper.
   */
  public static function destination() {
    return static::getContainer()->get('redirect.destination');
  }

759
760
761
762
763
764
765
766
767
768
  /**
   * 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');
  }

769
770
771
772
773
774
775
776
777
778
  /**
   * Returns the time service.
   *
   * @return \Drupal\Component\Datetime\TimeInterface
   *   The time service.
   */
  public static function time() {
    return static::getContainer()->get('datetime.time');
  }

779
780
781
782
783
784
785
786
787
  /**
   * Returns the messenger.
   *
   * @return \Drupal\Core\Messenger\MessengerInterface
   *   The messenger.
   */
  public static function messenger() {
    // @todo Replace with service once LegacyMessenger is removed in 9.0.0.
    // @see https://www.drupal.org/node/2928994
788
    return new LegacyMessenger();
789
790
  }

791
}