function ModuleInstaller::install

Overrides ModuleInstallerInterface::install

File

core/lib/Drupal/Core/Extension/ModuleInstaller.php, line 82

Class

ModuleInstaller

Default implementation of the module installer.

Namespace

Code

public function install(array $module_list, $enable_dependencies = TRUE) {
    $extension_config = \Drupal::configFactory()->getEditable('core.extension');
    // Get all module data so we can find dependencies and sort and find the
    // core requirements. The module list needs to be reset so that it can
    // re-scan and include any new modules that may have been added directly
    // into the filesystem.
    $module_data = \Drupal::service('extension.list.module')->reset()
        ->getList();
    foreach ($module_list as $module) {
        if (!empty($module_data[$module]->info['core_incompatible'])) {
            throw new MissingDependencyException("Unable to install modules: module '{$module}' is incompatible with this version of Drupal core.");
        }
    }
    if ($enable_dependencies) {
        $module_list = $module_list ? array_combine($module_list, $module_list) : [];
        if ($missing_modules = array_diff_key($module_list, $module_data)) {
            // One or more of the given modules doesn't exist.
            throw new MissingDependencyException(sprintf('Unable to install modules %s due to missing modules %s.', implode(', ', $module_list), implode(', ', $missing_modules)));
        }
        // Only process currently uninstalled modules.
        $installed_modules = $extension_config->get('module') ?: [];
        if (!($module_list = array_diff_key($module_list, $installed_modules))) {
            // Nothing to do. All modules already installed.
            return TRUE;
        }
        // Add dependencies to the list. The new modules will be processed as
        // the foreach loop continues.
        foreach ($module_list as $module => $value) {
            foreach (array_keys($module_data[$module]->requires) as $dependency) {
                if (!isset($module_data[$dependency])) {
                    // The dependency does not exist.
                    throw new MissingDependencyException("Unable to install modules: module '{$module}' is missing its dependency module {$dependency}.");
                }
                // Skip already installed modules.
                if (!isset($module_list[$dependency]) && !isset($installed_modules[$dependency])) {
                    if ($module_data[$dependency]->info['core_incompatible']) {
                        throw new MissingDependencyException("Unable to install modules: module '{$module}'. Its dependency module '{$dependency}' is incompatible with this version of Drupal core.");
                    }
                    $module_list[$dependency] = $dependency;
                }
            }
        }
        // Set the actual module weights.
        $module_list = array_map(function ($module) use ($module_data) {
            return $module_data[$module]->sort;
        }, $module_list);
        // Sort the module list by their weights (reverse).
        arsort($module_list);
        $module_list = array_keys($module_list);
    }
    // Required for module installation checks.
    include_once $this->root . '/core/includes/install.inc';
    
    /** @var \Drupal\Core\Config\ConfigInstaller $config_installer */
    $config_installer = \Drupal::service('config.installer');
    $sync_status = $config_installer->isSyncing();
    if ($sync_status) {
        $source_storage = $config_installer->getSourceStorage();
    }
    $modules_installed = [];
    foreach ($module_list as $module) {
        $enabled = $extension_config->get("module.{$module}") !== NULL;
        if (!$enabled) {
            // Throw an exception if the module name is too long.
            if (strlen($module) > DRUPAL_EXTENSION_NAME_MAX_LENGTH) {
                throw new ExtensionNameLengthException("Module name '{$module}' is over the maximum allowed length of " . DRUPAL_EXTENSION_NAME_MAX_LENGTH . ' characters');
            }
            // Load a new config object for each iteration, otherwise changes made
            // in hook_install() are not reflected in $extension_config.
            $extension_config = \Drupal::configFactory()->getEditable('core.extension');
            // Check the validity of the default configuration. This will throw
            // exceptions if the configuration is not valid.
            $config_installer->checkConfigurationToInstall('module', $module);
            // Save this data without checking schema. This is a performance
            // improvement for module installation.
            $extension_config->set("module.{$module}", 0)
                ->set('module', module_config_sort($extension_config->get('module')))
                ->save(TRUE);
            // Prepare the new module list, sorted by weight, including filenames.
            // This list is used for both the ModuleHandler and DrupalKernel. It
            // needs to be kept in sync between both. A DrupalKernel reboot or
            // rebuild will automatically re-instantiate a new ModuleHandler that
            // uses the new module list of the kernel. However, DrupalKernel does
            // not cause any modules to be loaded.
            // Furthermore, the currently active (fixed) module list can be
            // different from the configured list of enabled modules. For all active
            // modules not contained in the configured enabled modules, we assume a
            // weight of 0.
            $current_module_filenames = $this->moduleHandler
                ->getModuleList();
            $current_modules = array_fill_keys(array_keys($current_module_filenames), 0);
            $current_modules = module_config_sort(array_merge($current_modules, $extension_config->get('module')));
            $module_filenames = [];
            foreach ($current_modules as $name => $weight) {
                if (isset($current_module_filenames[$name])) {
                    $module_filenames[$name] = $current_module_filenames[$name];
                }
                else {
                    $module_path = \Drupal::service('extension.list.module')->getPath($name);
                    $pathname = "{$module_path}/{$name}.info.yml";
                    $filename = file_exists($module_path . "/{$name}.module") ? "{$name}.module" : NULL;
                    $module_filenames[$name] = new Extension($this->root, 'module', $pathname, $filename);
                }
            }
            // Update the module handler in order to have the correct module list
            // for the kernel update.
            $this->moduleHandler
                ->setModuleList($module_filenames);
            // Clear the static cache of the "extension.list.module" service to pick
            // up the new module, since it merges the installation status of modules
            // into its statically cached list.
            \Drupal::service('extension.list.module')->reset();
            // Update the kernel to include it.
            $this->updateKernel($module_filenames);
            // Load the module's .module and .install files.
            $this->moduleHandler
                ->load($module);
            module_load_install($module);
            // Replace the route provider service with a version that will rebuild
            // if routes used during installation. This ensures that a module's
            // routes are available during installation. This has to occur before
            // any services that depend on it are instantiated otherwise those
            // services will have the old route provider injected. Note that, since
            // the container is rebuilt by updating the kernel, the route provider
            // service is the regular one even though we are in a loop and might
            // have replaced it before.
            \Drupal::getContainer()->set('router.route_provider.old', \Drupal::service('router.route_provider'));
            \Drupal::getContainer()->set('router.route_provider', \Drupal::service('router.route_provider.lazy_builder'));
            // Allow modules to react prior to the installation of a module.
            $this->moduleHandler
                ->invokeAll('module_preinstall', [
                $module,
            ]);
            // Now install the module's schema if necessary.
            drupal_install_schema($module);
            // Clear plugin manager caches.
            \Drupal::getContainer()->get('plugin.cache_clearer')
                ->clearCachedDefinitions();
            // Set the schema version to the number of the last update provided by
            // the module, or the minimum core schema version.
            $version = \Drupal::CORE_MINIMUM_SCHEMA_VERSION;
            $versions = drupal_get_schema_versions($module);
            if ($versions) {
                $version = max(max($versions), $version);
            }
            // Notify interested components that this module's entity types and
            // field storage definitions are new. For example, a SQL-based storage
            // handler can use this as an opportunity to create the necessary
            // database tables.
            // @todo Clean this up in https://www.drupal.org/node/2350111.
            $entity_type_manager = \Drupal::entityTypeManager();
            $update_manager = \Drupal::entityDefinitionUpdateManager();
            
            /** @var \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager */
            $entity_field_manager = \Drupal::service('entity_field.manager');
            foreach ($entity_type_manager->getDefinitions() as $entity_type) {
                $is_fieldable_entity_type = $entity_type->entityClassImplements(FieldableEntityInterface::class);
                if ($entity_type->getProvider() == $module) {
                    if ($is_fieldable_entity_type) {
                        $update_manager->installFieldableEntityType($entity_type, $entity_field_manager->getFieldStorageDefinitions($entity_type->id()));
                    }
                    else {
                        $update_manager->installEntityType($entity_type);
                    }
                }
                elseif ($is_fieldable_entity_type) {
                    // The module being installed may be adding new fields to existing
                    // entity types. Field definitions for any entity type defined by
                    // the module are handled in the if branch.
                    foreach ($entity_field_manager->getFieldStorageDefinitions($entity_type->id()) as $storage_definition) {
                        if ($storage_definition->getProvider() == $module) {
                            // If the module being installed is also defining a storage key
                            // for the entity type, the entity schema may not exist yet. It
                            // will be created later in that case.
                            try {
                                $update_manager->installFieldStorageDefinition($storage_definition->getName(), $entity_type->id(), $module, $storage_definition);
                            } catch (EntityStorageException $e) {
                                watchdog_exception('system', $e, 'An error occurred while notifying the creation of the @name field storage definition: "!message" in %function (line %line of %file).', [
                                    '@name' => $storage_definition->getName(),
                                ]);
                            }
                        }
                    }
                }
            }
            // Install default configuration of the module.
            $config_installer = \Drupal::service('config.installer');
            if ($sync_status) {
                $config_installer->setSyncing(TRUE)
                    ->setSourceStorage($source_storage);
            }
            \Drupal::service('config.installer')->installDefaultConfig('module', $module);
            // If the module has no current updates, but has some that were
            // previously removed, set the version to the value of
            // hook_update_last_removed().
            if ($last_removed = $this->moduleHandler
                ->invoke($module, 'update_last_removed')) {
                $version = max($version, $last_removed);
            }
            drupal_set_installed_schema_version($module, $version);
            // Ensure that all post_update functions are registered already. This
            // should include existing post-updates, as well as any specified as
            // having been previously removed, to ensure that newly installed and
            // updated sites have the same entries in the registry.
            
            /** @var \Drupal\Core\Update\UpdateRegistry $post_update_registry */
            $post_update_registry = \Drupal::service('update.post_update_registry');
            $post_update_registry->registerInvokedUpdates(array_merge($post_update_registry->getModuleUpdateFunctions($module), array_keys($post_update_registry->getRemovedPostUpdates($module))));
            // Record the fact that it was installed.
            $modules_installed[] = $module;
            // Drupal's stream wrappers needs to be re-registered in case a
            // module-provided stream wrapper is used later in the same request. In
            // particular, this happens when installing Drupal via Drush, as the
            // 'translations' stream wrapper is provided by Interface Translation
            // module and is later used to import translations.
            \Drupal::service('stream_wrapper_manager')->register();
            // Update the theme registry to include it.
            drupal_theme_rebuild();
            // Modules can alter theme info, so refresh theme data.
            // @todo ThemeHandler cannot be injected into ModuleHandler, since that
            //   causes a circular service dependency.
            // @see https://www.drupal.org/node/2208429
            \Drupal::service('theme_handler')->refreshInfo();
            // Allow the module to perform install tasks.
            $this->moduleHandler
                ->invoke($module, 'install', [
                $sync_status,
            ]);
            // Record the fact that it was installed.
            \Drupal::logger('system')->info('%module module installed.', [
                '%module' => $module,
            ]);
        }
    }
    // If any modules were newly installed, invoke hook_modules_installed().
    if (!empty($modules_installed)) {
        // If the container was rebuilt during hook_install() it might not have
        // the 'router.route_provider.old' service.
        if (\Drupal::hasService('router.route_provider.old')) {
            \Drupal::getContainer()->set('router.route_provider', \Drupal::service('router.route_provider.old'));
        }
        if (!\Drupal::service('router.route_provider.lazy_builder')->hasRebuilt()) {
            // Rebuild routes after installing module. This is done here on top of
            // \Drupal\Core\Routing\RouteBuilder::destruct to not run into errors on
            // fastCGI which executes ::destruct() after the module installation
            // page was sent already.
            \Drupal::service('router.builder')->rebuild();
        }
        $this->moduleHandler
            ->invokeAll('modules_installed', [
            $modules_installed,
            $sync_status,
        ]);
    }
    return TRUE;
}