Drupal.php 21.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php

/**
 * @file
 * Contains Drupal.
 */

use Symfony\Component\DependencyInjection\ContainerInterface;

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

79
80
81
82
83
84
85
86
87
88
  /**
   * The current system version.
   */
  const VERSION = '8.0-dev';

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

89
90
91
92
93
  /**
   * Core minimum schema version.
   */
  const CORE_MINIMUM_SCHEMA_VERSION = 8000;

94
95
96
97
98
99
100
101
102
103
104
  /**
   * The currently active container object.
   *
   * @var \Symfony\Component\DependencyInjection\ContainerInterface
   */
  protected static $container;

  /**
   * Sets a new global container.
   *
   * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
105
106
107
   *   A new container instance to replace the current. NULL may be passed by
   *   testing frameworks to ensure that the global state of a previous
   *   environment does not leak into a test.
108
   */
109
  public static function setContainer(ContainerInterface $container = NULL) {
110
111
112
113
114
115
    static::$container = $container;
  }

  /**
   * Returns the currently active global container.
   *
116
117
   * @deprecated This method is only useful for the testing environment. It
   * should not be used otherwise.
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
   *
   * @return \Symfony\Component\DependencyInjection\ContainerInterface
   */
  public static function getContainer() {
    return static::$container;
  }

  /**
   * 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.
   * @return mixed
   *   The specified service.
   */
  public static function service($id) {
    return static::$container->get($id);
  }

141
142
143
144
145
146
147
148
149
150
151
152
153
  /**
   * 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) {
    return static::$container && static::$container->has($id);
  }

154
155
156
157
158
159
160
161
162
163
  /**
   * 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() {
    return static::$container && static::$container->has('request') && static::$container->initialized('request') && static::$container->isScopeActive('request');
  }

164
165
166
  /**
   * Retrieves the currently active request object.
   *
167
   * Note: The use of this wrapper in particular is especially discouraged. Most
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
   * 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() {
    return static::$container->get('request');
  }

190
191
192
  /**
   * Gets the current active user.
   *
193
   * @return \Drupal\Core\Session\AccountProxyInterface
194
195
196
197
198
   */
  public static function currentUser() {
    return static::$container->get('current_user');
  }

199
200
201
  /**
   * Retrieves the entity manager service.
   *
202
   * @return \Drupal\Core\Entity\EntityManagerInterface
203
204
205
   *   The entity manager service.
   */
  public static function entityManager() {
206
    return static::$container->get('entity.manager');
207
208
  }

209
210
211
212
213
214
215
216
217
218
  /**
   * Returns the current primary database.
   *
   * @return \Drupal\Core\Database\Connection
   *   The current active database's master connection.
   */
  public static function database() {
    return static::$container->get('database');
  }

219
220
221
222
223
  /**
   * Returns the requested cache bin.
   *
   * @param string $bin
   *   (optional) The cache bin for which the cache object should be returned,
224
   *   defaults to 'default'.
225
   *
226
   * @return \Drupal\Core\Cache\CacheBackendInterface
227
   *   The cache object associated with the specified bin.
228
229
   *
   * @ingroup cache
230
   */
231
  public static function cache($bin = 'default') {
232
233
234
    return static::$container->get('cache.' . $bin);
  }

235
236
237
238
239
240
241
242
243
244
245
246
247
  /**
   * 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) {
    return static::$container->get('keyvalue.expirable')->get($collection);
  }

248
249
250
251
  /**
   * Returns the locking layer instance.
   *
   * @return \Drupal\Core\Lock\LockBackendInterface
252
253
   *
   * @ingroup lock
254
255
256
257
258
   */
  public static function lock() {
    return static::$container->get('lock');
  }

259
260
261
262
  /**
   * Retrieves a configuration object.
   *
   * This is the main entry point to the configuration API. Calling
263
   * @code \Drupal::config('book.admin') @endcode will return a configuration
264
265
266
267
   * object in which the book module can store its administrative settings.
   *
   * @param string $name
   *   The name of the configuration object to retrieve. The name corresponds to
268
   *   a configuration file. For @code \Drupal::config('book.admin') @endcode, the config
269
270
271
272
273
274
275
276
277
   *   object returned will contain the contents of book.admin configuration file.
   *
   * @return \Drupal\Core\Config\Config
   *   A configuration object.
   */
  public static function config($name) {
    return static::$container->get('config.factory')->get($name);
  }

278
279
280
281
282
283
284
  /**
   * 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.
   *
285
   * @return \Drupal\Core\Config\ConfigFactoryInterface
286
   *   The configuration factory service.
287
288
289
290
291
   */
  public static function configFactory() {
    return static::$container->get('config.factory');
  }

292
293
294
  /**
   * Returns a queue for the given queue name.
   *
295
296
297
298
299
300
301
302
   * 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'.
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
   *
   * @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) {
    return static::$container->get('queue')->get($name, $reliable);
  }

  /**
   * Returns a key/value storage collection.
   *
321
   * @param string $collection
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
   *   Name of the key/value collection to return.
   *
   * @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface
   */
  public static function keyValue($collection) {
    return static::$container->get('keyvalue')->get($collection);
  }

  /**
   * 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
337
   * (for example, the system maintenance message) should use \Drupal::config() instead.
338
   *
339
   * @return \Drupal\Core\State\StateInterface
340
341
342
343
344
345
346
347
   */
  public static function state() {
    return static::$container->get('state');
  }

  /**
   * Returns the default http client.
   *
348
   * @return \GuzzleHttp\ClientInterface
349
350
351
   *   A guzzle http client instance.
   */
  public static function httpClient() {
352
    return static::$container->get('http_client');
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
  }

  /**
   * Returns the entity query object for this entity type.
   *
   * @param string $entity_type
   *   The entity type, e.g. node, for which the query object should be
   *   returned.
   * @param string $conjunction
   *   AND if all conditions in the query need to apply, OR if any of them is
   *   enough. Optional, defaults to AND.
   *
   * @return \Drupal\Core\Entity\Query\QueryInterface
   *   The query object that can query the given entity type.
   */
  public static function entityQuery($entity_type, $conjunction = 'AND') {
    return static::$container->get('entity.query')->get($entity_type, $conjunction);
  }

372
373
374
  /**
   * Returns the entity query aggregate object for this entity type.
   *
375
   * @param string $entity_type
376
377
   *   The entity type, e.g. node, for which the query object should be
   *   returned.
378
   * @param string $conjunction
379
380
381
   *   AND if all conditions in the query need to apply, OR if any of them is
   *   enough. Optional, defaults to AND.
   *
382
   * @return \Drupal\Core\Entity\Query\QueryAggregateInterface
383
384
385
386
387
388
   *   The query object that can query the given entity type.
   */
  public static function entityQueryAggregate($entity_type, $conjunction = 'AND') {
    return static::$container->get('entity.query')->getAggregate($entity_type, $conjunction);
  }

389
390
391
392
393
394
395
396
397
398
399
400
  /**
   * Returns the flood instance.
   *
   * @return \Drupal\Core\Flood\FloodInterface
   */
  public static function flood() {
    return static::$container->get('flood');
  }

  /**
   * Returns the module handler.
   *
401
   * @return \Drupal\Core\Extension\ModuleHandlerInterface
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
   */
  public static function moduleHandler() {
    return static::$container->get('module_handler');
  }

  /**
   * Returns the typed data manager service.
   *
   * Use the typed data manager service for creating typed data objects.
   *
   * @return \Drupal\Core\TypedData\TypedDataManager
   *   The typed data manager.
   *
   * @see \Drupal\Core\TypedData\TypedDataManager::create()
   */
417
418
  public static function typedDataManager() {
    return static::$container->get('typed_data_manager');
419
420
  }

421
422
423
424
425
426
427
428
429
430
  /**
   * Returns the token service.
   *
   * @return \Drupal\Core\Utility\Token
   *   The token service.
   */
  public static function token() {
    return static::$container->get('token');
  }

431
432
433
  /**
   * Returns the url generator service.
   *
434
   * @return \Drupal\Core\Routing\UrlGeneratorInterface
435
436
437
438
   *   The url generator service.
   */
  public static function urlGenerator() {
    return static::$container->get('url_generator');
439
440
  }

441
442
443
444
445
446
447
  /**
   * Generates a URL or path for a specific route based on the given parameters.
   *
   * Parameters that reference placeholders in the route pattern will be
   * substituted for them in the pattern. Extra params are added as query
   * strings to the URL.
   *
448
   * @param string $route_name
449
   *   The name of the route
450
   * @param array $route_parameters
451
452
453
454
455
456
457
458
459
460
461
462
463
   *   An associative array of parameter names and values.
   * @param array $options
   *   (optional) An associative array of additional options, with the following
   *   elements:
   *   - 'query': An array of query key/value-pairs (without any URL-encoding)
   *     to append to the URL. Merged with the parameters array.
   *   - 'fragment': A fragment identifier (named anchor) to append to the URL.
   *     Do not include the leading '#' character.
   *   - 'absolute': Defaults to FALSE. Whether to force the output to be an
   *     absolute link (beginning with http:). Useful for links that will be
   *     displayed outside the site, such as in an RSS feed.
   *   - 'language': An optional language object used to look up the alias
   *     for the URL. If $options['language'] is omitted, the language will be
464
   *     obtained from \Drupal::languageManager()->getCurrentLanguage(Language::TYPE_URL).
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
   *   - 'https': Whether this URL should point to a secure location. If not
   *     defined, the current scheme is used, so the user stays on HTTP or HTTPS
   *     respectively. if mixed mode sessions are permitted, TRUE enforces HTTPS
   *     and FALSE enforces HTTP.
   *
   * @return string
   *   The generated URL for the given route.
   *
   * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException
   *   Thrown when the named route doesn't exist.
   * @throws \Symfony\Component\Routing\Exception\MissingMandatoryParametersException
   *   Thrown when some parameters are missing that are mandatory for the route.
   * @throws \Symfony\Component\Routing\Exception\InvalidParameterException
   *   Thrown when a parameter value for a placeholder is not correct because it
   *   does not match the requirement.
   *
   * @see \Drupal\Core\Routing\UrlGeneratorInterface::generateFromRoute()
   */
483
  public static function url($route_name, $route_parameters = array(), $options = array()) {
484
485
486
    return static::$container->get('url_generator')->generateFromRoute($route_name, $route_parameters, $options);
  }

487
488
489
490
491
492
493
  /**
   * Returns the link generator service.
   *
   * @return \Drupal\Core\Utility\LinkGeneratorInterface
   */
  public static function linkGenerator() {
    return static::$container->get('link_generator');
494
495
496
497
498
499
500
501
502
503
504
505
  }

  /**
   * Renders a link to a route given a route name and its parameters.
   *
   * This function correctly handles aliased paths and sanitizing text, so all
   * internal links output by modules should be generated by this function if
   * possible.
   *
   * However, for links enclosed in translatable text you should use t() and
   * embed the HTML anchor tag directly in the translated string. For example:
   * @code
506
   * t('Visit the <a href="@url">content types</a> page', array('@url' => \Drupal::url('node.overview_types')));
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
   * @endcode
   * This keeps the context of the link title ('settings' in the example) for
   * translators.
   *
   * @param string|array $text
   *   The link text for the anchor tag as a translated string or render array.
   * @param string $route_name
   *   The name of the route to use to generate the link.
   * @param array $parameters
   *   (optional) Any parameters needed to render the route path pattern.
   * @param array $options
   *   (optional) An associative array of additional options. Defaults to an
   *   empty array. It may contain the following elements:
   *   - 'query': An array of query key/value-pairs (without any URL-encoding) to
   *     append to the URL.
   *   - absolute: Whether to force the output to be an absolute link (beginning
   *     with http:). Useful for links that will be displayed outside the site,
   *     such as in an RSS feed. Defaults to FALSE.
   *   - attributes: An associative array of HTML attributes to apply to the
   *     anchor tag. If element 'class' is included, it must be an array; 'title'
   *     must be a string; other elements are more flexible, as they just need
   *     to work as an argument for the constructor of the class
   *     Drupal\Core\Template\Attribute($options['attributes']).
   *   - html: Whether $text is HTML or just plain-text. For
   *     example, to make an image tag into a link, this must be set to TRUE, or
   *     you will see the escaped HTML image tag. $text is not sanitized if
   *     'html' is TRUE. The calling function must ensure that $text is already
   *     safe. Defaults to FALSE.
   *   - language: An optional language object. If the path being linked to is
   *     internal to the site, $options['language'] is used to determine whether
   *     the link is "active", or pointing to the current page (the language as
   *     well as the path must match).
   *
   * @return string
   *   An HTML string containing a link to the given route and parameters.
   *
   * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException
   *   Thrown when the named route doesn't exist.
   * @throws \Symfony\Component\Routing\Exception\MissingMandatoryParametersException
   *   Thrown when some parameters are missing that are mandatory for the route.
   * @throws \Symfony\Component\Routing\Exception\InvalidParameterException
   *   Thrown when a parameter value for a placeholder is not correct because it
   *   does not match the requirement.
   *
   * @see \Drupal\Core\Routing\UrlGeneratorInterface::generateFromRoute()
   * @see \Drupal\Core\Utility\LinkGeneratorInterface::generate()
   */
554
  public static function l($text, $route_name, array $parameters = array(), array $options = array()) {
555
    return static::$container->get('link_generator')->generate($text, $route_name, $parameters, $options);
556
557
  }

558
559
560
  /**
   * Returns the string translation service.
   *
561
   * @return \Drupal\Core\StringTranslation\TranslationManager
562
563
564
565
566
567
   *   The string translation manager.
   */
  public static function translation() {
    return static::$container->get('string_translation');
  }

568
569
570
  /**
   * Returns the language manager service.
   *
571
   * @return \Drupal\Core\Language\LanguageManagerInterface
572
573
574
575
576
577
   *   The language manager.
   */
  public static function languageManager() {
    return static::$container->get('language_manager');
  }

578
579
580
  /**
   * Returns the CSRF token manager service.
   *
581
582
583
584
585
   * 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.
   *
586
587
   * @return \Drupal\Core\Access\CsrfTokenGenerator
   *   The CSRF token manager.
588
   *
589
   * @see \Drupal\Core\Session\SessionManager::start()
590
591
592
593
594
   */
  public static function csrfToken() {
    return static::$container->get('csrf_token');
  }

595
596
597
598
599
600
601
602
603
604
  /**
   * Returns the transliteration service.
   *
   * @return \Drupal\Core\Transliteration\PHPTransliteration
   *   The transliteration manager.
   */
  public static function transliteration() {
    return static::$container->get('transliteration');
  }

605
606
607
608
609
610
611
612
613
614
  /**
   * Returns the form builder service.
   *
   * @return \Drupal\Core\Form\FormBuilderInterface
   *   The form builder.
   */
  public static function formBuilder() {
    return static::$container->get('form_builder');
  }

615
616
617
618
619
620
  /**
   * Gets the syncing state.
   *
   * @return bool
   *   Returns TRUE is syncing flag set.
   */
621
  public static function isConfigSyncing() {
622
623
624
    return static::$container->get('config.installer')->isSyncing();
  }

625
626
627
628
629
630
631
632
633
634
635
636
637
638
  /**
   * 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.
   *
   * @return \Drupal\Core\Logger\LoggerChannelInterface
   *   The logger for this channel.
   */
  public static function logger($channel) {
    return static::$container->get('logger.factory')->get($channel);
  }

639
}