Newer
Older
<?php
Alex Pott
committed
use Drupal\Core\DependencyInjection\ContainerNotInitializedException;
Lee Rowlands
committed
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
* \Drupal\Core\CoreServiceProvider, the service providers of enabled modules and any other
* service providers defined in $GLOBALS['conf']['container_service_providers'].
*
* 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() {
* $lock = \Drupal::lock()->acquire('stuff_lock');
* // ...
* }
*
* // The preferred way: dependency injected code.
* function hook_do_stuff() {
* // Move the actual implementation to a class and instantiate it.
* $instance = new StuffDoingClass(\Drupal::lock());
* $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.
* \Drupal::service('stuff.doing')->doStuff();
* }
*
* interface StuffDoingInterface {
* public function doStuff();
* }
*
* class StuffDoingClass implements StuffDoingInterface {
* protected $lockBackend;
*
* public function __construct(LockBackendInterface $lock_backend) {
* $this->lockBackend = $lock_backend;
* }
*
* public function doStuff() {
* $lock = $this->lockBackend->acquire('stuff_lock');
* // ...
* }
* }
* @endcode
*
* @see \Drupal\Core\DrupalKernel
*/
class Drupal {
catch
committed
/**
* The current system version.
*/
catch
committed
/**
* Core API compatibility.
*/
const CORE_COMPATIBILITY = '8.x';
Angie Byron
committed
/**
* Core minimum schema version.
*/
const CORE_MINIMUM_SCHEMA_VERSION = 8000;
/**
* Minimum supported version of PHP.
*
Lee Rowlands
committed
* @deprecated in drupal:9.4.0 and is removed from drupal:10.0.0. Use
* \Drupal\Core\Utility\PhpRequirements::getMinimumSupportedPhp() instead.
*
* @see https://www.drupal.org/node/3261451
*/
const MINIMUM_SUPPORTED_PHP = '7.4.0';
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
/**
* 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.
*/
catch
committed
const RECOMMENDED_PHP = '8.0';
/**
* The currently active container object, or NULL if not initialized yet.
*
* @var \Symfony\Component\DependencyInjection\ContainerInterface|null
*/
protected static $container;
/**
* Sets a new global container.
*
* @param \Symfony\Component\DependencyInjection\ContainerInterface $container
Alex Pott
committed
* A new container instance to replace the current.
*/
Alex Pott
committed
public static function setContainer(ContainerInterface $container) {
static::$container = $container;
}
Alex Pott
committed
/**
* Unsets the global container.
*/
public static function unsetContainer() {
static::$container = NULL;
}
/**
* Returns the currently active global container.
*
* @return \Symfony\Component\DependencyInjection\ContainerInterface
*
* @throws \Drupal\Core\DependencyInjection\ContainerNotInitializedException
*/
public static function getContainer() {
Alex Pott
committed
if (static::$container === NULL) {
throw new ContainerNotInitializedException('\Drupal::$container is not initialized yet. \Drupal::setContainer() must be called with a real container.');
}
return static::$container;
}
/**
* Returns TRUE if the container has been initialized, FALSE otherwise.
*
* @return bool
*/
public static function hasContainer() {
return static::$container !== NULL;
}
/**
* 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) {
Alex Pott
committed
return static::getContainer()->get($id);
}
/**
* 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) {
// Check hasContainer() first in order to always return a Boolean.
return static::hasContainer() && static::getContainer()->has($id);
/**
* Gets the app root.
*
* @return string
*/
public static function root() {
return static::getContainer()->getParameter('app.root');
}
/**
* 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');
}
/**
* 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() {
// 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;
}
/**
* Retrieves the currently active request object.
*
* Note: The use of this wrapper in particular is especially discouraged. Most
* 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() {
Alex Pott
committed
return static::getContainer()->get('request_stack')->getCurrentRequest();
}
Angie Byron
committed
/**
Alex Pott
committed
* Retrieves the request stack.
Angie Byron
committed
*
* @return \Symfony\Component\HttpFoundation\RequestStack
* The request stack
*/
public static function requestStack() {
Alex Pott
committed
return static::getContainer()->get('request_stack');
Angie Byron
committed
}
/**
* Retrieves the currently active route match object.
*
* @return \Drupal\Core\Routing\RouteMatchInterface
* The currently active route match object.
*/
public static function routeMatch() {
Alex Pott
committed
return static::getContainer()->get('current_route_match');
}
/**
* Gets the current active user.
*
* 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
*
* @return \Drupal\Core\Session\AccountProxyInterface
*/
public static function currentUser() {
Alex Pott
committed
return static::getContainer()->get('current_user');
}
Alex Pott
committed
/**
* 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');
}
/**
* Returns the current primary database.
*
* @return \Drupal\Core\Database\Connection
* The current active database's master connection.
*/
public static function database() {
Alex Pott
committed
return static::getContainer()->get('database');
}
/**
* Returns the requested cache bin.
*
* @param string $bin
* (optional) The cache bin for which the cache object should be returned,
catch
committed
* defaults to 'default'.
* @return \Drupal\Core\Cache\CacheBackendInterface
* The cache object associated with the specified bin.
Angie Byron
committed
*
* @ingroup cache
catch
committed
public static function cache($bin = 'default') {
Alex Pott
committed
return static::getContainer()->get('cache.' . $bin);
}
/**
* 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.
*
* @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.
*/
public static function classResolver($class = NULL) {
if ($class) {
return static::getContainer()->get('class_resolver')->getInstanceFromDefinition($class);
}
return static::getContainer()->get('class_resolver');
}
/**
* 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) {
Alex Pott
committed
return static::getContainer()->get('keyvalue.expirable')->get($collection);
}
/**
* Returns the locking layer instance.
*
* @return \Drupal\Core\Lock\LockBackendInterface
*
* @ingroup lock
*/
public static function lock() {
Alex Pott
committed
return static::getContainer()->get('lock');
}
/**
* Retrieves a configuration object.
*
* This is the main entry point to the configuration API. Calling
Angie Byron
committed
* @code \Drupal::config('book.admin') @endcode will return a configuration
* object the Book module can use to read its administrative settings.
*
* @param string $name
* 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.
*
* @return \Drupal\Core\Config\ImmutableConfig
* An immutable configuration object.
*/
public static function config($name) {
Alex Pott
committed
return static::getContainer()->get('config.factory')->get($name);
}
/**
* 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.
*
Alex Pott
committed
* @return \Drupal\Core\Config\ConfigFactoryInterface
* The configuration factory service.
*/
public static function configFactory() {
Alex Pott
committed
return static::getContainer()->get('config.factory');
}
/**
* Returns a queue for the given queue name.
*
* 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'.
*
* @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) {
Alex Pott
committed
return static::getContainer()->get('queue')->get($name, $reliable);
}
/**
* Returns a key/value storage collection.
*
Alex Pott
committed
* @param string $collection
* Name of the key/value collection to return.
*
* @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface
*/
public static function keyValue($collection) {
Alex Pott
committed
return static::getContainer()->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
Angie Byron
committed
* (for example, the system maintenance message) should use \Drupal::config() instead.
*
Alex Pott
committed
* @return \Drupal\Core\State\StateInterface
*/
public static function state() {
Alex Pott
committed
return static::getContainer()->get('state');
}
/**
* Returns the default http client.
*
* @return \GuzzleHttp\Client
* A guzzle http client instance.
*/
public static function httpClient() {
Alex Pott
committed
return static::getContainer()->get('http_client');
}
/**
* Returns the entity query object for this entity type.
*
* @param string $entity_type
Jennifer Hodgdon
committed
* The entity type (for example, node) for which the query object should be
* returned.
* @param string $conjunction
Jennifer Hodgdon
committed
* (optional) Either 'AND' if all conditions in the query need to apply, or
* 'OR' if any of them is sufficient. 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::entityTypeManager()->getStorage($entity_type)->getQuery($conjunction);
}
Alex Pott
committed
/**
* Returns the entity query aggregate object for this entity type.
*
Alex Pott
committed
* @param string $entity_type
Jennifer Hodgdon
committed
* The entity type (for example, node) for which the query object should be
Alex Pott
committed
* returned.
Alex Pott
committed
* @param string $conjunction
Jennifer Hodgdon
committed
* (optional) Either 'AND' if all conditions in the query need to apply, or
* 'OR' if any of them is sufficient. Defaults to 'AND'.
Alex Pott
committed
*
Angie Byron
committed
* @return \Drupal\Core\Entity\Query\QueryAggregateInterface
Alex Pott
committed
* The query object that can query the given entity type.
*/
public static function entityQueryAggregate($entity_type, $conjunction = 'AND') {
return static::entityTypeManager()->getStorage($entity_type)->getAggregateQuery($conjunction);
Alex Pott
committed
}
/**
* Returns the flood instance.
*
* @return \Drupal\Core\Flood\FloodInterface
*/
public static function flood() {
Alex Pott
committed
return static::getContainer()->get('flood');
}
/**
* Returns the module handler.
*
Alex Pott
committed
* @return \Drupal\Core\Extension\ModuleHandlerInterface
*/
public static function moduleHandler() {
Alex Pott
committed
return static::getContainer()->get('module_handler');
}
/**
* Returns the typed data manager service.
*
* Use the typed data manager service for creating typed data objects.
*
Alex Bronstein
committed
* @return \Drupal\Core\TypedData\TypedDataManagerInterface
* The typed data manager.
*
* @see \Drupal\Core\TypedData\TypedDataManager::create()
*/
public static function typedDataManager() {
Alex Pott
committed
return static::getContainer()->get('typed_data_manager');
}
/**
* Returns the token service.
*
* @return \Drupal\Core\Utility\Token
* The token service.
*/
public static function token() {
Alex Pott
committed
return static::getContainer()->get('token');
/**
* Returns the url generator service.
*
Angie Byron
committed
* @return \Drupal\Core\Routing\UrlGeneratorInterface
* The url generator service.
*/
public static function urlGenerator() {
Alex Pott
committed
return static::getContainer()->get('url_generator');
}
/**
* Returns the link generator service.
*
* @return \Drupal\Core\Utility\LinkGeneratorInterface
*/
public static function linkGenerator() {
Alex Pott
committed
return static::getContainer()->get('link_generator');
}
/**
* Returns the string translation service.
*
Jennifer Hodgdon
committed
* @return \Drupal\Core\StringTranslation\TranslationManager
* The string translation manager.
*/
public static function translation() {
Alex Pott
committed
return static::getContainer()->get('string_translation');
/**
* Returns the language manager service.
*
* @return \Drupal\Core\Language\LanguageManagerInterface
* The language manager.
*/
public static function languageManager() {
Alex Pott
committed
return static::getContainer()->get('language_manager');
}
/**
* Returns the CSRF token manager service.
*
Jennifer Hodgdon
committed
* 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.
*
* @return \Drupal\Core\Access\CsrfTokenGenerator
* The CSRF token manager.
Jennifer Hodgdon
committed
*
* @see \Drupal\Core\Session\SessionManager::start()
*/
public static function csrfToken() {
Alex Pott
committed
return static::getContainer()->get('csrf_token');
}
/**
* Returns the transliteration service.
*
* @return \Drupal\Core\Transliteration\PhpTransliteration
* The transliteration manager.
*/
public static function transliteration() {
Alex Pott
committed
return static::getContainer()->get('transliteration');
}
Alex Pott
committed
/**
* Returns the form builder service.
*
* @return \Drupal\Core\Form\FormBuilderInterface
* The form builder.
*/
public static function formBuilder() {
Alex Pott
committed
return static::getContainer()->get('form_builder');
Alex Pott
committed
}
/**
* Gets the theme service.
*
* @return \Drupal\Core\Theme\ThemeManagerInterface
*/
public static function theme() {
Alex Pott
committed
return static::getContainer()->get('theme.manager');
/**
* Gets the syncing state.
*
* @return bool
* Returns TRUE is syncing flag set.
*/
public static function isConfigSyncing() {
Alex Pott
committed
return static::getContainer()->get('config.installer')->isSyncing();
}
/**
* 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 \Psr\Log\LoggerInterface
* The logger for this channel.
*/
public static function logger($channel) {
Alex Pott
committed
return static::getContainer()->get('logger.factory')->get($channel);
}
/**
* Returns the menu tree.
*
* @return \Drupal\Core\Menu\MenuLinkTreeInterface
* The menu tree.
*/
public static function menuTree() {
Alex Pott
committed
return static::getContainer()->get('menu.link_tree');
}
Angie Byron
committed
/**
* Returns the path validator.
*
* @return \Drupal\Core\Path\PathValidatorInterface
*/
public static function pathValidator() {
Alex Pott
committed
return static::getContainer()->get('path.validator');
Angie Byron
committed
}
Alex Pott
committed
/**
* Returns the access manager service.
*
* @return \Drupal\Core\Access\AccessManagerInterface
* The access manager service.
*/
public static function accessManager() {
Alex Pott
committed
return static::getContainer()->get('access_manager');
Alex Pott
committed
}
/**
* Returns the redirect destination helper.
*
* @return \Drupal\Core\Routing\RedirectDestinationInterface
* The redirect destination helper.
*/
public static function destination() {
return static::getContainer()->get('redirect.destination');
}
Alex Bronstein
committed
/**
* 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');
}
/**
* Returns the time service.
*
* @return \Drupal\Component\Datetime\TimeInterface
* The time service.
*/
public static function time() {
return static::getContainer()->get('datetime.time');
}
Lee Rowlands
committed
/**
* Returns the messenger.
*
* @return \Drupal\Core\Messenger\MessengerInterface
* The messenger.
*/
public static function messenger() {
return static::getContainer()->get('messenger');
Lee Rowlands
committed
}