function ModuleInstaller::uninstall

Overrides ModuleInstallerInterface::uninstall

File

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

Class

ModuleInstaller

Default implementation of the module installer.

Namespace

Code

public function uninstall(array $module_list, $uninstall_dependents = TRUE) {
    // Get all module data so we can find dependencies and sort.
    $module_data = \Drupal::service('extension.list.module')->getList();
    $sync_status = \Drupal::service('config.installer')->isSyncing();
    $module_list = $module_list ? array_combine($module_list, $module_list) : [];
    if (array_diff_key($module_list, $module_data)) {
        // One or more of the given modules doesn't exist.
        return FALSE;
    }
    $extension_config = \Drupal::configFactory()->getEditable('core.extension');
    $installed_modules = $extension_config->get('module') ?: [];
    if (!($module_list = array_intersect_key($module_list, $installed_modules))) {
        // Nothing to do. All modules already uninstalled.
        return TRUE;
    }
    if ($uninstall_dependents) {
        $theme_list = \Drupal::service('extension.list.theme')->getList();
        // Add dependent modules 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]->required_by) as $dependent) {
                if (!isset($module_data[$dependent]) && !isset($theme_list[$dependent])) {
                    // The dependent module or theme does not exist.
                    return FALSE;
                }
                // Skip already uninstalled modules.
                if (isset($installed_modules[$dependent]) && !isset($module_list[$dependent])) {
                    $module_list[$dependent] = $dependent;
                }
            }
        }
    }
    // Use the validators and throw an exception with the reasons.
    if ($reasons = $this->validateUninstall($module_list)) {
        foreach ($reasons as $reason) {
            $reason_message[] = implode(', ', $reason);
        }
        throw new ModuleUninstallValidatorException('The following reasons prevent the modules from being uninstalled: ' . implode('; ', $reason_message));
    }
    // 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.
    asort($module_list);
    $module_list = array_keys($module_list);
    // Only process modules that are enabled. A module is only enabled if it is
    // configured as enabled. Custom or overridden module handlers might contain
    // the module already, which means that it might be loaded, but not
    // necessarily installed.
    foreach ($module_list as $module) {
        // Clean up all entity bundles (including fields) of every entity type
        // provided by the module that is being uninstalled.
        // @todo Clean this up in https://www.drupal.org/node/2350111.
        $entity_type_manager = \Drupal::entityTypeManager();
        $entity_type_bundle_info = \Drupal::service('entity_type.bundle.info');
        foreach ($entity_type_manager->getDefinitions() as $entity_type_id => $entity_type) {
            if ($entity_type->getProvider() == $module) {
                foreach (array_keys($entity_type_bundle_info->getBundleInfo($entity_type_id)) as $bundle) {
                    \Drupal::service('entity_bundle.listener')->onBundleDelete($bundle, $entity_type_id);
                }
            }
        }
        // Allow modules to react prior to the uninstallation of a module.
        $this->moduleHandler
            ->invokeAll('module_preuninstall', [
            $module,
        ]);
        // Uninstall the module.
        module_load_install($module);
        $this->moduleHandler
            ->invoke($module, 'uninstall', [
            $sync_status,
        ]);
        // Remove all configuration belonging to the module.
        \Drupal::service('config.manager')->uninstall('module', $module);
        // In order to make uninstalling transactional if anything uses routes.
        \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'));
        // Notify interested components that this module's entity types are being
        // deleted. For example, a SQL-based storage handler can use this as an
        // opportunity to drop the corresponding database tables.
        // @todo Clean this up in https://www.drupal.org/node/2350111.
        $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) {
            if ($entity_type->getProvider() == $module) {
                $update_manager->uninstallEntityType($entity_type);
            }
            elseif ($entity_type->entityClassImplements(FieldableEntityInterface::CLASS)) {
                // The module being uninstalled might have added new fields to
                // existing entity types. This will add them to the deleted fields
                // repository so their data will be purged on cron.
                foreach ($entity_field_manager->getFieldStorageDefinitions($entity_type->id()) as $storage_definition) {
                    if ($storage_definition->getProvider() == $module) {
                        $update_manager->uninstallFieldStorageDefinition($storage_definition);
                    }
                }
            }
        }
        // Remove the schema.
        drupal_uninstall_schema($module);
        // Remove the module's entry from the config. Don't check schema when
        // uninstalling a module since we are only clearing a key.
        \Drupal::configFactory()->getEditable('core.extension')
            ->clear("module.{$module}")
            ->save(TRUE);
        // Update the module handler to remove the module.
        // The current ModuleHandler instance is obsolete with the kernel rebuild
        // below.
        $module_filenames = $this->moduleHandler
            ->getModuleList();
        unset($module_filenames[$module]);
        $this->moduleHandler
            ->setModuleList($module_filenames);
        // Remove any potential cache bins provided by the module.
        $this->removeCacheBins($module);
        // 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();
        // Clear plugin manager caches.
        \Drupal::getContainer()->get('plugin.cache_clearer')
            ->clearCachedDefinitions();
        // Update the kernel to exclude the uninstalled modules.
        $this->updateKernel($module_filenames);
        // Update the theme registry to remove the newly uninstalled module.
        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();
        \Drupal::logger('system')->info('%module module uninstalled.', [
            '%module' => $module,
        ]);
        $schema_store = \Drupal::keyValue('system.schema');
        $schema_store->delete($module);
        
        /** @var \Drupal\Core\Update\UpdateRegistry $post_update_registry */
        $post_update_registry = \Drupal::service('update.post_update_registry');
        $post_update_registry->filterOutInvokedUpdatesByModule($module);
    }
    // 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 uninstallation page
    // was sent already.
    \Drupal::service('router.builder')->rebuild();
    drupal_get_installed_schema_version(NULL, TRUE);
    // Let other modules react.
    $this->moduleHandler
        ->invokeAll('modules_uninstalled', [
        $module_list,
        $sync_status,
    ]);
    // Flush all persistent caches.
    // Any cache entry might implicitly depend on the uninstalled modules,
    // so clear all of them explicitly.
    $this->moduleHandler
        ->invokeAll('cache_flush');
    foreach (Cache::getBins() as $service_id => $cache_backend) {
        $cache_backend->deleteAll();
    }
    return TRUE;
}