install.inc
Same filename in other branches
API functions for installing modules and themes.
File
-
core/
includes/ install.inc
View source
<?php
/**
* @file
* API functions for installing modules and themes.
*/
use Drupal\Component\Utility\Unicode;
use Drupal\Component\Utility\UrlHelper;
use Drupal\Core\Database\Database;
use Drupal\Core\Extension\Dependency;
use Drupal\Core\Extension\ExtensionDiscovery;
use Drupal\Core\Installer\InstallerKernel;
use Symfony\Component\HttpFoundation\RedirectResponse;
/**
* Requirement severity -- Informational message only.
*/
const REQUIREMENT_INFO = -1;
/**
* Requirement severity -- Requirement successfully met.
*/
const REQUIREMENT_OK = 0;
/**
* Requirement severity -- Warning condition; proceed but flag warning.
*/
const REQUIREMENT_WARNING = 1;
/**
* Requirement severity -- Error condition; abort installation.
*/
const REQUIREMENT_ERROR = 2;
/**
* File permission check -- File exists.
*/
const FILE_EXIST = 1;
/**
* File permission check -- File is readable.
*/
const FILE_READABLE = 2;
/**
* File permission check -- File is writable.
*/
const FILE_WRITABLE = 4;
/**
* File permission check -- File is executable.
*/
const FILE_EXECUTABLE = 8;
/**
* File permission check -- File does not exist.
*/
const FILE_NOT_EXIST = 16;
/**
* File permission check -- File is not readable.
*/
const FILE_NOT_READABLE = 32;
/**
* File permission check -- File is not writable.
*/
const FILE_NOT_WRITABLE = 64;
/**
* File permission check -- File is not executable.
*/
const FILE_NOT_EXECUTABLE = 128;
/**
* Loads .install files for installed modules to initialize the update system.
*/
function drupal_load_updates() {
/** @var \Drupal\Core\Extension\ModuleExtensionList $extension_list_module */
$extension_list_module = \Drupal::service('extension.list.module');
foreach (\Drupal::service('update.update_hook_registry')->getAllInstalledVersions() as $module => $schema_version) {
if ($extension_list_module->exists($module) && !$extension_list_module->checkIncompatibility($module)) {
if ($schema_version > -1) {
\Drupal::moduleHandler()->loadInclude($module, 'install');
}
}
}
}
/**
* Loads the installation profile, extracting its defined distribution name.
*
* @return string
* The distribution name defined in the profile's .info.yml file. Defaults to
* "Drupal" if none is explicitly provided by the installation profile.
*
* @see install_profile_info()
*/
function drupal_install_profile_distribution_name() {
// During installation, the profile information is stored in the global
// installation state (it might not be saved anywhere yet).
$info = [];
if (InstallerKernel::installationAttempted()) {
global $install_state;
if (isset($install_state['profile_info'])) {
$info = $install_state['profile_info'];
}
}
elseif ($profile = \Drupal::installProfile()) {
$info = \Drupal::service('extension.list.profile')->getExtensionInfo($profile);
}
return $info['distribution']['name'] ?? 'Drupal';
}
/**
* Loads the installation profile, extracting its defined version.
*
* @return string
* Distribution version defined in the profile's .info.yml file.
* Defaults to \Drupal::VERSION if no version is explicitly provided by the
* installation profile.
*
* @see install_profile_info()
*/
function drupal_install_profile_distribution_version() {
// During installation, the profile information is stored in the global
// installation state (it might not be saved anywhere yet).
if (InstallerKernel::installationAttempted()) {
global $install_state;
return $install_state['profile_info']['version'] ?? \Drupal::VERSION;
}
else {
$profile = \Drupal::installProfile();
$info = \Drupal::service('extension.list.profile')->getExtensionInfo($profile);
return $info['version'];
}
}
/**
* Verifies that all dependencies are met for a given installation profile.
*
* @param $install_state
* An array of information about the current installation state.
*
* @return array
* The list of modules to install.
*
* @todo https://www.drupal.org/i/3005959 Rework this method as it is not only
* about profiles.
*/
function drupal_verify_profile($install_state) {
$profile = $install_state['parameters']['profile'];
if ($profile === FALSE) {
return [];
}
$info = $install_state['profile_info'];
// Get the list of available modules for the selected installation profile.
$listing = new ExtensionDiscovery(\Drupal::root());
$present_modules = [];
foreach ($listing->scan('module') as $present_module) {
$present_modules[] = $present_module->getName();
}
// The installation profile is also a module, which needs to be installed
// after all the other dependencies have been installed.
$present_modules[] = $profile;
// Verify that all of the profile's required modules are present.
$missing_modules = array_diff($info['install'], $present_modules);
$requirements = [];
if ($missing_modules) {
$build = [
'#theme' => 'item_list',
'#context' => [
'list_style' => 'comma-list',
],
];
foreach ($missing_modules as $module) {
$build['#items'][] = [
'#markup' => '<span class="admin-missing">' . Unicode::ucfirst($module) . '</span>',
];
}
$modules_list = \Drupal::service('renderer')->renderInIsolation($build);
$requirements['required_modules'] = [
'title' => t('Required modules'),
'value' => t('Required modules not found.'),
'severity' => REQUIREMENT_ERROR,
'description' => t('The following modules are required but were not found. Move them into the appropriate modules subdirectory, such as <em>/modules</em>. Missing modules: @modules', [
'@modules' => $modules_list,
]),
];
}
return $requirements;
}
/**
* Installs the system module.
*
* Separated from the installation of other modules so core system
* functions can be made available while other modules are installed.
*
* @param array $install_state
* An array of information about the current installation state. This is used
* to set the default language.
*/
function drupal_install_system($install_state) {
// Remove the service provider of the early installer.
unset($GLOBALS['conf']['container_service_providers']['InstallerServiceProvider']);
// Add the normal installer service provider.
$GLOBALS['conf']['container_service_providers']['InstallerServiceProvider'] = 'Drupal\\Core\\Installer\\NormalInstallerServiceProvider';
// Get the existing request.
$request = \Drupal::request();
// Reboot into a full production environment to continue the installation.
/** @var \Drupal\Core\Installer\InstallerKernel $kernel */
$kernel = \Drupal::service('kernel');
$kernel->shutdown();
// Have installer rebuild from the disk, rather then building from scratch.
$kernel->rebuildContainer();
// Reboot the kernel with new container.
$kernel->boot();
$kernel->preHandle($request);
// Ensure our request includes the session if appropriate.
if (PHP_SAPI !== 'cli') {
$request->setSession($kernel->getContainer()
->get('session'));
}
// Before having installed the system module and being able to do a module
// rebuild, prime the \Drupal\Core\Extension\ModuleExtensionList static cache
// with the module's location.
// @todo Try to install system as any other module, see
// https://www.drupal.org/node/2719315.
\Drupal::service('extension.list.module')->setPathname('system', 'core/modules/system/system.info.yml');
// Install base system configuration.
\Drupal::service('config.installer')->installDefaultConfig('core', 'core');
// Store the installation profile in configuration to populate the
// 'install_profile' container parameter.
$config = \Drupal::configFactory()->getEditable('core.extension');
if ($install_state['parameters']['profile'] === FALSE) {
$config->clear('profile');
}
else {
$config->set('profile', $install_state['parameters']['profile']);
}
$config->save();
$connection = Database::getConnection();
$provider = $connection->getProvider();
// When the database driver is provided by a module, then install that module.
// This module must be installed before any other module, as it must be able
// to override any call to hook_schema() or any "backend_overridable" service.
// In edge cases, a driver module may extend from another driver module (for
// instance, a module to provide backward compatibility with a database
// version no longer supported by core). In order for the extended classes to
// be autoloadable, the extending module should list the extended module in
// its dependencies, and here the dependencies will be installed as well.
if ($provider !== 'core') {
$autoload = $connection->getConnectionOptions()['autoload'] ?? '';
if (str_contains($autoload, 'src/Driver/Database/')) {
$kernel->getContainer()
->get('module_installer')
->install([
$provider,
], TRUE);
}
}
// Install System module.
$kernel->getContainer()
->get('module_installer')
->install([
'system',
], FALSE);
// Ensure default language is saved.
if (isset($install_state['parameters']['langcode'])) {
\Drupal::configFactory()->getEditable('system.site')
->set('langcode', (string) $install_state['parameters']['langcode'])
->set('default_langcode', (string) $install_state['parameters']['langcode'])
->save(TRUE);
}
}
/**
* Verifies the state of the specified file.
*
* @param $file
* The file to check for.
* @param $mask
* An optional bitmask created from various FILE_* constants.
* @param $type
* The type of file. Can be file (default), dir, or link.
* @param bool $auto_fix
* (optional) Determines whether to attempt fixing the permissions according
* to the provided $mask. Defaults to TRUE.
*
* @return bool
* TRUE on success or FALSE on failure. A message is set for the latter.
*/
function drupal_verify_install_file($file, $mask = NULL, $type = 'file', $auto_fix = TRUE) {
$return = TRUE;
// Check for files that shouldn't be there.
if (isset($mask) && $mask & FILE_NOT_EXIST && file_exists($file)) {
return FALSE;
}
// Verify that the file is the type of file it is supposed to be.
if (isset($type) && file_exists($file)) {
$check = 'is_' . $type;
if (!function_exists($check) || !$check($file)) {
$return = FALSE;
}
}
// Verify file permissions.
if (isset($mask)) {
$masks = [
FILE_EXIST,
FILE_READABLE,
FILE_WRITABLE,
FILE_EXECUTABLE,
FILE_NOT_READABLE,
FILE_NOT_WRITABLE,
FILE_NOT_EXECUTABLE,
];
foreach ($masks as $current_mask) {
if ($mask & $current_mask) {
switch ($current_mask) {
case FILE_EXIST:
if (!file_exists($file)) {
if ($type == 'dir' && $auto_fix) {
drupal_install_mkdir($file, $mask);
}
if (!file_exists($file)) {
$return = FALSE;
}
}
break;
case FILE_READABLE:
if (!is_readable($file)) {
$return = FALSE;
}
break;
case FILE_WRITABLE:
if (!is_writable($file)) {
$return = FALSE;
}
break;
case FILE_EXECUTABLE:
if (!is_executable($file)) {
$return = FALSE;
}
break;
case FILE_NOT_READABLE:
if (is_readable($file)) {
$return = FALSE;
}
break;
case FILE_NOT_WRITABLE:
if (is_writable($file)) {
$return = FALSE;
}
break;
case FILE_NOT_EXECUTABLE:
if (is_executable($file)) {
$return = FALSE;
}
break;
}
}
}
}
if (!$return && $auto_fix) {
return drupal_install_fix_file($file, $mask);
}
return $return;
}
/**
* Creates a directory with the specified permissions.
*
* @param $file
* The name of the directory to create;
* @param $mask
* The permissions of the directory to create.
* @param $message
* (optional) Whether to output messages. Defaults to TRUE.
*
* @return bool
* TRUE/FALSE whether or not the directory was successfully created.
*/
function drupal_install_mkdir($file, $mask, $message = TRUE) {
$mod = 0;
$masks = [
FILE_READABLE,
FILE_WRITABLE,
FILE_EXECUTABLE,
FILE_NOT_READABLE,
FILE_NOT_WRITABLE,
FILE_NOT_EXECUTABLE,
];
foreach ($masks as $m) {
if ($mask & $m) {
switch ($m) {
case FILE_READABLE:
$mod |= 0444;
break;
case FILE_WRITABLE:
$mod |= 0222;
break;
case FILE_EXECUTABLE:
$mod |= 0111;
break;
}
}
}
if (@\Drupal::service('file_system')->mkdir($file, $mod)) {
return TRUE;
}
else {
return FALSE;
}
}
/**
* Attempts to fix file permissions.
*
* The general approach here is that, because we do not know the security
* setup of the webserver, we apply our permission changes to all three
* digits of the file permission (i.e. user, group and all).
*
* To ensure that the values behave as expected (and numbers don't carry
* from one digit to the next) we do the calculation on the octal value
* using bitwise operations. This lets us remove, for example, 0222 from
* 0700 and get the correct value of 0500.
*
* @param $file
* The name of the file with permissions to fix.
* @param $mask
* The desired permissions for the file.
* @param $message
* (optional) Whether to output messages. Defaults to TRUE.
*
* @return bool
* TRUE/FALSE whether or not we were able to fix the file's permissions.
*/
function drupal_install_fix_file($file, $mask, $message = TRUE) {
// If $file does not exist, fileperms() issues a PHP warning.
if (!file_exists($file)) {
return FALSE;
}
$mod = fileperms($file) & 0777;
$masks = [
FILE_READABLE,
FILE_WRITABLE,
FILE_EXECUTABLE,
FILE_NOT_READABLE,
FILE_NOT_WRITABLE,
FILE_NOT_EXECUTABLE,
];
// FILE_READABLE, FILE_WRITABLE, and FILE_EXECUTABLE permission strings
// can theoretically be 0400, 0200, and 0100 respectively, but to be safe
// we set all three access types in case the administrator intends to
// change the owner of settings.php after installation.
foreach ($masks as $m) {
if ($mask & $m) {
switch ($m) {
case FILE_READABLE:
if (!is_readable($file)) {
$mod |= 0444;
}
break;
case FILE_WRITABLE:
if (!is_writable($file)) {
$mod |= 0222;
}
break;
case FILE_EXECUTABLE:
if (!is_executable($file)) {
$mod |= 0111;
}
break;
case FILE_NOT_READABLE:
if (is_readable($file)) {
$mod &= ~0444;
}
break;
case FILE_NOT_WRITABLE:
if (is_writable($file)) {
$mod &= ~0222;
}
break;
case FILE_NOT_EXECUTABLE:
if (is_executable($file)) {
$mod &= ~0111;
}
break;
}
}
}
// chmod() will work if the web server is running as owner of the file.
if (@chmod($file, $mod)) {
return TRUE;
}
else {
return FALSE;
}
}
/**
* Sends the user to a different installer page.
*
* This issues an on-site HTTP redirect. Messages (and errors) are erased.
*
* @param $path
* An installer path.
*/
function install_goto($path) {
global $base_url;
$headers = [
// Not a permanent redirect.
'Cache-Control' => 'no-cache',
];
$response = new RedirectResponse($base_url . '/' . $path, 302, $headers);
$response->send();
}
/**
* Returns the URL of the current script, with modified query parameters.
*
* This function can be called by low-level scripts (such as install.php and
* update.php) and returns the URL of the current script. Existing query
* parameters are preserved by default, but new ones can optionally be merged
* in.
*
* This function is used when the script must maintain certain query parameters
* over multiple page requests in order to work correctly. In such cases (for
* example, update.php, which requires the 'continue=1' parameter to remain in
* the URL throughout the update process if there are any requirement warnings
* that need to be bypassed), using this function to generate the URL for links
* to the next steps of the script ensures that the links will work correctly.
*
* @param $query
* (optional) An array of query parameters to merge in to the existing ones.
*
* @return string
* The URL of the current script, with query parameters modified by the
* passed-in $query. The URL is not sanitized, so it still needs to be run
* through \Drupal\Component\Utility\UrlHelper::filterBadProtocol() if it will be
* used as an HTML attribute value.
*
* @see drupal_requirements_url()
* @see Drupal\Component\Utility\UrlHelper::filterBadProtocol()
*/
function drupal_current_script_url($query = []) {
$uri = $_SERVER['SCRIPT_NAME'];
$query = array_merge(UrlHelper::filterQueryParameters(\Drupal::request()->query
->all()), $query);
if (!empty($query)) {
$uri .= '?' . UrlHelper::buildQuery($query);
}
return $uri;
}
/**
* Returns a URL for proceeding to the next page after a requirements problem.
*
* This function can be called by low-level scripts (such as install.php and
* update.php) and returns a URL that can be used to attempt to proceed to the
* next step of the script.
*
* @param $severity
* The severity of the requirements problem, as returned by
* drupal_requirements_severity().
*
* @return string
* A URL for attempting to proceed to the next step of the script. The URL is
* not sanitized, so it still needs to be run through
* \Drupal\Component\Utility\UrlHelper::filterBadProtocol() if it will be used
* as an HTML attribute value.
*
* @see drupal_current_script_url()
* @see \Drupal\Component\Utility\UrlHelper::filterBadProtocol()
*/
function drupal_requirements_url($severity) {
$query = [];
// If there are no errors, only warnings, append 'continue=1' to the URL so
// the user can bypass this screen on the next page load.
if ($severity == REQUIREMENT_WARNING) {
$query['continue'] = 1;
}
return drupal_current_script_url($query);
}
/**
* Checks an installation profile's requirements.
*
* @param string $profile
* Name of installation profile to check.
*
* @return array
* Array of the installation profile's requirements.
*/
function drupal_check_profile($profile) {
$info = install_profile_info($profile);
// Collect requirement testing results.
$requirements = [];
// Performs an ExtensionDiscovery scan as the system module is unavailable and
// we don't yet know where all the modules are located.
// @todo Remove as part of https://www.drupal.org/node/2186491
$drupal_root = \Drupal::root();
$module_list = (new ExtensionDiscovery($drupal_root))->scan('module');
foreach ($info['install'] as $module) {
// If the module is in the module list we know it exists and we can continue
// including and registering it.
// @see \Drupal\Core\Extension\ExtensionDiscovery::scanDirectory()
if (isset($module_list[$module])) {
$function = $module . '_requirements';
$module_path = $module_list[$module]->getPath();
$install_file = "{$drupal_root}/{$module_path}/{$module}.install";
if (is_file($install_file)) {
require_once $install_file;
}
\Drupal::service('class_loader')->addPsr4('Drupal\\' . $module . '\\', \Drupal::root() . "/{$module_path}/src");
if (function_exists($function)) {
$requirements = array_merge($requirements, $function('install'));
}
}
}
// Add the profile requirements.
$function = $profile . '_requirements';
if (function_exists($function)) {
$requirements = array_merge($requirements, $function('install'));
}
return $requirements;
}
/**
* Extracts the highest severity from the requirements array.
*
* @param $requirements
* An array of requirements, in the same format as is returned by
* hook_requirements().
*
* @return int
* The highest severity in the array.
*/
function drupal_requirements_severity(&$requirements) {
$severity = REQUIREMENT_OK;
foreach ($requirements as $requirement) {
if (isset($requirement['severity'])) {
$severity = max($severity, $requirement['severity']);
}
}
return $severity;
}
/**
* Checks a module's requirements.
*
* @param $module
* Machine name of module to check.
*
* @return bool
* TRUE or FALSE, depending on whether the requirements are met.
*/
function drupal_check_module($module) {
/** @var \Drupal\Core\Extension\ModuleExtensionList $module_list */
$module_list = \Drupal::service('extension.list.module');
$file = DRUPAL_ROOT . '/' . $module_list->getPath($module) . "/{$module}.install";
if (is_file($file)) {
require_once $file;
}
// Check requirements
$requirements = \Drupal::moduleHandler()->invoke($module, 'requirements', [
'install',
]);
if (is_array($requirements) && drupal_requirements_severity($requirements) == REQUIREMENT_ERROR) {
// Print any error messages
foreach ($requirements as $requirement) {
if (isset($requirement['severity']) && $requirement['severity'] == REQUIREMENT_ERROR) {
$message = $requirement['description'];
if (isset($requirement['value']) && $requirement['value']) {
$message = t('@requirements_message (Currently using @item version @version)', [
'@requirements_message' => $requirement['description'],
'@item' => $requirement['title'],
'@version' => $requirement['value'],
]);
}
\Drupal::messenger()->addError($message);
}
}
return FALSE;
}
return TRUE;
}
/**
* Retrieves information about an installation profile from its .info.yml file.
*
* The information stored in a profile .info.yml file is similar to that stored
* in a normal Drupal module .info.yml file. For example:
* - name: The real name of the installation profile for display purposes.
* - description: A brief description of the profile.
* - dependencies: An array of short names of other modules that this install
* profile requires.
* - install: An array of shortname of other modules to install that are not
* required by this install profile.
*
* Additional, less commonly-used information that can appear in a
* profile.info.yml file but not in a normal Drupal module .info.yml file
* includes:
*
* - distribution: Existence of this key denotes that the installation profile
* is intended to be the only eligible choice in a distribution and will be
* auto-selected during installation, whereas the installation profile
* selection screen will be skipped. If more than one distribution profile is
* found then the first one discovered will be selected.
* The following subproperties may be set:
* - name: The name of the distribution that is being installed, to be shown
* throughout the installation process. If omitted,
* drupal_install_profile_distribution_name() defaults to 'Drupal'.
* - install: Optional parameters to override the installer:
* - theme: The machine name of a theme to use in the installer instead of
* Drupal's default installer theme.
* - finish_url: A destination to visit after the installation of the
* distribution is finished
*
* Note that this function does an expensive file system scan to get info file
* information for dependencies. If you only need information from the info
* file itself, use
* \Drupal::service('extension.list.profile')->getExtensionInfo().
*
* Example of .info.yml file:
* @code
* name: Minimal
* description: Start fresh, with only a few modules enabled.
* install:
* - block
* - dblog
* @endcode
*
* @param $profile
* Name of profile.
* @param $langcode
* Language code (if any).
*
* @return array
* The info array.
*/
function install_profile_info($profile, $langcode = 'en') {
static $cache = [];
if (!isset($cache[$profile][$langcode])) {
// Set defaults for module info.
$defaults = [
'dependencies' => [],
'install' => [],
'themes' => [
'stark',
],
'description' => '',
'version' => NULL,
'hidden' => FALSE,
'php' => \Drupal::MINIMUM_PHP,
'config_install_path' => NULL,
];
$profile_path = \Drupal::service('extension.list.profile')->getPath($profile);
/** @var \Drupal\Core\Extension\InfoParserInterface $parser */
$parser = \Drupal::service('info_parser');
$info = $parser->parse("{$profile_path}/{$profile}.info.yml");
$info += $defaults;
$dependency_name_function = function ($dependency) {
return Dependency::createFromString($dependency)->getName();
};
// Convert dependencies in [project:module] format.
$info['dependencies'] = array_map($dependency_name_function, $info['dependencies']);
// Convert install key in [project:module] format.
$info['install'] = array_map($dependency_name_function, $info['install']);
// Get a list of core's required modules.
$required = [];
$listing = new ExtensionDiscovery(\Drupal::root());
$files = $listing->scan('module');
foreach ($files as $name => $file) {
$parsed = $parser->parse($file->getPathname());
if (!empty($parsed) && !empty($parsed['required']) && $parsed['required']) {
$required[] = $name;
}
}
$locale = !empty($langcode) && $langcode != 'en' ? [
'locale',
] : [];
// Merge dependencies, required modules and locale into install list and
// remove any duplicates.
$info['install'] = array_unique(array_merge($info['install'], $required, $info['dependencies'], $locale));
// If the profile has a config/sync directory use that to install drupal.
if (is_dir($profile_path . '/config/sync')) {
$info['config_install_path'] = $profile_path . '/config/sync';
}
$cache[$profile][$langcode] = $info;
}
return $cache[$profile][$langcode];
}
Functions
Title | Deprecated | Summary |
---|---|---|
drupal_check_module | Checks a module's requirements. | |
drupal_check_profile | Checks an installation profile's requirements. | |
drupal_current_script_url | Returns the URL of the current script, with modified query parameters. | |
drupal_install_fix_file | Attempts to fix file permissions. | |
drupal_install_mkdir | Creates a directory with the specified permissions. | |
drupal_install_profile_distribution_name | Loads the installation profile, extracting its defined distribution name. | |
drupal_install_profile_distribution_version | Loads the installation profile, extracting its defined version. | |
drupal_install_system | Installs the system module. | |
drupal_load_updates | Loads .install files for installed modules to initialize the update system. | |
drupal_requirements_severity | Extracts the highest severity from the requirements array. | |
drupal_requirements_url | Returns a URL for proceeding to the next page after a requirements problem. | |
drupal_verify_install_file | Verifies the state of the specified file. | |
drupal_verify_profile | Verifies that all dependencies are met for a given installation profile. | |
install_goto | Sends the user to a different installer page. | |
install_profile_info | Retrieves information about an installation profile from its .info.yml file. |
Constants
Title | Deprecated | Summary |
---|---|---|
FILE_EXECUTABLE | File permission check -- File is executable. | |
FILE_EXIST | File permission check -- File exists. | |
FILE_NOT_EXECUTABLE | File permission check -- File is not executable. | |
FILE_NOT_EXIST | File permission check -- File does not exist. | |
FILE_NOT_READABLE | File permission check -- File is not readable. | |
FILE_NOT_WRITABLE | File permission check -- File is not writable. | |
FILE_READABLE | File permission check -- File is readable. | |
FILE_WRITABLE | File permission check -- File is writable. | |
REQUIREMENT_ERROR | Requirement severity -- Error condition; abort installation. | |
REQUIREMENT_INFO | Requirement severity -- Informational message only. | |
REQUIREMENT_OK | Requirement severity -- Requirement successfully met. | |
REQUIREMENT_WARNING | Requirement severity -- Warning condition; proceed but flag warning. |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.