PageUpdater.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use InvalidArgumentException;
use LogicException;
use MediaWiki\CommentStore\CommentStoreComment;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Content\Content;
use MediaWiki\Content\ContentHandler;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\Content\ValidationParams;
use MediaWiki\Deferred\AtomicSectionUpdate;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Logging\ManualLogEntry;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\Event\PageLatestRevisionChangedEvent;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\WikiPage;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\Revision\MutableRevisionRecord;
use MediaWiki\Revision\RevisionAccessException;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRecord;
use MediaWiki\Revision\SlotRoleRegistry;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleFormatter;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserIdentity;
use Psr\Log\LoggerInterface;
use RuntimeException;
use Wikimedia\Assert\Assert;
use Wikimedia\NormalizedException\NormalizedException;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\IDBAccessObject;
 
class PageUpdater implements PageUpdateCauses {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::ManualRevertSearchRadius,
        MainConfigNames::UseRCPatrol,
    ];
 
    private readonly WikiPage $wikiPage;
    private readonly HookRunner $hookRunner;
 
    private $useAutomaticEditSummaries = true;
 
    private $rcPatrolStatus = RecentChange::PRC_UNPATROLLED;
 
    private $usePageCreationLog = true;
 
    private $forceEmptyRevision = false;
 
    private $preventChange = false;
 
    private $tags = [];
 
    private readonly RevisionSlotsUpdate $slotsUpdate;
 
    private $status = null;
 
    private readonly EditResultBuilder $editResultBuilder;
 
    private $editResult = null;
 
    private $flags = 0;
 
    private array $hints = [];
 
    public function __construct(
        private UserIdentity $author,
        private readonly PageIdentity $pageIdentity,
        private readonly DerivedPageDataUpdater $derivedDataUpdater,
        private readonly IConnectionProvider $dbProvider,
        private readonly RevisionStore $revisionStore,
        private readonly SlotRoleRegistry $slotRoleRegistry,
        private readonly IContentHandlerFactory $contentHandlerFactory,
        private readonly HookContainer $hookContainer,
        private readonly UserGroupManager $userGroupManager,
        private readonly TitleFormatter $titleFormatter,
        private readonly ServiceOptions $serviceOptions,
        private readonly array $softwareTags,
        private readonly LoggerInterface $logger,
        WikiPageFactory $wikiPageFactory,
    ) {
        $serviceOptions->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
 
        $this->wikiPage = $wikiPageFactory->newFromTitle( $pageIdentity );
        $this->derivedDataUpdater->setCause( self::CAUSE_EDIT );
 
        $this->hookRunner = new HookRunner( $hookContainer );
 
        $this->slotsUpdate = new RevisionSlotsUpdate();
        $this->editResultBuilder = new EditResultBuilder(
            $revisionStore,
            $softwareTags,
            new ServiceOptions(
                EditResultBuilder::CONSTRUCTOR_OPTIONS,
                [
                    MainConfigNames::ManualRevertSearchRadius =>
                        $serviceOptions->get( MainConfigNames::ManualRevertSearchRadius )
                ]
            )
        );
    }
 
    public function setCause( string $cause ): self {
        $this->derivedDataUpdater->setCause( $cause );
        return $this;
    }
 
    public function setHints( array $hints ): self {
        $this->hints = $hints + $this->hints;
        return $this;
    }
 
    public function setFlags( int $flags ) {
        $this->flags |= $flags;
        return $this;
    }
 
    public function prepareUpdate( int $flags = 0 ): PreparedUpdate {
        $this->setFlags( $flags );
 
        // Load the data from the primary database if needed. Needed to check flags.
        $this->grabParentRevision();
        if ( !$this->derivedDataUpdater->isUpdatePrepared() ) {
            // Avoid statsd noise and wasted cycles check the edit stash (T136678)
            $useStashed = !( ( $this->flags & EDIT_INTERNAL ) || ( $this->flags & EDIT_FORCE_BOT ) );
            // Prepare the update. This performs PST and generates the canonical ParserOutput.
            $this->derivedDataUpdater->prepareContent(
                $this->author,
                $this->slotsUpdate,
                $useStashed
            );
        }
 
        return $this->derivedDataUpdater;
    }
 
    public function updateAuthor( UserIdentity $author ) {
        if ( $this->author->getName() !== $author->getName() ) {
            throw new InvalidArgumentException( 'Cannot replace the author with an author ' .
                'of a different name, since DerivedPageDataUpdater may have stored the ' .
                'old name.' );
        }
        $this->author = $author;
    }
 
    public function setUseAutomaticEditSummaries( $useAutomaticEditSummaries ) {
        $this->useAutomaticEditSummaries = $useAutomaticEditSummaries;
        return $this;
    }
 
    public function setRcPatrolStatus( $status ) {
        $this->rcPatrolStatus = $status;
        return $this;
    }
 
    public function setUsePageCreationLog( $use ) {
        $this->usePageCreationLog = $use;
        return $this;
    }
 
    public function setForceEmptyRevision( bool $forceEmptyRevision ): self {
        $this->forceEmptyRevision = $forceEmptyRevision;
 
        if ( $forceEmptyRevision ) {
            // XXX: throw if there is no current/parent revision?
            $original = $this->grabParentRevision();
            $this->setOriginalRevisionId( $original ? $original->getId() : false );
        }
 
        $this->derivedDataUpdater->setForceEmptyRevision( $forceEmptyRevision );
        return $this;
    }
 
    private function getWikiId() {
        return $this->revisionStore->getWikiId();
    }
 
    public function getPage(): PageIdentity {
        return $this->pageIdentity;
    }
 
    private function getTitle() {
        // NOTE: eventually, this won't use WikiPage any more
        return $this->wikiPage->getTitle();
    }
 
    private function getWikiPage() {
        // NOTE: eventually, this won't use WikiPage any more
        return $this->wikiPage;
    }
 
    public function hasEditConflict( $expectedParentRevision ) {
        $parent = $this->grabParentRevision();
        $parentId = $parent ? $parent->getId() : 0;
 
        return $parentId !== $expectedParentRevision;
    }
 
    public function grabParentRevision() {
        return $this->derivedDataUpdater->grabLatestRevision();
    }
 
    public function setContent( $role, Content $content ) {
        $this->ensureRoleAllowed( $role );
 
        $this->slotsUpdate->modifyContent( $role, $content );
        return $this;
    }
 
    public function setSlot( SlotRecord $slot ) {
        $this->ensureRoleAllowed( $slot->getRole() );
 
        $this->slotsUpdate->modifySlot( $slot );
        return $this;
    }
 
    public function inheritSlot( SlotRecord $originalSlot ) {
        // NOTE: slots can be inherited even if the role is not "allowed" on the title.
        // NOTE: this slot is inherited from some other revision, but it's
        // a "modified" slot for the RevisionSlotsUpdate and DerivedPageDataUpdater,
        // since it's not implicitly inherited from the parent revision.
        $inheritedSlot = SlotRecord::newInherited( $originalSlot );
        $this->slotsUpdate->modifySlot( $inheritedSlot );
        return $this;
    }
 
    public function removeSlot( $role ) {
        $this->ensureRoleNotRequired( $role );
 
        $this->slotsUpdate->removeSlot( $role );
    }
 
    public function setOriginalRevisionId( $originalRevId ) {
        $this->editResultBuilder->setOriginalRevision( $originalRevId );
        return $this;
    }
 
    public function markAsRevert(
        int $revertMethod,
        int $newestRevertedRevId,
        ?int $revertAfterRevId = null
    ) {
        $this->editResultBuilder->markAsRevert(
            $revertMethod, $newestRevertedRevId, $revertAfterRevId
        );
        return $this;
    }
 
    public function getEditResult(): ?EditResult {
        return $this->editResult;
    }
 
    public function addTag( string $tag ) {
        $this->tags[] = trim( $tag );
        return $this;
    }
 
    public function addTags( array $tags ) {
        Assert::parameterElementType( 'string', $tags, '$tags' );
        foreach ( $tags as $tag ) {
            $this->addTag( $tag );
        }
        return $this;
    }
 
    public function addSoftwareTag( string $tag ): self {
        if ( in_array( $tag, $this->softwareTags ) ) {
            $this->addTag( $tag );
        }
        return $this;
    }
 
    public function getExplicitTags() {
        return $this->tags;
    }
 
    private function computeEffectiveTags() {
        $tags = $this->tags;
        $editResult = $this->getEditResult();
 
        foreach ( $this->slotsUpdate->getModifiedRoles() as $role ) {
            $old_content = $this->getParentContent( $role );
 
            $handler = $this->getContentHandler( $role );
            $content = $this->slotsUpdate->getModifiedSlot( $role )->getContent();
 
            // TODO: MCR: Do this for all slots. Also add tags for removing roles!
            $tag = $handler->getChangeTag( $old_content, $content, $this->flags );
            // If there is no applicable tag, null is returned, so we need to check
            if ( $tag ) {
                $tags[] = $tag;
            }
        }
 
        $tags = array_merge( $tags, $editResult->getRevertTags() );
 
        return array_unique( $tags );
    }
 
    private function getParentContent( $role ) {
        $parent = $this->grabParentRevision();
 
        if ( $parent && $parent->hasSlot( $role ) ) {
            return $parent->getContent( $role, RevisionRecord::RAW );
        }
 
        return null;
    }
 
    private function getContentHandler( $role ) {
        if ( $this->slotsUpdate->isModifiedSlot( $role ) ) {
            $slot = $this->slotsUpdate->getModifiedSlot( $role );
        } else {
            $parent = $this->grabParentRevision();
 
            if ( $parent ) {
                $slot = $parent->getSlot( $role, RevisionRecord::RAW );
            } else {
                throw new RevisionAccessException(
                    'No such slot: {role}',
                    [ 'role' => $role ]
                );
            }
        }
 
        return $this->contentHandlerFactory->getContentHandler( $slot->getModel() );
    }
 
    private function makeAutoSummary() {
        if ( !$this->useAutomaticEditSummaries || ( $this->flags & EDIT_AUTOSUMMARY ) === 0 ) {
            return CommentStoreComment::newUnsavedComment( '' );
        }
 
        // NOTE: this generates an auto-summary for SOME RANDOM changed slot!
        // TODO: combine auto-summaries for multiple slots!
        // XXX: this logic should not be in the storage layer!
        $roles = $this->slotsUpdate->getModifiedRoles();
        $role = reset( $roles );
 
        if ( $role === false ) {
            return CommentStoreComment::newUnsavedComment( '' );
        }
 
        $handler = $this->getContentHandler( $role );
        $content = $this->slotsUpdate->getModifiedSlot( $role )->getContent();
        $old_content = $this->getParentContent( $role );
        $summary = $handler->getAutosummary( $old_content, $content, $this->flags );
 
        return CommentStoreComment::newUnsavedComment( $summary );
    }
 
    public function saveDummyRevision( $summary, int $flags = 0 ) {
        $flags |= EDIT_UPDATE | EDIT_INTERNAL | EDIT_IMPLICIT;
 
        $this->setForceEmptyRevision( true );
        $rev = $this->saveRevision( $summary, $flags );
 
        if ( $rev === null ) {
            throw new NormalizedException( 'Failed to create dummy revision on ' .
                '{page} (page ID {id})',
                [
                    'page' => (string)$this->getPage(),
                    'id' => (string)$this->getPage()->getId(),
                ]
            );
        }
 
        return $rev;
    }
 
    public function saveRevision( $summary, int $flags = 0 ) {
        Assert::parameterType(
            [ 'string', CommentStoreComment::class, ],
            $summary,
            '$summary'
        );
 
        if ( is_string( $summary ) ) {
            $summary = CommentStoreComment::newUnsavedComment( $summary );
        }
 
        $this->setFlags( $flags );
 
        if ( $this->wasCommitted() ) {
            throw new RuntimeException(
                'saveRevision() or updateRevision() has already been called on this PageUpdater!'
            );
        }
 
        // Low-level check
        if ( $this->getPage()->getDBkey() === '' ) {
            throw new RuntimeException( 'Something is trying to edit an article with an empty title' );
        }
 
        // NOTE: slots can be inherited even if the role is not "allowed" on the title.
        $status = PageUpdateStatus::newGood();
        $this->checkAllRolesAllowed(
            $this->slotsUpdate->getModifiedRoles(),
            $status
        );
        $this->checkNoRolesRequired(
            $this->slotsUpdate->getRemovedRoles(),
            $status
        );
 
        if ( !$status->isOK() ) {
            return null;
        }
 
        // Make sure the given content is allowed in the respective slots of this page
        foreach ( $this->slotsUpdate->getModifiedRoles() as $role ) {
            $slot = $this->slotsUpdate->getModifiedSlot( $role );
            $roleHandler = $this->slotRoleRegistry->getRoleHandler( $role );
 
            if ( !$roleHandler->isAllowedModel( $slot->getModel(), $this->getPage() ) ) {
                $contentHandler = $this->contentHandlerFactory
                    ->getContentHandler( $slot->getModel() );
                $this->status = PageUpdateStatus::newFatal( 'content-not-allowed-here',
                    ContentHandler::getLocalizedName( $contentHandler->getModelID() ),
                    $this->titleFormatter->getPrefixedText( $this->getPage() ),
                    wfMessage( $roleHandler->getNameMessageKey() )
                    // TODO: defer message lookup to caller
                );
                return null;
            }
        }
 
        // Load the data from the primary database if needed. Needed to check flags.
        // NOTE: This grabs the parent revision as the CAS token, if grabParentRevision
        // wasn't called yet. If the page is modified by another process before we are done with
        // it, this method must fail (with status 'edit-conflict')!
        // NOTE: The parent revision may be different from the edit's base revision.
        $this->prepareUpdate();
 
        // Detect whether update or creation should be performed.
        if ( !( $this->flags & EDIT_NEW ) && !( $this->flags & EDIT_UPDATE ) ) {
            $this->flags |= ( $this->derivedDataUpdater->pageExisted() ) ? EDIT_UPDATE : EDIT_NEW;
        }
 
        // Trigger pre-save hook (using provided edit summary)
        $renderedRevision = $this->derivedDataUpdater->getRenderedRevision();
        $hookStatus = PageUpdateStatus::newGood( [] );
        $allowedByHook = $this->hookRunner->onMultiContentSave(
            $renderedRevision, $this->author, $summary, $this->flags, $hookStatus
        );
 
        if ( !$allowedByHook ) {
            // The hook has prevented this change from being saved.
            if ( $hookStatus->isOK() ) {
                // Hook returned false but didn't call fatal(); use generic message
                $hookStatus->fatal( 'edit-hook-aborted' );
            }
 
            $this->status = $hookStatus;
            $this->logger->info( 'Hook prevented page save', [ 'status' => $hookStatus ] );
            return null;
        }
 
        // Provide autosummaries if one is not provided and autosummaries are enabled
        // XXX: $summary == null seems logical, but the empty string may actually come from the user
        // XXX: Move this logic out of the storage layer! It does not belong here! Use a callback?
        if ( $summary->text === '' && $summary->data === null ) {
            $summary = $this->makeAutoSummary();
        }
 
        // Actually create the revision and create/update the page.
        // Do NOT yet set $this->status!
        if ( $this->flags & EDIT_UPDATE ) {
            $status = $this->doModify( $summary );
        } else {
            $status = $this->doCreate( $summary );
        }
 
        // Promote user to any groups they meet the criteria for
        DeferredUpdates::addCallableUpdate( function () {
            $this->userGroupManager->addUserToAutopromoteOnceGroups( $this->author, 'onEdit' );
            // Also run 'onView' for backwards compatibility
            $this->userGroupManager->addUserToAutopromoteOnceGroups( $this->author, 'onView' );
        } );
 
        // NOTE: set $this->status only after all hooks have been called,
        // so wasCommitted doesn't return true when called indirectly from a hook handler!
        $this->status = $status;
 
        // TODO: replace bad status with Exceptions!
        return $this->status
            ? $this->status->getNewRevision()
            : null;
    }
 
    public function updateRevision( int $revId = 0 ) {
        if ( $this->wasCommitted() ) {
            throw new RuntimeException(
                'saveRevision() or updateRevision() has already been called on this PageUpdater!'
            );
        }
 
        // Low-level check
        if ( $this->getPage()->getDBkey() === '' ) {
            throw new RuntimeException( 'Something is trying to edit an article with an empty title' );
        }
 
        $status = PageUpdateStatus::newGood();
        $this->checkAllRolesAllowed(
            $this->slotsUpdate->getModifiedRoles(),
            $status
        );
        $this->checkAllRolesDerived(
            $this->slotsUpdate->getModifiedRoles(),
            $status
        );
        $this->checkAllRolesDerived(
            $this->slotsUpdate->getRemovedRoles(),
            $status
        );
 
        if ( $revId === 0 ) {
            $revision = $this->grabParentRevision();
        } else {
            $revision = $this->revisionStore->getRevisionById( $revId, IDBAccessObject::READ_LATEST );
        }
        if ( $revision === null ) {
            $status->fatal( 'edit-gone-missing' );
        }
 
        if ( !$status->isOK() ) {
            $this->status = $status;
            return;
        }
 
        // Make sure the given content is allowed in the respective slots of this page
        foreach ( $this->slotsUpdate->getModifiedRoles() as $role ) {
            $slot = $this->slotsUpdate->getModifiedSlot( $role );
            $roleHandler = $this->slotRoleRegistry->getRoleHandler( $role );
 
            if ( !$roleHandler->isAllowedModel( $slot->getModel(), $this->getPage() ) ) {
                $contentHandler = $this->contentHandlerFactory
                    ->getContentHandler( $slot->getModel() );
                $this->status = PageUpdateStatus::newFatal(
                    'content-not-allowed-here',
                    ContentHandler::getLocalizedName( $contentHandler->getModelID() ),
                    $this->titleFormatter->getPrefixedText( $this->getPage() ),
                    wfMessage( $roleHandler->getNameMessageKey() )
                // TODO: defer message lookup to caller
                );
                return;
            }
        }
 
        // XXX: do we need PST?
 
        // @phan-suppress-next-line PhanTypeMismatchArgumentNullable revision is checked
        $this->status = $this->doUpdate( $revision );
    }
 
    public function wasCommitted() {
        return $this->status !== null;
    }
 
    public function getStatus(): PageUpdateStatus {
        if ( !$this->status ) {
            throw new LogicException(
                'getStatus() is undefined before saveRevision() or updateRevision() have been called'
            );
        }
        return $this->status;
    }
 
    public function wasSuccessful() {
        return $this->status && $this->status->isOK();
    }
 
    public function isNew() {
        return $this->status && $this->status->wasPageCreated();
    }
 
    public function isUnchanged() {
        return !$this->wasRevisionCreated();
    }
 
    public function isChange() {
        return $this->derivedDataUpdater->isChange();
    }
 
    public function preventChange() {
        $this->preventChange = true;
        return $this;
    }
 
    public function wasRevisionCreated(): bool {
        return $this->status
            && $this->status->wasRevisionCreated();
    }
 
    public function getNewRevision() {
        return $this->status
            ? $this->status->getNewRevision()
            : null;
    }
 
    private function makeNewRevision(
        CommentStoreComment $comment,
        PageUpdateStatus $status
    ) {
        $title = $this->getTitle();
        $parent = $this->grabParentRevision();
 
        // XXX: we expect to get a MutableRevisionRecord here, but that's a bit brittle!
        // TODO: introduce something like an UnsavedRevisionFactory service instead!
        $rev = $this->derivedDataUpdater->getRevision();
        '@phan-var MutableRevisionRecord $rev';
 
        // Avoid fatal error when the Title's ID changed, T204793
        if (
            $rev->getPageId() !== null && $title->exists()
            && $rev->getPageId() !== $title->getArticleID()
        ) {
            $titlePageId = $title->getArticleID();
            $revPageId = $rev->getPageId();
            $masterPageId = $title->getArticleID( IDBAccessObject::READ_LATEST );
 
            if ( $revPageId === $masterPageId ) {
                wfWarn( __METHOD__ . ": Encountered stale Title object: old ID was $titlePageId, "
                    . "continuing with new ID from primary DB, $masterPageId" );
            } else {
                throw new InvalidArgumentException(
                    "Revision inherited page ID $revPageId from its parent, "
                    . "but the provided Title object belongs to page ID $masterPageId"
                );
            }
        }
 
        if ( $parent ) {
            $oldid = $parent->getId();
            $rev->setParentId( $oldid );
 
            if ( $title->getArticleID() !== $parent->getPageId() ) {
                wfWarn( __METHOD__ . ': Encountered stale Title object with no page ID! '
                    . 'Using page ID from parent revision: ' . $parent->getPageId() );
            }
        } else {
            $oldid = 0;
        }
 
        $rev->setComment( $comment );
        $rev->setUser( $this->author );
        $rev->setMinorEdit( ( $this->flags & EDIT_MINOR ) > 0 );
 
        foreach ( $rev->getSlots()->getSlots() as $slot ) {
            $content = $slot->getContent();
 
            // XXX: We may push this up to the "edit controller" level, see T192777.
            $contentHandler = $this->contentHandlerFactory->getContentHandler( $content->getModel() );
            // @phan-suppress-next-line PhanTypeMismatchArgumentNullable getId is not null here
            $validationParams = new ValidationParams( $this->getPage(), $this->flags, $oldid );
            $prepStatus = $contentHandler->validateSave( $content, $validationParams );
 
            // TODO: MCR: record which problem arose in which slot.
            $status->merge( $prepStatus );
        }
 
        $this->checkAllRequiredRoles(
            $rev->getSlotRoles(),
            $status
        );
 
        return $rev;
    }
 
    private function buildEditResult( RevisionRecord $revision, bool $isNew ) {
        $this->editResultBuilder->setRevisionRecord( $revision );
        $this->editResultBuilder->setIsNew( $isNew );
        $this->editResult = $this->editResultBuilder->buildEditResult();
    }
 
    private function doUpdate( RevisionRecord $revision ): PageUpdateStatus {
        $currentRevision = $this->grabParentRevision();
        if ( !$currentRevision ) {
            // Article gone missing
            return PageUpdateStatus::newFatal( 'edit-gone-missing' );
        }
 
        $dbw = $this->dbProvider->getPrimaryDatabase( $this->getWikiId() );
        $dbw->startAtomic( __METHOD__ );
 
        $slots = $this->revisionStore->updateSlotsOn( $revision, $this->slotsUpdate, $dbw );
 
        // Return the slots and revision to the caller
        $newRevisionRecord = MutableRevisionRecord::newUpdatedRevisionRecord( $revision, $slots );
        $status = PageUpdateStatus::newGood( [
            'revision-record' => $newRevisionRecord,
            'slots' => $slots,
        ] );
 
        $isCurrent = $revision->getId( $this->getWikiId() ) ===
            $currentRevision->getId( $this->getWikiId() );
 
        if ( $isCurrent ) {
            // Update page_touched
            $this->getTitle()->invalidateCache( $newRevisionRecord->getTimestamp() );
 
            $this->buildEditResult( $newRevisionRecord, false );
 
            // NOTE: don't trigger a PageLatestRevisionChanged event!
            $wikiPage = $this->getWikiPage(); // TODO: use for legacy hooks only!
            $this->prepareDerivedDataUpdater(
                $newRevisionRecord,
                [],
                [
                    PageLatestRevisionChangedEvent::FLAG_SILENT => true,
                    PageLatestRevisionChangedEvent::FLAG_IMPLICIT => true,
                    'emitEvents' => false,
                ]
            );
 
            $this->scheduleAtomicSectionUpdate(
                $dbw,
                $wikiPage,
                $newRevisionRecord,
                $revision->getComment(),
                [ 'changed' => false ]
            );
        }
 
        // Mark the earliest point where the transaction round can be committed in CLI mode.
        // We want to make sure that the event was bound to a round of transactions. We also
        // want the deferred update to enqueue similarly in both web and CLI modes, in order
        // to simplify testing assertions.
        $dbw->endAtomic( __METHOD__ );
 
        return $status;
    }
 
    private function doModify( CommentStoreComment $summary ): PageUpdateStatus {
        $wikiPage = $this->getWikiPage(); // TODO: use for legacy hooks only!
 
        // Update article, but only if changed.
        $status = PageUpdateStatus::newEmpty( false );
 
        $oldRev = $this->grabParentRevision();
        $oldid = $oldRev ? $oldRev->getId() : 0;
 
        if ( !$oldRev ) {
            // Article gone missing
            return $status->fatal( 'edit-gone-missing' );
        }
 
        $newRevisionRecord = $this->makeNewRevision(
            $summary,
            $status
        );
 
        if ( !$status->isOK() ) {
            return $status;
        }
 
        $now = $newRevisionRecord->getTimestamp();
 
        $changed = $this->derivedDataUpdater->isChange();
 
        if ( $changed ) {
            if ( $this->forceEmptyRevision ) {
                throw new LogicException(
                    'Content has been changed even though setForceEmptyRevision( true ) was called.'
                );
            }
            if ( $this->preventChange ) {
                throw new LogicException(
                    'Content has been changed even though preventChange() was called.'
                );
            }
        }
 
        // We build the EditResult before the $change if/else branch in order to pass
        // the correct $newRevisionRecord to EditResultBuilder. In case this is a null
        // edit, $newRevisionRecord will be later overridden to its parent revision, which
        // would confuse EditResultBuilder.
        if ( !$changed ) {
            // This is a null edit, ensure original revision ID is set properly
            $this->editResultBuilder->setOriginalRevision( $oldRev );
        }
        $this->buildEditResult( $newRevisionRecord, false );
 
        $dbw = $this->dbProvider->getPrimaryDatabase( $this->getWikiId() );
        $dbw->startAtomic( __METHOD__ );
 
        if ( $changed || $this->forceEmptyRevision ) {
            // Get the latest page_latest value while locking it.
            // Do a CAS style check to see if it's the same as when this method
            // started. If it changed then bail out before touching the DB.
            $latestNow = $wikiPage->lockAndGetLatest(); // TODO: move to storage service, pass DB
            if ( $latestNow != $oldid ) {
                // We don't need to roll back, since we did not modify the database yet.
                // XXX: Or do we want to rollback, any transaction started by calling
                // code will fail? If we want that, we should probably throw an exception.
                $dbw->endAtomic( __METHOD__ );
 
                // Page updated or deleted in the mean time
                return $status->fatal( 'edit-conflict' );
            }
 
            // At this point we are now committed to returning an OK
            // status unless some DB query error or other exception comes up.
            // This way callers don't have to call rollback() if $status is bad
            // unless they actually try to catch exceptions (which is rare).
 
            // Save revision content and meta-data
            $newRevisionRecord = $this->revisionStore->insertRevisionOn( $newRevisionRecord, $dbw );
 
            // Update page_latest and friends to reflect the new revision
            // TODO: move to storage service
            $wasRedirect = $this->derivedDataUpdater->wasRedirect();
            if ( !$wikiPage->updateRevisionOn( $dbw, $newRevisionRecord, null, $wasRedirect ) ) {
                throw new PageUpdateException( 'Failed to update page row to use new revision.' );
            }
 
            $editResult = $this->getEditResult();
            $tags = $this->computeEffectiveTags();
 
            if ( !$this->updatesSuppressed() ) {
                $this->hookRunner->onRevisionFromEditComplete(
                    $wikiPage,
                    $newRevisionRecord,
                    $editResult->getOriginalRevisionId(),
                    $this->author,
                    $tags
                );
            }
 
            $this->prepareDerivedDataUpdater(
                $newRevisionRecord,
                $tags
            );
 
            // Return the new revision to the caller
            $status->setNewRevision( $newRevisionRecord );
 
            // Notify the dispatcher of the PageLatestRevisionChangedEvent during the transaction round
            $this->emitEvents();
        } else {
            // T34948: revision ID must be set to page {{REVISIONID}} and
            // related variables correctly. Likewise for {{REVISIONUSER}} (T135261).
            // Since we don't insert a new revision into the database, the least
            // error-prone way is to reuse given old revision.
            $newRevisionRecord = $oldRev;
 
            $this->prepareDerivedDataUpdater(
                $newRevisionRecord,
                [],
                [ 'changed' => false ]
            );
 
            $status->warning( 'edit-no-change' );
            // Update page_touched as updateRevisionOn() was not called.
            // Other cache updates are managed in WikiPage::onArticleEdit()
            // via WikiPage::doEditUpdates().
            $this->getTitle()->invalidateCache( $now );
 
            // Notify the dispatcher of the PageLatestRevisionChangedEvent during the transaction round
            $this->emitEvents();
        }
 
        // Schedule the secondary updates to run after the transaction round commits.
        // NOTE: the updates have to be processed before sending the response to the client
        // (DeferredUpdates::PRESEND), otherwise the client may already be following the
        // HTTP redirect to the standard view before derived data has been created - most
        // importantly, before the parser cache has been updated. This would cause the
        // content to be parsed a second time, or may cause stale content to be shown.
        $this->scheduleAtomicSectionUpdate(
            $dbw,
            $wikiPage,
            $newRevisionRecord,
            $summary,
            [ 'changed' => $changed, ]
        );
 
        // Mark the earliest point where the transaction round can be committed in CLI mode.
        // We want to make sure that the event was bound to a round of transactions. We also
        // want the deferred update to enqueue similarly in both web and CLI modes, in order
        // to simplify testing assertions.
        $dbw->endAtomic( __METHOD__ );
 
        return $status;
    }
 
    private function doCreate( CommentStoreComment $summary ): PageUpdateStatus {
        if ( $this->preventChange ) {
            throw new LogicException(
                'Content was changed even though preventChange is true.'
            );
        }
        $wikiPage = $this->getWikiPage(); // TODO: use for legacy hooks only!
 
        if ( !$this->derivedDataUpdater->getSlots()->hasSlot( SlotRecord::MAIN ) ) {
            throw new PageUpdateException( 'Must provide a main slot when creating a page!' );
        }
 
        $status = PageUpdateStatus::newEmpty( true );
 
        $newRevisionRecord = $this->makeNewRevision(
            $summary,
            $status
        );
 
        if ( !$status->isOK() ) {
            return $status;
        }
 
        $this->buildEditResult( $newRevisionRecord, true );
        $now = $newRevisionRecord->getTimestamp();
 
        $dbw = $this->dbProvider->getPrimaryDatabase( $this->getWikiId() );
        $dbw->startAtomic( __METHOD__ );
 
        // Add the page record unless one already exists for the title
        // TODO: move to storage service
        $newid = $wikiPage->insertOn( $dbw );
        if ( $newid === false ) {
            $dbw->endAtomic( __METHOD__ );
            return $status->fatal( 'edit-already-exists' );
        }
 
        // At this point we are now committed to returning an OK
        // status unless some DB query error or other exception comes up.
        // This way callers don't have to call rollback() if $status is bad
        // unless they actually try to catch exceptions (which is rare).
        $newRevisionRecord->setPageId( $newid );
 
        // Save the revision text...
        $newRevisionRecord = $this->revisionStore->insertRevisionOn( $newRevisionRecord, $dbw );
 
        // Update the page record with revision data
        // TODO: move to storage service
        if ( !$wikiPage->updateRevisionOn( $dbw, $newRevisionRecord, 0, false ) ) {
            throw new PageUpdateException( 'Failed to update page row to use new revision.' );
        }
 
        $tags = $this->computeEffectiveTags();
        if ( !$this->updatesSuppressed() ) {
            $this->hookRunner->onRevisionFromEditComplete(
                $wikiPage, $newRevisionRecord, false, $this->author, $tags
            );
        }
 
        if ( $this->usePageCreationLog ) {
            // Log the page creation
            // @TODO: Do we want a 'recreate' action?
            $logEntry = new ManualLogEntry( 'create', 'create' );
            $logEntry->setPerformer( $this->author );
            $logEntry->setTarget( $this->getPage() );
            $logEntry->setComment( $summary->text );
            $logEntry->setTimestamp( $now );
            $logEntry->setAssociatedRevId( $newRevisionRecord->getId() );
            $logEntry->insert();
            // Note that we don't publish page creation events to recentchanges
            // (i.e. $logEntry->publish()) since this would create duplicate entries,
            // one for the edit and one for the page creation.
        }
 
        $this->prepareDerivedDataUpdater(
            $newRevisionRecord,
            $tags
        );
 
        // Return the new revision to the caller
        $status->setNewRevision( $newRevisionRecord );
 
        // Notify the dispatcher of the PageLatestRevisionChangedEvent during the transaction round
        $this->emitEvents();
 
        // Schedule the secondary updates to run after the transaction round commits
        $this->scheduleAtomicSectionUpdate(
            $dbw,
            $wikiPage,
            $newRevisionRecord,
            $summary,
            [ 'created' => true ]
        );
 
        // Mark the earliest point where the transaction round can be committed in CLI mode.
        // We want to make sure that the event was bound to a round of transactions. We also
        // want the deferred update to enqueue similarly in both web and CLI modes, in order
        // to simplify testing assertions.
        $dbw->endAtomic( __METHOD__ );
 
        return $status;
    }
 
    private function prepareDerivedDataUpdater(
        RevisionRecord $newRevisionRecord,
        array $tags,
        array $hintOverrides = []
    ) {
        static $flagMap = [
            EDIT_SILENT => PageLatestRevisionChangedEvent::FLAG_SILENT,
            EDIT_FORCE_BOT => PageLatestRevisionChangedEvent::FLAG_BOT,
            EDIT_IMPLICIT => PageLatestRevisionChangedEvent::FLAG_IMPLICIT,
        ];
 
        $hints = $this->hints;
        foreach ( $flagMap as $bit => $name ) {
            $hints[$name] = ( $this->flags & $bit ) === $bit;
        }
 
        $hints += PageLatestRevisionChangedEvent::DEFAULT_FLAGS;
        $hints = $hintOverrides + $hints;
 
        // set debug data
        $hints['causeAction'] = 'edit-page';
        $hints['causeAgent'] = $this->author->getName();
 
        $editResult = $this->getEditResult();
        $hints['editResult'] = $editResult;
 
        // Prepare to update links tables, site stats, etc.
        $hints['rcPatrolStatus'] = $this->rcPatrolStatus;
        $hints['tags'] = $tags;
 
        $this->derivedDataUpdater->setPerformer( $this->author );
        $this->derivedDataUpdater->prepareUpdate( $newRevisionRecord, $hints );
    }
 
    private function updatesSuppressed(): bool {
        return $this->hints['suppressDerivedDataUpdates'] ?? false;
    }
 
    private function emitEvents(): void {
        if ( $this->updatesSuppressed() ) {
            return;
        }
 
        $this->derivedDataUpdater->emitEvents();
    }
 
    private function scheduleAtomicSectionUpdate(
        IDatabase $dbw,
        WikiPage $wikiPage,
        RevisionRecord $newRevisionRecord,
        CommentStoreComment $summary,
        array $hints = []
    ): void {
        if ( $this->updatesSuppressed() ) {
            return;
        }
 
        DeferredUpdates::addUpdate(
            $this->getAtomicSectionUpdate(
                $dbw,
                $wikiPage,
                $newRevisionRecord,
                $summary,
                $hints
            ),
            DeferredUpdates::PRESEND
        );
    }
 
    private function getAtomicSectionUpdate(
        IDatabase $dbw,
        WikiPage $wikiPage,
        RevisionRecord $newRevisionRecord,
        CommentStoreComment $summary,
        array $hints = []
    ): AtomicSectionUpdate {
        return new AtomicSectionUpdate(
            $dbw,
            __METHOD__,
            function () use (
                $wikiPage, $newRevisionRecord,
                $summary, $hints
            ) {
                $this->derivedDataUpdater->doUpdates();
 
                $created = $hints['created'] ?? false;
                $this->flags |= ( $created ? EDIT_NEW : EDIT_UPDATE );
 
                // PageSaveComplete replaced old PageContentInsertComplete and
                // PageContentSaveComplete hooks since 1.35
                $this->hookRunner->onPageSaveComplete(
                    $wikiPage,
                    $this->author,
                    $summary->text,
                    $this->flags,
                    $newRevisionRecord,
                    // @phan-suppress-next-line PhanTypeMismatchArgumentNullable Not null already checked
                    $this->getEditResult()
                );
            }
        );
    }
 
    private function getRequiredSlotRoles() {
        return $this->slotRoleRegistry->getRequiredRoles( $this->getPage() );
    }
 
    private function getAllowedSlotRoles() {
        return $this->slotRoleRegistry->getAllowedRoles( $this->getPage() );
    }
 
    private function ensureRoleAllowed( string $role ) {
        $allowedRoles = $this->getAllowedSlotRoles();
        if ( !in_array( $role, $allowedRoles ) ) {
            throw new PageUpdateException( "Slot role `$role` is not allowed." );
        }
    }
 
    private function ensureRoleNotRequired( string $role ) {
        $requiredRoles = $this->getRequiredSlotRoles();
        if ( in_array( $role, $requiredRoles ) ) {
            throw new PageUpdateException( "Slot role `$role` is required." );
        }
    }
 
    private function checkAllRolesAllowed( array $roles, PageUpdateStatus $status ) {
        $allowedRoles = $this->getAllowedSlotRoles();
 
        $forbidden = array_diff( $roles, $allowedRoles );
        if ( $forbidden ) {
            $status->error(
                'edit-slots-cannot-add',
                count( $forbidden ),
                implode( ', ', $forbidden )
            );
        }
    }
 
    private function checkAllRolesDerived( array $roles, PageUpdateStatus $status ) {
        $notDerived = array_filter(
            $roles,
            function ( $role ) {
                return !$this->slotRoleRegistry->getRoleHandler( $role )->isDerived();
            }
        );
        if ( $notDerived ) {
            $status->error(
                'edit-slots-not-derived',
                count( $notDerived ),
                implode( ', ', $notDerived )
            );
        }
    }
 
    private function checkNoRolesRequired( array $roles, PageUpdateStatus $status ) {
        $requiredRoles = $this->getRequiredSlotRoles();
 
        $needed = array_diff( $roles, $requiredRoles );
        if ( $needed ) {
            $status->error(
                'edit-slots-cannot-remove',
                count( $needed ),
                implode( ', ', $needed )
            );
        }
    }
 
    private function checkAllRequiredRoles( array $roles, PageUpdateStatus $status ) {
        $requiredRoles = $this->getRequiredSlotRoles();
 
        $missing = array_diff( $requiredRoles, $roles );
        if ( $missing ) {
            $status->error(
                'edit-slots-missing',
                count( $missing ),
                implode( ', ', $missing )
            );
        }
    }
 
}