diff --git a/core/lib/Drupal/Core/Extension/ModuleHandler.php b/core/lib/Drupal/Core/Extension/ModuleHandler.php index c24b9f4..0263597 100644 --- a/core/lib/Drupal/Core/Extension/ModuleHandler.php +++ b/core/lib/Drupal/Core/Extension/ModuleHandler.php @@ -10,6 +10,7 @@ use Drupal\Component\Graph\Graph; use Drupal\Component\Utility\NestedArray; use Drupal\Component\Utility\String; +use Drupal\Core\Cache\Cache; use Drupal\Core\Cache\CacheBackendInterface; /** @@ -689,6 +690,399 @@ public static function parseDependency($dependency) { /** * {@inheritdoc} */ +<<<<<<< HEAD +======= + public function install(array $module_list, $enable_dependencies = TRUE) { + $extension_config = \Drupal::config('core.extension'); + if ($enable_dependencies) { + // Get all module data so we can find dependencies and sort. + $module_data = system_rebuild_module_data(); + $module_list = $module_list ? array_combine($module_list, $module_list) : array(); + if (array_diff_key($module_list, $module_data)) { + // One or more of the given modules doesn't exist. + return FALSE; + } + + // Only process currently uninstalled modules. + $installed_modules = $extension_config->get('module') ?: array(); + 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 while loop continues. + while (list($module) = each($module_list)) { + foreach (array_keys($module_data[$module]->requires) as $dependency) { + if (!isset($module_data[$dependency])) { + // The dependency does not exist. + return FALSE; + } + + // Skip already installed modules. + if (!isset($module_list[$dependency]) && !isset($installed_modules[$dependency])) { + $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 DRUPAL_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 = array(); + 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(format_string('Module name %name is over the maximum allowed length of @max characters.', array( + '%name' => $module, + '@max' => DRUPAL_EXTENSION_NAME_MAX_LENGTH, + ))); + } + + $extension_config + ->set("module.$module", 0) + ->set('module', module_config_sort($extension_config->get('module'))) + ->save(); + + // 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->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 = array(); + foreach ($current_modules as $name => $weight) { + if (isset($current_module_filenames[$name])) { + $module_filenames[$name] = $current_module_filenames[$name]; + } + else { + $module_path = drupal_get_path('module', $name); + $pathname = "$module_path/$name.info.yml"; + $filename = file_exists($module_path . "/$name.module") ? "$name.module" : NULL; + $module_filenames[$name] = new Extension('module', $pathname, $filename); + } + } + + // Update the module handler in order to load the module's code. + // This allows the module to participate in hooks and its existence to + // be discovered by other modules. + // The current ModuleHandler instance is obsolete with the kernel + // rebuild below. + $this->setModuleList($module_filenames); + $this->load($module); + module_load_install($module); + + // Clear the static cache of system_rebuild_module_data() to pick up the + // new module, since it merges the installation status of modules into + // its statically cached list. + drupal_static_reset('system_rebuild_module_data'); + + // Update the kernel to include it. + $this->updateKernel($module_filenames); + + // Refresh the schema to include it. + drupal_get_schema(NULL, TRUE); + + // Allow modules to react prior to the installation of a module. + $this->invokeAll('module_preinstall', array($module)); + + // Now install the module's schema if necessary. + drupal_install_schema($module); + + // Clear plugin manager caches and flag router to rebuild if requested. + \Drupal::getContainer()->get('plugin.cache_clearer')->clearCachedDefinitions(); + \Drupal::service('router.builder_indicator')->setRebuildNeeded(); + + // 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 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_manager = \Drupal::entityManager(); + foreach ($entity_manager->getDefinitions() as $entity_type) { + if ($entity_type->getProvider() == $module) { + $entity_manager->onEntityTypeCreate($entity_type); + } + } + + // Install default configuration of the module. + $config_installer = \Drupal::service('config.installer'); + if ($sync_status) { + $config_installer + ->setSyncing(TRUE) + ->setSourceStorage($source_storage); + } + else { + // If we're not in a config synchronisation reset the source storage + // so that the extension install storage will pick up the new + // configuration. + $config_installer->resetSourceStorage(); + } + \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->invoke($module, 'update_last_removed')) { + $version = max($version, $last_removed); + } + drupal_set_installed_schema_version($module, $version); + + // Record the fact that it was installed. + $modules_installed[] = $module; + + // file_get_stream_wrappers() needs to re-register Drupal's stream + // wrappers 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://drupal.org/node/2208429 + \Drupal::service('theme_handler')->refreshInfo(); + + // Allow the module to perform install tasks. + $this->invoke($module, 'install'); + + // Record the fact that it was installed. + \Drupal::logger('system')->info('%module module installed.', array('%module' => $module)); + } + } + + // If any modules were newly installed, invoke hook_modules_installed(). + if (!empty($modules_installed)) { + $this->invokeAll('modules_installed', array($modules_installed)); + } + + return TRUE; + } + + /** + * {@inheritdoc} + */ + public function uninstall(array $module_list, $uninstall_dependents = TRUE) { + // Get all module data so we can find dependencies and sort. + $module_data = system_rebuild_module_data(); + $module_list = $module_list ? array_combine($module_list, $module_list) : array(); + if (array_diff_key($module_list, $module_data)) { + // One or more of the given modules doesn't exist. + return FALSE; + } + + // Only process currently installed modules. + $extension_config = \Drupal::config('core.extension'); + $installed_modules = $extension_config->get('module') ?: array(); + if (!$module_list = array_intersect_key($module_list, $installed_modules)) { + // Nothing to do. All modules already uninstalled. + return TRUE; + } + + if ($uninstall_dependents) { + // Add dependent modules to the list. The new modules will be processed as + // the while loop continues. + $profile = drupal_get_profile(); + while (list($module) = each($module_list)) { + foreach (array_keys($module_data[$module]->required_by) as $dependent) { + if (!isset($module_data[$dependent])) { + // The dependent module does not exist. + return FALSE; + } + + // Skip already uninstalled modules. + if (isset($installed_modules[$dependent]) && !isset($module_list[$dependent]) && $dependent != $profile) { + $module_list[$dependent] = $dependent; + } + } + } + } + + // 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. + $schema_store = \Drupal::keyValue('system.schema'); + $entity_manager = \Drupal::entityManager(); + 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. + foreach ($entity_manager->getDefinitions() as $entity_type_id => $entity_type) { + if ($entity_type->getProvider() == $module) { + foreach (array_keys($entity_manager->getBundleInfo($entity_type_id)) as $bundle) { + $entity_manager->onBundleDelete($bundle, $entity_type_id); + } + } + } + + // Allow modules to react prior to the uninstallation of a module. + $this->invokeAll('module_preuninstall', array($module)); + + // Uninstall the module. + module_load_install($module); + $this->invoke($module, 'uninstall'); + + // Remove all configuration belonging to the module. + \Drupal::service('config.manager')->uninstall('module', $module); + + // 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. + foreach ($entity_manager->getDefinitions() as $entity_type) { + if ($entity_type->getProvider() == $module) { + $entity_manager->onEntityTypeDelete($entity_type); + } + } + + // Remove the schema. + drupal_uninstall_schema($module); + + // Remove the module's entry from the config. + $extension_config->clear("module.$module")->save(); + + // Update the module handler to remove the module. + // The current ModuleHandler instance is obsolete with the kernel rebuild + // below. + $module_filenames = $this->getModuleList(); + unset($module_filenames[$module]); + $this->setModuleList($module_filenames); + + // Remove any potential cache bins provided by the module. + $this->removeCacheBins($module); + + // Clear the static cache of system_rebuild_module_data() to pick up the + // new module, since it merges the installation status of modules into + // its statically cached list. + drupal_static_reset('system_rebuild_module_data'); + + // Clear plugin manager caches and flag router to rebuild if requested. + \Drupal::getContainer()->get('plugin.cache_clearer')->clearCachedDefinitions(); + \Drupal::service('router.builder_indicator')->setRebuildNeeded(); + + // 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://drupal.org/node/2208429 + \Drupal::service('theme_handler')->refreshInfo(); + + \Drupal::logger('system')->info('%module module uninstalled.', array('%module' => $module)); + + $schema_store->delete($module); + } + drupal_get_installed_schema_version(NULL, TRUE); + + // Let other modules react. + $this->invokeAll('modules_uninstalled', array($module_list)); + + // Flush all persistent caches. + // Any cache entry might implicitly depend on the uninstalled modules, + // so clear all of them explicitly. + $this->invokeAll('cache_flush'); + foreach (Cache::getBins() as $service_id => $cache_backend) { + $cache_backend->deleteAll(); + } + + return TRUE; + } + + /** + * Helper method for removing all cache bins registered by a given module. + * + * @param string $module + * The name of the module for which to remove all registered cache bins. + */ + protected function removeCacheBins($module) { + // Remove any cache bins defined by a module. + $service_yaml_file = drupal_get_path('module', $module) . "/$module.services.yml"; + if (file_exists($service_yaml_file)) { + $definitions = Yaml::decode(file_get_contents($service_yaml_file)); + if (isset($definitions['services'])) { + foreach ($definitions['services'] as $id => $definition) { + if (isset($definition['tags'])) { + foreach ($definition['tags'] as $tag) { + // This works for the default cache registration and even in some + // cases when a non-default "super" factory is used. That should + // be extremely rare. + if ($tag['name'] == 'cache.bin' && isset($definition['factory_service']) && isset($definition['factory_method']) && !empty($definition['arguments'])) { + try { + $factory = \Drupal::service($definition['factory_service']); + if (method_exists($factory, $definition['factory_method'])) { + $backend = call_user_func_array(array($factory, $definition['factory_method']), $definition['arguments']); + if ($backend instanceof CacheBackendInterface) { + $backend->removeBin(); + } + } + } + catch (\Exception $e) { + watchdog_exception('system', $e, 'Failed to remove cache bin defined by the service %id.', array('%id' => $id)); + } + } + } + } + } + } + } + } + + /** + * {@inheritdoc} + */ +>>>>>>> applied patch public function getModuleDirectories() { $dirs = array(); foreach ($this->getModuleList() as $name => $module) { diff --git a/core/lib/Drupal/Core/Extension/ModuleInstaller.php b/core/lib/Drupal/Core/Extension/ModuleInstaller.php index f074ed3..749af89 100644 --- a/core/lib/Drupal/Core/Extension/ModuleInstaller.php +++ b/core/lib/Drupal/Core/Extension/ModuleInstaller.php @@ -8,6 +8,7 @@ namespace Drupal\Core\Extension; use Drupal\Component\Serialization\Yaml; +use Drupal\Core\Cache\Cache; use Drupal\Core\Cache\CacheBackendInterface; use Drupal\Core\DrupalKernelInterface; @@ -400,6 +401,14 @@ public function uninstall(array $module_list, $uninstall_dependents = TRUE) { // Let other modules react. $this->moduleHandler->invokeAll('modules_uninstalled', array($module_list)); + // Flush all persistent caches. + // Any cache entry might implicitly depend on the uninstalled modules, + // so clear all of them explicitly. + $this->invokeAll('cache_flush'); + foreach (Cache::getBins() as $service_id => $cache_backend) { + $cache_backend->deleteAll(); + } + return TRUE; } diff --git a/core/modules/system/src/Tests/Module/UninstallTest.php b/core/modules/system/src/Tests/Module/UninstallTest.php index 1b1cd70..f48a8aa 100644 --- a/core/modules/system/src/Tests/Module/UninstallTest.php +++ b/core/modules/system/src/Tests/Module/UninstallTest.php @@ -7,6 +7,7 @@ namespace Drupal\system\Tests\Module; +use Drupal\Core\Cache\Cache; use Drupal\Component\Utility\String; use Drupal\simpletest\WebTestBase; @@ -74,8 +75,19 @@ function testUninstallPage() { // labels. $this->assertRaw('

' . $entity_type->getLabel() . '

'); } + + // Set a unique cache entry to be able to test whether all caches are + // cleared during the uninstall. + \Drupal::cache()->set('uninstall_test', 'test_uninstall_page', Cache::PERMANENT); + $cached = \Drupal::cache()->get('uninstall_test'); + $this->assertEqual($cached->data, 'test_uninstall_page', String::format('Cache entry found: @bin', array('@bin' => $cached->data))); + $this->drupalPostForm(NULL, NULL, t('Uninstall')); $this->assertText(t('The selected modules have been uninstalled.'), 'Modules status has been updated.'); $this->assertNoRaw('<label', 'The page does not have double escaped HTML tags.'); + + // Make sure our unique cache entry is gone. + $cached = \Drupal::cache()->get('uninstall_test'); + $this->assertFalse($cached, 'Cache entry not found'); } }