diff --git a/core/includes/install.core.inc b/core/includes/install.core.inc index 41f0b5c..808520b 100644 --- a/core/includes/install.core.inc +++ b/core/includes/install.core.inc @@ -1656,6 +1656,12 @@ function install_profile_themes(&$install_state) { * An array of information about the current installation state. */ function install_install_profile(&$install_state) { + // Now that all modules are installed, make sure the entity storage and other + // handlers are up to date with the current entity and field definitions. For + // example, Path module adds a base field to nodes and taxonomy terms after + // those modules are already installed. + \Drupal::service('entity.definition_update_manager')->applyUpdates(); + \Drupal::service('module_installer')->install(array(drupal_get_profile()), FALSE); // Install all available optional config. During installation the module order // is determined by dependencies. If there are no dependencies between modules diff --git a/core/includes/update.inc b/core/includes/update.inc index 9d4557f..34882c3 100644 --- a/core/includes/update.inc +++ b/core/includes/update.inc @@ -224,14 +224,10 @@ function update_do_one($module, $number, $dependency_map, &$context) { /** * Performs entity definition updates, which can trigger schema updates. * - * @param $module - * The module whose update will be run. - * @param $number - * The update number to run. * @param $context * The batch context array. */ -function update_entity_definitions($module, $number, &$context) { +function update_entity_definitions(&$context) { try { \Drupal::service('entity.definition_update_manager')->applyUpdates(); } @@ -243,7 +239,7 @@ function update_entity_definitions($module, $number, &$context) { // \Drupal\Component\Utility\SafeMarkup::checkPlain() by // \Drupal\Core\Utility\Error::decodeException(). $ret['#abort'] = array('success' => FALSE, 'query' => t('%type: !message in %function (line %line of %file).', $variables)); - $context['results'][$module][$number] = $ret; + $context['results']['core']['update_entity_definitions'] = $ret; $context['results']['#abort'][] = 'update_entity_definitions'; } } diff --git a/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php index 1531f81..902aab9 100644 --- a/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php +++ b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManager.php @@ -97,7 +97,7 @@ public function getChangeSummary() { public function applyUpdates() { $change_list = $this->getChangeList(); if ($change_list) { - // getChangeList() only disables the cache and does not invalidate. + // self::getChangeList() only disables the cache and does not invalidate. // In case there are changes, explicitly invalidate caches. $this->entityManager->clearCachedDefinitions(); } @@ -107,18 +107,7 @@ public function applyUpdates() { // to revisionable and at the same time add revisionable fields to the // entity type. if (!empty($change_list['entity_type'])) { - $entity_type = $this->entityManager->getDefinition($entity_type_id); - - switch ($change_list['entity_type']) { - case static::DEFINITION_CREATED: - $this->entityManager->onEntityTypeCreate($entity_type); - break; - - case static::DEFINITION_UPDATED: - $original = $this->entityManager->getLastInstalledDefinition($entity_type_id); - $this->entityManager->onEntityTypeUpdate($entity_type, $original); - break; - } + $this->doEntityUpdate($change_list['entity_type'], $entity_type_id); } // Process field storage definition changes. @@ -127,25 +116,106 @@ public function applyUpdates() { $original_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id); foreach ($change_list['field_storage_definitions'] as $field_name => $change) { - switch ($change) { - case static::DEFINITION_CREATED: - $this->entityManager->onFieldStorageDefinitionCreate($storage_definitions[$field_name]); - break; - - case static::DEFINITION_UPDATED: - $this->entityManager->onFieldStorageDefinitionUpdate($storage_definitions[$field_name], $original_storage_definitions[$field_name]); - break; - - case static::DEFINITION_DELETED: - $this->entityManager->onFieldStorageDefinitionDelete($original_storage_definitions[$field_name]); - break; - } + $storage_definition = isset($storage_definitions[$field_name]) ? $storage_definitions[$field_name] : NULL; + $original_storage_definition = isset($original_storage_definitions[$field_name]) ? $original_storage_definitions[$field_name] : NULL; + $this->doFieldUpdate($change, $storage_definition, $original_storage_definition); } } } } /** + * {@inheritdoc} + */ + public function applyEntityUpdate($op, $entity_type_id, $reset_cached_definitions = TRUE) { + $change_list = $this->getChangeList(); + if (!isset($change_list[$entity_type_id]) || $change_list[$entity_type_id]['entity_type'] !== $op) { + return FALSE; + } + if ($reset_cached_definitions) { + // self::getChangeList() only disables the cache and does not invalidate. + // In case there are changes, explicitly invalidate caches. + $this->entityManager->clearCachedDefinitions(); + } + $this->doEntityUpdate($op, $entity_type_id); + return TRUE; + } + + /** + * {@inheritdoc} + */ + public function applyFieldUpdate($op, $entity_type_id, $field_name, $reset_cached_definitions = TRUE) { + $change_list = $this->getChangeList(); + if (!isset($change_list[$entity_type_id]['field_storage_definitions']) || $change_list[$entity_type_id]['field_storage_definitions'][$field_name] !== $op) { + return FALSE; + } + + if ($reset_cached_definitions) { + // self::getChangeList() only disables the cache and does not invalidate. + // In case there are changes, explicitly invalidate caches. + $this->entityManager->clearCachedDefinitions(); + } + + $storage_definitions = $this->entityManager->getFieldStorageDefinitions($entity_type_id); + $original_storage_definitions = $this->entityManager->getLastInstalledFieldStorageDefinitions($entity_type_id); + $storage_definition = isset($storage_definitions[$field_name]) ? $storage_definitions[$field_name] : NULL; + $original_storage_definition = isset($original_storage_definitions[$field_name]) ? $original_storage_definitions[$field_name] : NULL; + + $this->doFieldUpdate($op, $storage_definition, $original_storage_definition); + return TRUE; + } + + /** + * Performs an entity type definition update. + * + * @param string $op + * The operation to perform, either static::DEFINITION_CREATED or + * static::DEFINITION_UPDATED. + * @param string $entity_type_id + * The entity type ID. + */ + protected function doEntityUpdate($op, $entity_type_id) { + $entity_type = $this->entityManager->getDefinition($entity_type_id); + switch ($op) { + case static::DEFINITION_CREATED: + $this->entityManager->onEntityTypeCreate($entity_type); + break; + + case static::DEFINITION_UPDATED: + $original = $this->entityManager->getLastInstalledDefinition($entity_type_id); + $this->entityManager->onEntityTypeUpdate($entity_type, $original); + break; + } + } + + /** + * Performs a field storage definition update. + * + * @param string $op + * The operation to perform, possible values are static::DEFINITION_CREATED, + * static::DEFINITION_UPDATED or static::DEFINITION_DELETED. + * @param array|null $storage_definition + * The new field storage definition. + * @param array|null $original_storage_definition + * The original field storage definition. + */ + protected function doFieldUpdate($op, $storage_definition = NULL, $original_storage_definition = NULL) { + switch ($op) { + case static::DEFINITION_CREATED: + $this->entityManager->onFieldStorageDefinitionCreate($storage_definition); + break; + + case static::DEFINITION_UPDATED: + $this->entityManager->onFieldStorageDefinitionUpdate($storage_definition, $original_storage_definition); + break; + + case static::DEFINITION_DELETED: + $this->entityManager->onFieldStorageDefinitionDelete($original_storage_definition); + break; + } + } + + /** * Gets a list of changes to entity type and field storage definitions. * * @return array diff --git a/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php index 8eee170..635e781 100644 --- a/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php +++ b/core/lib/Drupal/Core/Entity/EntityDefinitionUpdateManagerInterface.php @@ -83,4 +83,65 @@ public function getChangeSummary(); */ public function applyUpdates(); + /** + * Performs a single entity definition update. + * + * This method should be used from hook_update_N functions to process entity + * definition updates as part of the update function. This is only necessary + * if the hook_update_N implementation relies on the entity definition update. + * + * @param string $op + * The operation to perform, either static::DEFINITION_CREATED or + * static::DEFINITION_UPDATED. + * @param string $entity_type_id + * The entity type to update. + * @param bool $reset_cached_definitions + * (optional). Determines whether to clear the Entity Manager's cached + * definitions before applying the update. Defaults to TRUE. Can be used + * to prevent unnecessary cache invalidation when a hook_update_N makes + * multiple calls to this method. + * + * @return bool + * TRUE if the entity update is processed, FALSE if not. + * + * @throws \Drupal\Core\Entity\EntityStorageException + * This exception is thrown if a change cannot be applied without + * unacceptable data loss. In such a case, the site administrator needs to + * apply some other process, such as a custom update function or a + * migration via the Migrate module. + */ + public function applyEntityUpdate($op, $entity_type_id, $reset_cached_definitions = TRUE); + + /** + * Performs a single field storage definition update. + * + * This method should be used from hook_update_N functions to process field + * storage definition updates as part of the update function. This is only + * necessary if the hook_update_N implementation relies on the field storage + * definition update. + * + * @param string $op + * The operation to perform, possible values are static::DEFINITION_CREATED, + * static::DEFINITION_UPDATED or static::DEFINITION_DELETED. + * @param string $entity_type_id + * The entity type to update. + * @param string $field_name + * The field name to update. + * @param bool $reset_cached_definitions + * (optional). Determines whether to clear the Entity Manager's cached + * definitions before applying the update. Defaults to TRUE. Can be used + * to prevent unnecessary cache invalidation when a hook_update_N makes + * multiple calls to this method. + + * @return bool + * TRUE if the entity update is processed, FALSE if not. + * + * @throws \Drupal\Core\Entity\EntityStorageException + * This exception is thrown if a change cannot be applied without + * unacceptable data loss. In such a case, the site administrator needs to + * apply some other process, such as a custom update function or a + * migration via the Migrate module. + */ + public function applyFieldUpdate($op, $entity_type_id, $field_name, $reset_cached_definitions = TRUE); + } diff --git a/core/modules/system/src/Controller/DbUpdateController.php b/core/modules/system/src/Controller/DbUpdateController.php index a55ef02..9ea4dda 100644 --- a/core/modules/system/src/Controller/DbUpdateController.php +++ b/core/modules/system/src/Controller/DbUpdateController.php @@ -556,13 +556,6 @@ protected function triggerBatch(Request $request) { $operations = array(); - // First of all perform entity definition updates, which will update - // storage schema if needed, so that module update functions work with - // the correct entity schema. - if ($this->entityDefinitionUpdateManager->needsUpdates()) { - $operations[] = array('update_entity_definitions', array('system', '0 - Update entity definitions')); - } - // Resolve any update dependencies to determine the actual updates that will // be run and the order they will be run in. $start = $this->getModuleUpdates(); @@ -578,7 +571,7 @@ protected function triggerBatch(Request $request) { } // Determine updates to be performed. - foreach ($updates as $update) { + foreach ($updates as $function => $update) { if ($update['allowed']) { // Set the installed version of each module so updates will start at the // correct place. (The updates are already sorted, so we can simply base @@ -587,11 +580,18 @@ protected function triggerBatch(Request $request) { drupal_set_installed_schema_version($update['module'], $update['number'] - 1); unset($start[$update['module']]); } - // Add this update function to the batch. - $function = $update['module'] . '_update_' . $update['number']; $operations[] = array('update_do_one', array($update['module'], $update['number'], $dependency_map[$function])); } } + + // Lastly, perform entity definition updates, which will update storage + // schema if needed. If module update functions need to work with specific + // entity schema they should call the entity update service for the specific + // update themselves. + if ($this->entityDefinitionUpdateManager->needsUpdates()) { + $operations[] = array('update_entity_definitions', array()); + } + $batch['operations'] = $operations; $batch += array( 'title' => $this->t('Updating'), diff --git a/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php b/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php index 6d9408e8..b68f1d0 100644 --- a/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php +++ b/core/modules/system/src/Tests/Entity/EntityDefinitionUpdateTest.php @@ -9,6 +9,7 @@ use Drupal\Core\Database\DatabaseExceptionWrapper; use Drupal\Core\Database\IntegrityConstraintViolationException; +use Drupal\Core\Entity\EntityDefinitionUpdateManagerInterface; use Drupal\Core\Entity\EntityStorageException; use Drupal\Core\Entity\EntityTypeEvents; use Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException; @@ -604,4 +605,25 @@ public function testEntityTypeSchemaUpdateAndRevisionableBaseFieldCreateWithoutD } } + /** + * Tests ::applyEntityUpdate() and ::applyFieldUpdate(). + */ + public function testSingleActionCalls() { + // Ensure that the methods return FALSE when called with bogus information. + $this->assertFalse($this->entityDefinitionUpdateManager->applyEntityUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED, 'foo'), 'Calling applyEntityUpdate() with an non-existent entity returns FALSE.'); + $this->assertFalse($this->entityDefinitionUpdateManager->applyFieldUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED, 'foo', 'bar'), 'Calling applyFieldUpdate() with an non-existent entity returns FALSE.'); + $this->assertFalse($this->entityDefinitionUpdateManager->applyFieldUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED, 'entity_test_update', 'bar'), 'Calling applyFieldUpdate() with an non-existent field returns FALSE.'); + $this->assertFalse($this->entityDefinitionUpdateManager->applyEntityUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED, 'entity_test_update'), 'Calling applyEntityUpdate() with an nonsense $op returns FALSE.'); + $this->assertFalse($this->entityDefinitionUpdateManager->applyFieldUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_DELETED, 'entity_test_update', 'new_base_field'), 'Calling applyFieldUpdate() with an nonsense $op returns FALSE.'); + + // Create a new base field. + $this->addRevisionableBaseField(); + $this->assertTrue($this->entityDefinitionUpdateManager->applyFieldUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED, 'entity_test_update', 'new_base_field'), 'Calling applyFieldUpdate() correctly returns TRUE.'); + $this->assertTrue($this->database->schema()->fieldExists('entity_test_update', 'new_base_field'), "New field 'new_base_field' has been created on the 'entity_test_update' table."); + // Make the entity type revisionable. + $this->updateEntityTypeToRevisionable(); + $this->assertTrue($this->entityDefinitionUpdateManager->applyEntityUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_UPDATED, 'entity_test_update'), 'Calling applyEntityUpdate() correctly returns TRUE.'); + $this->assertTrue($this->database->schema()->tableExists('entity_test_update_revision'), "The 'entity_test_update_revision' table has been created."); + } + } diff --git a/core/modules/system/src/Tests/Entity/Update/SqlContentEntityStorageSchemaIndexTest.php b/core/modules/system/src/Tests/Entity/Update/SqlContentEntityStorageSchemaIndexTest.php index 527c323..212424c 100644 --- a/core/modules/system/src/Tests/Entity/Update/SqlContentEntityStorageSchemaIndexTest.php +++ b/core/modules/system/src/Tests/Entity/Update/SqlContentEntityStorageSchemaIndexTest.php @@ -19,6 +19,11 @@ class SqlContentEntityStorageSchemaIndexTest extends UpdatePathTestBase { /** * {@inheritdoc} */ + protected static $modules = ['update_order_test']; + + /** + * {@inheritdoc} + */ public function setUp() { $this->databaseDumpFiles = [ __DIR__ . '/../../../../tests/fixtures/update/drupal-8.bare.standard.php.gz', @@ -30,13 +35,30 @@ public function setUp() { * Test for the new index. */ public function testIndex() { + \Drupal::state()->set('update_order_test', TRUE); $this->assertTrue(db_index_exists('node_field_data', 'node__default_langcode'), 'Index node__default_langcode exists prior to running updates.'); $this->assertFalse(db_index_exists('node_field_data', 'node__id__default_langcode__langcode'), 'Index node__id__default_langcode__langcode does not exist prior to running updates.'); $this->assertFalse(db_index_exists('users_field_data', 'user__id__default_langcode__langcode'), 'Index users__id__default_langcode__langcode does not exist prior to running updates.'); + $this->runUpdates(); $this->assertFalse(db_index_exists('node_field_data', 'node__default_langcode'), 'Index node__default_langcode properly removed.'); $this->assertTrue(db_index_exists('node_field_data', 'node__id__default_langcode__langcode'), 'Index node__id__default_langcode__langcode properly created on the node_field_data table.'); $this->assertTrue(db_index_exists('users_field_data', 'user__id__default_langcode__langcode'), 'Index users__id__default_langcode__langcode properly created on the user_field_data table.'); + + // Ensure that hook_update_N implementations are in the expected order. + $this->assertTrue(\Drupal::state()->get('update_order_test_update_8001', FALSE), 'update_order_test_update_8001 runs before entity type updates.'); + + // Node update has been run during update_order_test_update_8002. + $this->assertFalse(\Drupal::state()->get('update_order_test_update_8002_node__default_langcode', TRUE), 'The node__default_langcode index has been removed during update_order_test_update_8002.'); + $this->assertTrue(\Drupal::state()->get('update_order_test_update_8002_node__id__default_langcode__langcode', FALSE), 'The node__id__default_langcode__langcode index has been created during update_order_test_update_8002.'); + + // Ensure that the base field created by update_order_test_update_8002 is + // created when we expect it to. + $this->assertFalse(\Drupal::state()->get('update_order_test_update_8002_update_order_test_before', TRUE), 'The update_order_test field has not been created on Node before update_order_test_update_8002.'); + $this->assertTrue(\Drupal::state()->get('update_order_test_update_8002_update_order_test_after', FALSE), 'The update_order_test field has been created on Node by update_order_test_update_8002.'); + + // User update has not run during update_order_test_update_8002. + $this->assertFalse(\Drupal::state()->get('update_order_test_update_8002_user__id__default_langcode__langcode', TRUE)); } } diff --git a/core/modules/system/tests/modules/update_order_test/update_order_test.info.yml b/core/modules/system/tests/modules/update_order_test/update_order_test.info.yml new file mode 100644 index 0000000..22aa179 --- /dev/null +++ b/core/modules/system/tests/modules/update_order_test/update_order_test.info.yml @@ -0,0 +1,6 @@ +name: 'Update order test' +type: module +description: 'Support module for update testing.' +package: Testing +version: VERSION +core: 8.x diff --git a/core/modules/system/tests/modules/update_order_test/update_order_test.install b/core/modules/system/tests/modules/update_order_test/update_order_test.install new file mode 100644 index 0000000..4feb74a --- /dev/null +++ b/core/modules/system/tests/modules/update_order_test/update_order_test.install @@ -0,0 +1,40 @@ +get('update_order_test', FALSE)) { + + /** + * Runs before entity schema updates. + */ + function update_order_test_update_8001() { + \Drupal::state()->set('update_order_test_update_8001', db_index_exists('node_field_data', 'node__default_langcode')); + } + + /** + * Runs before entity schema updates. + */ + function update_order_test_update_8002() { + \Drupal::state()->set('update_order_test_update_8002_update_order_test_before', db_field_exists('node_field_data', 'update_order_test')); + if (\Drupal::service('entity.definition_update_manager')->applyFieldUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_CREATED, 'node', 'update_order_test')) { + \Drupal::state()->set('update_order_test_update_8002_update_order_test_after', db_field_exists('node_field_data', 'update_order_test')); + } + + if (\Drupal::service('entity.definition_update_manager')->applyEntityUpdate(EntityDefinitionUpdateManagerInterface::DEFINITION_UPDATED, 'node')) { + // Node update has run. + \Drupal::state()->set('update_order_test_update_8002_node__default_langcode', db_index_exists('node_field_data', 'node__default_langcode')); + \Drupal::state()->set('update_order_test_update_8002_node__id__default_langcode__langcode', db_index_exists('node_field_data', 'node__id__default_langcode__langcode')); + // User update has not run. + \Drupal::state()->set('update_order_test_update_8002_user__id__default_langcode__langcode', db_index_exists('users_field_data', 'user__id__default_langcode__langcode')); + } + } + +} diff --git a/core/modules/system/tests/modules/update_order_test/update_order_test.module b/core/modules/system/tests/modules/update_order_test/update_order_test.module new file mode 100644 index 0000000..4a56cbc --- /dev/null +++ b/core/modules/system/tests/modules/update_order_test/update_order_test.module @@ -0,0 +1,27 @@ +get('update_order_test', FALSE)) { + + /** + * Implements hook_entity_base_field_info(). + */ + function update_order_test_entity_base_field_info(EntityTypeInterface $entity_type) { + if ($entity_type->id() === 'node') { + $fields['update_order_test'] = BaseFieldDefinition::create('integer') + ->setLabel(t('Update order test')); + return $fields; + } + } + +} diff --git a/core/profiles/minimal/src/Tests/MinimalTest.php b/core/profiles/minimal/src/Tests/MinimalTest.php index d70c097..bfc4e19 100644 --- a/core/profiles/minimal/src/Tests/MinimalTest.php +++ b/core/profiles/minimal/src/Tests/MinimalTest.php @@ -34,5 +34,10 @@ function testMinimal() { $this->drupalGet(''); $this->assertText(t('Tools')); $this->assertText(t('Administration')); + + // Ensure that there are no pending updates after installation. + $this->drupalLogin($this->rootUser); + $this->drupalGet('update.php/selection'); + $this->assertText('No pending updates.'); } } diff --git a/core/profiles/standard/src/Tests/StandardTest.php b/core/profiles/standard/src/Tests/StandardTest.php index 19b703e..ee867d1 100644 --- a/core/profiles/standard/src/Tests/StandardTest.php +++ b/core/profiles/standard/src/Tests/StandardTest.php @@ -152,6 +152,11 @@ function testStandard() { $this->adminUser->save(); $this->drupalGet('node/add'); $this->assertResponse(200); + + // Ensure that there are no pending updates after installation. + $this->drupalLogin($this->rootUser); + $this->drupalGet('update.php/selection'); + $this->assertText('No pending updates.'); } } diff --git a/core/profiles/standard/standard.install b/core/profiles/standard/standard.install index fd339b8..4d4416a 100644 --- a/core/profiles/standard/standard.install +++ b/core/profiles/standard/standard.install @@ -16,12 +16,6 @@ * @see system_install() */ function standard_install() { - // Now that all modules are installed, make sure the entity storage and other - // handlers are up to date with the current entity and field definitions. For - // example, Path module adds a base field to nodes and taxonomy terms after - // those modules are already installed. - \Drupal::service('entity.definition_update_manager')->applyUpdates(); - // Set front page to "node". \Drupal::configFactory()->getEditable('system.site')->set('page.front', '/node')->save(TRUE);