public function UpdateModuleHandler::enable

Enables or installs a given list of modules.

Definitions:

  • "Enabling" is the process of activating a module for use by Drupal.
  • "Disabling" is the process of deactivating a module.
  • "Installing" is the process of enabling it for the first time or after it has been uninstalled.
  • "Uninstalling" is the process of removing all traces of a module.

Order of events:

  • Gather and add module dependencies to $module_list (if applicable).
  • For each module that is being enabled:
    • Install module schema and update system registries and caches.
    • If the module is being enabled for the first time or had been uninstalled, invoke hook_install() and add it to the list of installed modules.
    • Invoke hook_enable().
  • Invoke hook_modules_installed().
  • Invoke hook_modules_enabled().

Parameters

$module_list: An array of module names.

$enable_dependencies: If TRUE, dependencies will automatically be added and enabled in the correct order. This incurs a significant performance cost, so use FALSE if you know $module_list is already complete and in the correct order.

Return value

FALSE if one or more dependencies are missing, TRUE otherwise.

Overrides ModuleHandler::enable

See also

hook_install()

hook_enable()

hook_modules_installed()

hook_modules_enabled()

File

drupal/core/lib/Drupal/Core/Extension/UpdateModuleHandler.php, line 57
Contains \Drupal\Core\Extension\UpdateModuleHandler.

Class

UpdateModuleHandler
Deals with module enables and throws exception if hooks fired during updates.

Namespace

Drupal\Core\Extension

Code

public function enable($module_list, $enable_dependencies = TRUE) {
  $schema_store = \Drupal::keyValue('system.schema');
  $old_schema = array();
  foreach ($module_list as $module) {

    // Check for initial schema and install it. The schema version of a newly
    // installed module is always 0. Using 8000 here would be inconsistent
    // since $module_update_8000() may involve a schema change, and we want
    // to install the schema as it was before any updates were added.
    module_load_install($module);
    $function = $module . '_schema_0';
    if (function_exists($function)) {
      $schema = $function();
      foreach ($schema as $table => $spec) {
        db_create_table($table, $spec);
      }
    }

    // Enable the module with a weight of 0.
    $module_config = config('system.module');
    $module_config
      ->set("enabled.{$module}", 0)
      ->set('enabled', module_config_sort($module_config
      ->get('enabled')))
      ->save();

    // Ensure the module is not contained in disabled modules.
    config('system.module.disabled')
      ->clear($module)
      ->save();
    $current_schema = $schema_store
      ->get($module);

    // Set the schema version if the module was not just disabled before.
    if ($current_schema === NULL || $current_schema === SCHEMA_UNINSTALLED) {

      // Change the schema version to the given value (defaults to 0), so any
      // module updates since the module's inception are executed in a core
      // upgrade.
      $schema_store
        ->set($module, 0);
      $old_schema[$module] = SCHEMA_UNINSTALLED;
    }
    else {
      $old_schema[$module] = $current_schema;
    }

    // Copy the default configuration of the module into the active storage.
    // The default configuration is not altered in any way, and since the module
    // is just being installed, none of its configuration can exist already, so
    // this is a plain copy operation from one storage to another.
    $module_config_path = drupal_get_path('module', $module) . '/config';
    if (is_dir($module_config_path)) {
      $module_filestorage = new FileStorage($module_config_path);
      $config_storage = drupal_container()
        ->get('config.storage');
      foreach ($module_filestorage
        ->listAll() as $config_name) {

        // If this file already exists, something in the upgrade path went
        // completely wrong and we want to know.
        if ($config_storage
          ->exists($config_name)) {
          throw new ConfigException(format_string('Default configuration file @name of @module module unexpectedly exists already before the module was installed.', array(
            '@module' => $module,
            '@name' => $config_name,
          )));
        }
        $config_storage
          ->write($config_name, $module_filestorage
          ->read($config_name));
      }
    }

    // system_list_reset() is in module.inc but that would only be available
    // once the variable bootstrap is done.
    require_once DRUPAL_ROOT . '/core/includes/module.inc';
    system_list_reset();
    $this->moduleList[$module] = drupal_get_filename('module', $module);
    $this
      ->load($module);
    drupal_classloader_register($module, dirname($this->moduleList[$module]));

    // @todo Figure out what to do about hook_install() and hook_enable().
  }
  return $old_schema;
}