3 * A handle for managing updates for derived page data on edit, import, purge, etc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
23 namespace MediaWiki\Storage
;
25 use CategoryMembershipChangeJob
;
33 use InvalidArgumentException
;
36 use LinksDeletionUpdate
;
39 use MediaWiki\Edit\PreparedEdit
;
40 use MediaWiki\MediaWikiServices
;
41 use MediaWiki\Revision\MutableRevisionRecord
;
42 use MediaWiki\Revision\RenderedRevision
;
43 use MediaWiki\Revision\RevisionRecord
;
44 use MediaWiki\Revision\RevisionRenderer
;
45 use MediaWiki\Revision\RevisionSlots
;
46 use MediaWiki\Revision\RevisionStore
;
47 use MediaWiki\Revision\SlotRoleRegistry
;
48 use MediaWiki\Revision\SlotRecord
;
49 use MediaWiki\User\UserIdentity
;
54 use Psr\Log\LoggerAwareInterface
;
55 use Psr\Log\LoggerInterface
;
56 use Psr\Log\NullLogger
;
57 use RecentChangesUpdateJob
;
58 use ResourceLoaderWikiModule
;
64 use Wikimedia\Assert\Assert
;
65 use Wikimedia\Rdbms\LBFactory
;
69 * A handle for managing updates for derived page data on edit, import, purge, etc.
71 * @note Avoid direct usage of DerivedPageDataUpdater.
73 * @todo Define interfaces for the different use cases of DerivedPageDataUpdater, particularly
74 * providing access to post-PST content and ParserOutput to callbacks during revision creation,
75 * which currently use WikiPage::prepareContentForEdit, and allowing updates to be triggered on
76 * purge, import, and undeletion, which currently use WikiPage::doEditUpdates() and
77 * Content::getSecondaryDataUpdates().
79 * DerivedPageDataUpdater instances are designed to be cached inside a WikiPage instance,
80 * and re-used by callback code over the course of an update operation. It's a stepping stone
81 * one the way to a more complete refactoring of WikiPage.
83 * When using a DerivedPageDataUpdater, the following life cycle must be observed:
84 * grabCurrentRevision (optional), prepareContent (optional), prepareUpdate (required
85 * for doUpdates). getCanonicalParserOutput, getSlots, and getSecondaryDataUpdates
86 * require prepareContent or prepareUpdate to have been called first, to initialize the
87 * DerivedPageDataUpdater.
89 * @see docs/pageupdater.txt for more information.
91 * MCR migration note: this replaces the relevant methods in WikiPage, and covers the use cases
99 class DerivedPageDataUpdater
implements IDBAccessObject
, LoggerAwareInterface
{
102 * @var UserIdentity|null
104 private $user = null;
114 private $parserCache;
119 private $revisionStore;
129 private $jobQueueGroup;
134 private $messageCache;
139 private $loadbalancerFactory;
142 * @var LoggerInterface
147 * @var string see $wgArticleCountMethod
149 private $articleCountMethod;
152 * @var boolean see $wgRCWatchCategoryMembership
154 private $rcWatchCategoryMembership = false;
157 * Stores (most of) the $options parameter of prepareUpdate().
158 * @see prepareUpdate()
162 // newrev is true if prepareUpdate is handling the creation of a new revision,
163 // as opposed to a null edit or a forced update.
168 'oldrevision' => null,
169 'oldcountable' => null,
170 'oldredirect' => null,
171 'triggeringUser' => null,
172 // causeAction/causeAgent default to 'unknown' but that's handled where it's read,
173 // to make the life of prepareUpdate() callers easier.
174 'causeAction' => null,
175 'causeAgent' => null,
179 * The state of the relevant row in page table before the edit.
180 * This is determined by the first call to grabCurrentRevision, prepareContent,
181 * or prepareUpdate (so it is only accessible in 'knows-current' or a later stage).
182 * If pageState was not initialized when prepareUpdate() is called, prepareUpdate() will
183 * attempt to emulate the state of the page table before the edit.
185 * Contains the following fields:
186 * - oldRevision (RevisionRecord|null): the revision that was current before the change
187 * associated with this update. Might not be set, use getParentRevision().
188 * - oldId (int|null): the id of the above revision. 0 if there is no such revision (the change
189 * was about creating a new page); null if not known (that should not happen).
190 * - oldIsRedirect (bool|null): whether the page was a redirect before the change. Lazy-loaded,
191 * can be null; use wasRedirect() instead of direct access.
192 * - oldCountable (bool|null): whether the page was countable before the change (or null
193 * if we don't have that information)
197 private $pageState = null;
200 * @var RevisionSlotsUpdate|null
202 private $slotsUpdate = null;
205 * @var RevisionRecord|null
207 private $parentRevision = null;
210 * @var RevisionRecord|null
212 private $revision = null;
215 * @var RenderedRevision
217 private $renderedRevision = null;
220 * @var RevisionRenderer
222 private $revisionRenderer;
224 /** @var SlotRoleRegistry */
225 private $slotRoleRegistry;
228 * A stage identifier for managing the life cycle of this instance.
229 * Possible stages are 'new', 'knows-current', 'has-content', 'has-revision', and 'done'.
231 * @see docs/pageupdater.txt for documentation of the life cycle.
235 private $stage = 'new';
238 * Transition table for managing the life cycle of DerivedPageDateUpdater instances.
240 * XXX: Overkill. This is a linear order, we could just count. Names are nice though,
241 * and constants are also overkill...
243 * @see docs/pageupdater.txt for documentation of the life cycle.
247 private static $transitions = [
250 'knows-current' => true,
251 'has-content' => true,
252 'has-revision' => true,
255 'knows-current' => true,
256 'has-content' => true,
257 'has-revision' => true,
260 'has-content' => true,
261 'has-revision' => true,
264 'has-revision' => true,
270 * @param WikiPage $wikiPage ,
271 * @param RevisionStore $revisionStore
272 * @param RevisionRenderer $revisionRenderer
273 * @param SlotRoleRegistry $slotRoleRegistry
274 * @param ParserCache $parserCache
275 * @param JobQueueGroup $jobQueueGroup
276 * @param MessageCache $messageCache
277 * @param Language $contLang
278 * @param LBFactory $loadbalancerFactory
280 public function __construct(
282 RevisionStore
$revisionStore,
283 RevisionRenderer
$revisionRenderer,
284 SlotRoleRegistry
$slotRoleRegistry,
285 ParserCache
$parserCache,
286 JobQueueGroup
$jobQueueGroup,
287 MessageCache
$messageCache,
289 LBFactory
$loadbalancerFactory
291 $this->wikiPage
= $wikiPage;
293 $this->parserCache
= $parserCache;
294 $this->revisionStore
= $revisionStore;
295 $this->revisionRenderer
= $revisionRenderer;
296 $this->slotRoleRegistry
= $slotRoleRegistry;
297 $this->jobQueueGroup
= $jobQueueGroup;
298 $this->messageCache
= $messageCache;
299 $this->contLang
= $contLang;
300 // XXX only needed for waiting for replicas to catch up; there should be a narrower
301 // interface for that.
302 $this->loadbalancerFactory
= $loadbalancerFactory;
303 $this->logger
= new NullLogger();
306 public function setLogger( LoggerInterface
$logger ) {
307 $this->logger
= $logger;
311 * Transition function for managing the life cycle of this instances.
313 * @see docs/pageupdater.txt for documentation of the life cycle.
315 * @param string $newStage the new stage
316 * @return string the previous stage
318 * @throws LogicException If a transition to the given stage is not possible in the current
321 private function doTransition( $newStage ) {
322 $this->assertTransition( $newStage );
324 $oldStage = $this->stage
;
325 $this->stage
= $newStage;
331 * Asserts that a transition to the given stage is possible, without performing it.
333 * @see docs/pageupdater.txt for documentation of the life cycle.
335 * @param string $newStage the new stage
337 * @throws LogicException If this instance is not in the expected stage
339 private function assertTransition( $newStage ) {
340 if ( empty( self
::$transitions[$this->stage
][$newStage] ) ) {
341 throw new LogicException( "Cannot transition from {$this->stage} to $newStage" );
346 * @return bool|string
348 private function getWikiId() {
349 // TODO: get from RevisionStore
354 * Checks whether this DerivedPageDataUpdater can be re-used for running updates targeting
355 * the given revision.
357 * @param UserIdentity|null $user The user creating the revision in question
358 * @param RevisionRecord|null $revision New revision (after save, if already saved)
359 * @param RevisionSlotsUpdate|null $slotsUpdate New content (before PST)
360 * @param null|int $parentId Parent revision of the edit (use 0 for page creation)
364 public function isReusableFor(
365 UserIdentity
$user = null,
366 RevisionRecord
$revision = null,
367 RevisionSlotsUpdate
$slotsUpdate = null,
372 && $revision->getParentId() !== $parentId
374 throw new InvalidArgumentException( '$parentId should match the parent of $revision' );
377 // NOTE: For null revisions, $user may be different from $this->revision->getUser
378 // and also from $revision->getUser.
379 // But $user should always match $this->user.
380 if ( $user && $this->user
&& $user->getName() !== $this->user
->getName() ) {
384 if ( $revision && $this->revision
&& $this->revision
->getId()
385 && $this->revision
->getId() !== $revision->getId()
390 if ( $this->pageState
392 && $revision->getParentId() !== null
393 && $this->pageState
['oldId'] !== $revision->getParentId()
398 if ( $this->pageState
399 && $parentId !== null
400 && $this->pageState
['oldId'] !== $parentId
405 // NOTE: this check is the primary reason for having the $this->slotsUpdate field!
406 if ( $this->slotsUpdate
408 && !$this->slotsUpdate
->hasSameUpdates( $slotsUpdate )
415 && !$this->revision
->getSlots()->hasSameContent( $revision->getSlots() )
424 * @param string $articleCountMethod "any" or "link".
425 * @see $wgArticleCountMethod
427 public function setArticleCountMethod( $articleCountMethod ) {
428 $this->articleCountMethod
= $articleCountMethod;
432 * @param bool $rcWatchCategoryMembership
433 * @see $wgRCWatchCategoryMembership
435 public function setRcWatchCategoryMembership( $rcWatchCategoryMembership ) {
436 $this->rcWatchCategoryMembership
= $rcWatchCategoryMembership;
442 private function getTitle() {
443 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
444 return $this->wikiPage
->getTitle();
450 private function getWikiPage() {
451 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
452 return $this->wikiPage
;
456 * Determines whether the page being edited already existed.
457 * Only defined after calling grabCurrentRevision() or prepareContent() or prepareUpdate()!
460 * @throws LogicException if called before grabCurrentRevision
462 public function pageExisted() {
463 $this->assertHasPageState( __METHOD__
);
465 return $this->pageState
['oldId'] > 0;
469 * Returns the parent revision of the new revision wrapped by this update.
470 * If the update is a null-edit, this will return the parent of the current (and new) revision.
471 * This will return null if the revision wrapped by this update created the page.
472 * Only defined after calling prepareContent() or prepareUpdate()!
474 * @return RevisionRecord|null the parent revision of the new revision, or null if
475 * the update created the page.
477 private function getParentRevision() {
478 $this->assertPrepared( __METHOD__
);
480 if ( $this->parentRevision
) {
481 return $this->parentRevision
;
484 if ( !$this->pageState
['oldId'] ) {
485 // If there was no current revision, there is no parent revision,
486 // since the page didn't exist.
490 $oldId = $this->revision
->getParentId();
491 $flags = $this->useMaster() ? RevisionStore
::READ_LATEST
: 0;
492 $this->parentRevision
= $oldId
493 ?
$this->revisionStore
->getRevisionById( $oldId, $flags )
496 return $this->parentRevision
;
500 * Returns the revision that was the page's current revision when grabCurrentRevision()
503 * During an edit, that revision will act as the logical parent of the new revision.
505 * Some updates are performed based on the difference between the database state at the
506 * moment this method is first called, and the state after the edit.
508 * @see docs/pageupdater.txt for more information on when thie method can and should be called.
510 * @note After prepareUpdate() was called, grabCurrentRevision() will throw an exception
511 * to avoid confusion, since the page's current revision is then the new revision after
512 * the edit, which was presumably passed to prepareUpdate() as the $revision parameter.
513 * Use getParentRevision() instead to access the revision that is the parent of the
516 * @return RevisionRecord|null the page's current revision, or null if the page does not
519 public function grabCurrentRevision() {
520 if ( $this->pageState
) {
521 return $this->pageState
['oldRevision'];
524 $this->assertTransition( 'knows-current' );
526 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
527 $wikiPage = $this->getWikiPage();
529 // Do not call WikiPage::clear(), since the caller may already have caused page data
530 // to be loaded with SELECT FOR UPDATE. Just assert it's loaded now.
531 $wikiPage->loadPageData( self
::READ_LATEST
);
532 $rev = $wikiPage->getRevision();
533 $current = $rev ?
$rev->getRevisionRecord() : null;
536 'oldRevision' => $current,
537 'oldId' => $rev ?
$rev->getId() : 0,
538 'oldIsRedirect' => $wikiPage->isRedirect(), // NOTE: uses page table
539 'oldCountable' => $wikiPage->isCountable(), // NOTE: uses pagelinks table
542 $this->doTransition( 'knows-current' );
544 return $this->pageState
['oldRevision'];
548 * Whether prepareUpdate() or prepareContent() have been called on this instance.
552 public function isContentPrepared() {
553 return $this->revision
!== null;
557 * Whether prepareUpdate() has been called on this instance.
559 * @note will also return null in case of a null-edit!
563 public function isUpdatePrepared() {
564 return $this->revision
!== null && $this->revision
->getId() !== null;
570 private function getPageId() {
571 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
572 return $this->wikiPage
->getId();
576 * Whether the content is deleted and thus not visible to the public.
580 public function isContentDeleted() {
581 if ( $this->revision
) {
582 // XXX: if that revision is the current revision, this should be skipped
583 return $this->revision
->isDeleted( RevisionRecord
::DELETED_TEXT
);
585 // If the content has not been saved yet, it cannot have been deleted yet.
591 * Returns the slot, modified or inherited, after PST, with no audience checks applied.
593 * @param string $role slot role name
595 * @throws PageUpdateException If the slot is neither set for update nor inherited from the
599 public function getRawSlot( $role ) {
600 return $this->getSlots()->getSlot( $role );
604 * Returns the content of the given slot, with no audience checks.
606 * @throws PageUpdateException If the slot is neither set for update nor inherited from the
608 * @param string $role slot role name
611 public function getRawContent( $role ) {
612 return $this->getRawSlot( $role )->getContent();
616 * Returns the content model of the given slot
618 * @param string $role slot role name
621 private function getContentModel( $role ) {
622 return $this->getRawSlot( $role )->getModel();
626 * @param string $role slot role name
627 * @return ContentHandler
629 private function getContentHandler( $role ) {
630 // TODO: inject something like a ContentHandlerRegistry
631 return ContentHandler
::getForModelID( $this->getContentModel( $role ) );
634 private function useMaster() {
635 // TODO: can we just set a flag to true in prepareContent()?
636 return $this->wikiPage
->wasLoadedFrom( self
::READ_LATEST
);
642 public function isCountable() {
643 // NOTE: Keep in sync with WikiPage::isCountable.
645 if ( !$this->getTitle()->isContentPage() ) {
649 if ( $this->isContentDeleted() ) {
650 // This should be irrelevant: countability only applies to the current revision,
651 // and the current revision is never suppressed.
655 if ( $this->isRedirect() ) {
661 if ( $this->articleCountMethod
=== 'link' ) {
662 // NOTE: it would be more appropriate to determine for each slot separately
663 // whether it has links, and use that information with that slot's
664 // isCountable() method. However, that would break parity with
665 // WikiPage::isCountable, which uses the pagelinks table to determine
666 // whether the current revision has links.
667 $hasLinks = (bool)count( $this->getCanonicalParserOutput()->getLinks() );
670 foreach ( $this->getModifiedSlotRoles() as $role ) {
671 $roleHandler = $this->slotRoleRegistry
->getRoleHandler( $role );
672 if ( $roleHandler->supportsArticleCount() ) {
673 $content = $this->getRawContent( $role );
675 if ( $content->isCountable( $hasLinks ) ) {
687 public function isRedirect() {
688 // NOTE: main slot determines redirect status
689 // TODO: MCR: this should be controlled by a PageTypeHandler
690 $mainContent = $this->getRawContent( SlotRecord
::MAIN
);
692 return $mainContent->isRedirect();
696 * @param RevisionRecord $rev
700 private function revisionIsRedirect( RevisionRecord
$rev ) {
701 // NOTE: main slot determines redirect status
702 $mainContent = $rev->getContent( SlotRecord
::MAIN
, RevisionRecord
::RAW
);
704 return $mainContent->isRedirect();
708 * Prepare updates based on an update which has not yet been saved.
710 * This may be used to create derived data that is needed when creating a new revision;
711 * particularly, this makes available the slots of the new revision via the getSlots()
712 * method, after applying PST and slot inheritance.
714 * The derived data prepared for revision creation may then later be re-used by doUpdates(),
715 * without the need to re-calculate.
717 * @see docs/pageupdater.txt for more information on when thie method can and should be called.
719 * @note Calling this method more than once with the same $slotsUpdate
720 * has no effect. Calling this method multiple times with different content will cause
723 * @note Calling this method after prepareUpdate() has been called will cause an exception.
725 * @param User $user The user to act as context for pre-save transformation (PST).
726 * Type hint should be reduced to UserIdentity at some point.
727 * @param RevisionSlotsUpdate $slotsUpdate The new content of the slots to be updated
728 * by this edit, before PST.
729 * @param bool $useStash Whether to use stashed ParserOutput
731 public function prepareContent(
733 RevisionSlotsUpdate
$slotsUpdate,
736 if ( $this->slotsUpdate
) {
737 if ( !$this->user
) {
738 throw new LogicException(
739 'Unexpected state: $this->slotsUpdate was initialized, '
740 . 'but $this->user was not.'
744 if ( $this->user
->getName() !== $user->getName() ) {
745 throw new LogicException( 'Can\'t call prepareContent() again for different user! '
746 . 'Expected ' . $this->user
->getName() . ', got ' . $user->getName()
750 if ( !$this->slotsUpdate
->hasSameUpdates( $slotsUpdate ) ) {
751 throw new LogicException(
752 'Can\'t call prepareContent() again with different slot content!'
756 return; // prepareContent() already done, nothing to do
759 $this->assertTransition( 'has-content' );
761 $wikiPage = $this->getWikiPage(); // TODO: use only for legacy hooks!
762 $title = $this->getTitle();
764 $parentRevision = $this->grabCurrentRevision();
766 // The edit may have already been prepared via api.php?action=stashedit
767 $stashedEdit = false;
769 // TODO: MCR: allow output for all slots to be stashed.
770 if ( $useStash && $slotsUpdate->isModifiedSlot( SlotRecord
::MAIN
) ) {
771 $editStash = MediaWikiServices
::getInstance()->getPageEditStash();
772 $stashedEdit = $editStash->checkCache(
774 $slotsUpdate->getModifiedSlot( SlotRecord
::MAIN
)->getContent(),
775 User
::newFromIdentity( $user )
779 $userPopts = ParserOptions
::newFromUserAndLang( $user, $this->contLang
);
780 Hooks
::run( 'ArticlePrepareTextForEdit', [ $wikiPage, $userPopts ] );
783 $this->slotsUpdate
= $slotsUpdate;
785 if ( $parentRevision ) {
786 $this->revision
= MutableRevisionRecord
::newFromParentRevision( $parentRevision );
788 $this->revision
= new MutableRevisionRecord( $title );
791 // NOTE: user and timestamp must be set, so they can be used for
792 // {{subst:REVISIONUSER}} and {{subst:REVISIONTIMESTAMP}} in PST!
793 $this->revision
->setTimestamp( wfTimestampNow() );
794 $this->revision
->setUser( $user );
796 // Set up ParserOptions to operate on the new revision
797 $oldCallback = $userPopts->getCurrentRevisionCallback();
798 $userPopts->setCurrentRevisionCallback(
799 function ( Title
$parserTitle, $parser = false ) use ( $title, $oldCallback ) {
800 if ( $parserTitle->equals( $title ) ) {
801 $legacyRevision = new Revision( $this->revision
);
802 return $legacyRevision;
804 return call_user_func( $oldCallback, $parserTitle, $parser );
809 $pstContentSlots = $this->revision
->getSlots();
811 foreach ( $slotsUpdate->getModifiedRoles() as $role ) {
812 $slot = $slotsUpdate->getModifiedSlot( $role );
814 if ( $slot->isInherited() ) {
815 // No PST for inherited slots! Note that "modified" slots may still be inherited
816 // from an earlier version, e.g. for rollbacks.
818 } elseif ( $role === SlotRecord
::MAIN
&& $stashedEdit ) {
819 // TODO: MCR: allow PST content for all slots to be stashed.
820 $pstSlot = SlotRecord
::newUnsaved( $role, $stashedEdit->pstContent
);
822 $content = $slot->getContent();
823 $pstContent = $content->preSaveTransform( $title, $this->user
, $userPopts );
824 $pstSlot = SlotRecord
::newUnsaved( $role, $pstContent );
827 $pstContentSlots->setSlot( $pstSlot );
830 foreach ( $slotsUpdate->getRemovedRoles() as $role ) {
831 $pstContentSlots->removeSlot( $role );
834 $this->options
['created'] = ( $parentRevision === null );
835 $this->options
['changed'] = ( $parentRevision === null
836 ||
!$pstContentSlots->hasSameContent( $parentRevision->getSlots() ) );
838 $this->doTransition( 'has-content' );
840 if ( !$this->options
['changed'] ) {
843 // TODO: move this into MutableRevisionRecord
844 // TODO: This needs to behave differently for a forced dummy edit!
845 $this->revision
->setId( $parentRevision->getId() );
846 $this->revision
->setTimestamp( $parentRevision->getTimestamp() );
847 $this->revision
->setPageId( $parentRevision->getPageId() );
848 $this->revision
->setParentId( $parentRevision->getParentId() );
849 $this->revision
->setUser( $parentRevision->getUser( RevisionRecord
::RAW
) );
850 $this->revision
->setComment( $parentRevision->getComment( RevisionRecord
::RAW
) );
851 $this->revision
->setMinorEdit( $parentRevision->isMinor() );
852 $this->revision
->setVisibility( $parentRevision->getVisibility() );
854 // prepareUpdate() is redundant for null-edits
855 $this->doTransition( 'has-revision' );
857 $this->parentRevision
= $parentRevision;
860 $renderHints = [ 'use-master' => $this->useMaster(), 'audience' => RevisionRecord
::RAW
];
862 if ( $stashedEdit ) {
863 /** @var ParserOutput $output */
864 $output = $stashedEdit->output
;
865 // TODO: this should happen when stashing the ParserOutput, not now!
866 $output->setCacheTime( $stashedEdit->timestamp
);
868 $renderHints['known-revision-output'] = $output;
870 $this->logger
->debug( __METHOD__
. ': using stashed edit output...' );
873 // NOTE: we want a canonical rendering, so don't pass $this->user or ParserOptions
874 // NOTE: the revision is either new or current, so we can bypass audience checks.
875 $this->renderedRevision
= $this->revisionRenderer
->getRenderedRevision(
884 * Returns the update's target revision - that is, the revision that will be the current
885 * revision after the update.
887 * @note Callers must treat the returned RevisionRecord's content as immutable, even
888 * if it is a MutableRevisionRecord instance. Other aspects of a MutableRevisionRecord
889 * returned from here, such as the user or the comment, may be changed, but may not
890 * be reflected in ParserOutput until after prepareUpdate() has been called.
892 * @todo This is currently used by PageUpdater::makeNewRevision() to construct an unsaved
893 * MutableRevisionRecord instance. Introduce something like an UnsavedRevisionFactory service
894 * for that purpose instead!
896 * @return RevisionRecord
898 public function getRevision() {
899 $this->assertPrepared( __METHOD__
);
900 return $this->revision
;
904 * @return RenderedRevision
906 public function getRenderedRevision() {
907 $this->assertPrepared( __METHOD__
);
909 return $this->renderedRevision
;
912 private function assertHasPageState( $method ) {
913 if ( !$this->pageState
) {
914 throw new LogicException(
915 'Must call grabCurrentRevision() or prepareContent() '
916 . 'or prepareUpdate() before calling ' . $method
921 private function assertPrepared( $method ) {
922 if ( !$this->revision
) {
923 throw new LogicException(
924 'Must call prepareContent() or prepareUpdate() before calling ' . $method
929 private function assertHasRevision( $method ) {
930 if ( !$this->revision
->getId() ) {
931 throw new LogicException(
932 'Must call prepareUpdate() before calling ' . $method
938 * Whether the edit creates the page.
942 public function isCreation() {
943 $this->assertPrepared( __METHOD__
);
944 return $this->options
['created'];
948 * Whether the edit created, or should create, a new revision (that is, it's not a null-edit).
950 * @warning at present, "null-revisions" that do not change content but do have a revision
951 * record would return false after prepareContent(), but true after prepareUpdate()!
952 * This should probably be fixed.
956 public function isChange() {
957 $this->assertPrepared( __METHOD__
);
958 return $this->options
['changed'];
962 * Whether the page was a redirect before the edit.
966 public function wasRedirect() {
967 $this->assertHasPageState( __METHOD__
);
969 if ( $this->pageState
['oldIsRedirect'] === null ) {
970 /** @var RevisionRecord $rev */
971 $rev = $this->pageState
['oldRevision'];
973 $this->pageState
['oldIsRedirect'] = $this->revisionIsRedirect( $rev );
975 $this->pageState
['oldIsRedirect'] = false;
979 return $this->pageState
['oldIsRedirect'];
983 * Returns the slots of the target revision, after PST.
985 * @note Callers must treat the returned RevisionSlots instance as immutable, even
986 * if it is a MutableRevisionSlots instance.
988 * @return RevisionSlots
990 public function getSlots() {
991 $this->assertPrepared( __METHOD__
);
992 return $this->revision
->getSlots();
996 * Returns the RevisionSlotsUpdate for this updater.
998 * @return RevisionSlotsUpdate
1000 private function getRevisionSlotsUpdate() {
1001 $this->assertPrepared( __METHOD__
);
1003 if ( !$this->slotsUpdate
) {
1004 $old = $this->getParentRevision();
1005 $this->slotsUpdate
= RevisionSlotsUpdate
::newFromRevisionSlots(
1006 $this->revision
->getSlots(),
1007 $old ?
$old->getSlots() : null
1010 return $this->slotsUpdate
;
1014 * Returns the role names of the slots touched by the new revision,
1015 * including removed roles.
1019 public function getTouchedSlotRoles() {
1020 return $this->getRevisionSlotsUpdate()->getTouchedRoles();
1024 * Returns the role names of the slots modified by the new revision,
1025 * not including removed roles.
1029 public function getModifiedSlotRoles() {
1030 return $this->getRevisionSlotsUpdate()->getModifiedRoles();
1034 * Returns the role names of the slots removed by the new revision.
1038 public function getRemovedSlotRoles() {
1039 return $this->getRevisionSlotsUpdate()->getRemovedRoles();
1043 * Prepare derived data updates targeting the given Revision.
1045 * Calling this method requires the given revision to be present in the database.
1046 * This may be right after a new revision has been created, or when re-generating
1047 * derived data e.g. in ApiPurge, RefreshLinksJob, and the refreshLinks
1050 * @see docs/pageupdater.txt for more information on when thie method can and should be called.
1052 * @note Calling this method more than once with the same revision has no effect.
1053 * $options are only used for the first call. Calling this method multiple times with
1054 * different revisions will cause an exception.
1056 * @note If grabCurrentRevision() (or prepareContent()) has been called before
1057 * calling this method, $revision->getParentRevision() has to refer to the revision that
1058 * was the current revision at the time grabCurrentRevision() was called.
1060 * @param RevisionRecord $revision
1061 * @param array $options Array of options, following indexes are used:
1062 * - changed: bool, whether the revision changed the content (default true)
1063 * - created: bool, whether the revision created the page (default false)
1064 * - moved: bool, whether the page was moved (default false)
1065 * - restored: bool, whether the page was undeleted (default false)
1066 * - oldrevision: Revision object for the pre-update revision (default null)
1067 * - triggeringUser: The user triggering the update (UserIdentity, defaults to the
1068 * user who created the revision)
1069 * - oldredirect: bool, null, or string 'no-change' (default null):
1070 * - bool: whether the page was counted as a redirect before that
1071 * revision, only used in changed is true and created is false
1072 * - null or 'no-change': don't update the redirect status.
1073 * - oldcountable: bool, null, or string 'no-change' (default null):
1074 * - bool: whether the page was counted as an article before that
1075 * revision, only used in changed is true and created is false
1076 * - null: if created is false, don't update the article count; if created
1077 * is true, do update the article count
1078 * - 'no-change': don't update the article count, ever
1079 * When set to null, pageState['oldCountable'] will be used instead if available.
1080 * - causeAction: an arbitrary string identifying the reason for the update.
1081 * See DataUpdate::getCauseAction(). (default 'unknown')
1082 * - causeAgent: name of the user who caused the update. See DataUpdate::getCauseAgent().
1083 * (string, default 'unknown')
1085 public function prepareUpdate( RevisionRecord
$revision, array $options = [] ) {
1087 !isset( $options['oldrevision'] )
1088 ||
$options['oldrevision'] instanceof Revision
1089 ||
$options['oldrevision'] instanceof RevisionRecord
,
1090 '$options["oldrevision"]',
1091 'must be a RevisionRecord (or Revision)'
1094 !isset( $options['triggeringUser'] )
1095 ||
$options['triggeringUser'] instanceof UserIdentity
,
1096 '$options["triggeringUser"]',
1097 'must be a UserIdentity'
1100 if ( !$revision->getId() ) {
1101 throw new InvalidArgumentException(
1102 'Revision must have an ID set for it to be used with prepareUpdate()!'
1106 if ( $this->revision
&& $this->revision
->getId() ) {
1107 if ( $this->revision
->getId() === $revision->getId() ) {
1108 return; // nothing to do!
1110 throw new LogicException(
1111 'Trying to re-use DerivedPageDataUpdater with revision '
1112 . $revision->getId()
1113 . ', but it\'s already bound to revision '
1114 . $this->revision
->getId()
1119 if ( $this->revision
1120 && !$this->revision
->getSlots()->hasSameContent( $revision->getSlots() )
1122 throw new LogicException(
1123 'The Revision provided has mismatching content!'
1127 // Override fields defined in $this->options with values from $options.
1128 $this->options
= array_intersect_key( $options, $this->options
) +
$this->options
;
1130 if ( $this->revision
) {
1131 $oldId = $this->pageState
['oldId'] ??
0;
1132 $this->options
['newrev'] = ( $revision->getId() !== $oldId );
1133 } elseif ( isset( $this->options
['oldrevision'] ) ) {
1134 /** @var Revision|RevisionRecord $oldRev */
1135 $oldRev = $this->options
['oldrevision'];
1136 $oldId = $oldRev->getId();
1137 $this->options
['newrev'] = ( $revision->getId() !== $oldId );
1139 $oldId = $revision->getParentId();
1142 if ( $oldId !== null ) {
1143 // XXX: what if $options['changed'] disagrees?
1144 // MovePage creates a dummy revision with changed = false!
1145 // We may want to explicitly distinguish between "no new revision" (null-edit)
1146 // and "new revision without new content" (dummy revision).
1148 if ( $oldId === $revision->getParentId() ) {
1149 // NOTE: this may still be a NullRevision!
1151 $this->options
['changed'] = true;
1152 } elseif ( $oldId === $revision->getId() ) {
1154 $this->options
['changed'] = false;
1156 // This indicates that calling code has given us the wrong Revision object
1157 throw new LogicException(
1158 'The Revision mismatches old revision ID: '
1159 . 'Old ID is ' . $oldId
1160 . ', parent ID is ' . $revision->getParentId()
1161 . ', revision ID is ' . $revision->getId()
1166 // If prepareContent() was used to generate the PST content (which is indicated by
1167 // $this->slotsUpdate being set), and this is not a null-edit, then the given
1168 // revision must have the acting user as the revision author. Otherwise, user
1169 // signatures generated by PST would mismatch the user in the revision record.
1170 if ( $this->user
!== null && $this->options
['changed'] && $this->slotsUpdate
) {
1171 $user = $revision->getUser();
1172 if ( !$this->user
->equals( $user ) ) {
1173 throw new LogicException(
1174 'The Revision provided has a mismatching actor: expected '
1175 . $this->user
->getName()
1182 // If $this->pageState was not yet initialized by grabCurrentRevision or prepareContent,
1183 // emulate the state of the page table before the edit, as good as we can.
1184 if ( !$this->pageState
) {
1185 $this->pageState
= [
1186 'oldIsRedirect' => isset( $this->options
['oldredirect'] )
1187 && is_bool( $this->options
['oldredirect'] )
1188 ?
$this->options
['oldredirect']
1190 'oldCountable' => isset( $this->options
['oldcountable'] )
1191 && is_bool( $this->options
['oldcountable'] )
1192 ?
$this->options
['oldcountable']
1196 if ( $this->options
['changed'] ) {
1197 // The edit created a new revision
1198 $this->pageState
['oldId'] = $revision->getParentId();
1200 if ( isset( $this->options
['oldrevision'] ) ) {
1201 $rev = $this->options
['oldrevision'];
1202 $this->pageState
['oldRevision'] = $rev instanceof Revision
1203 ?
$rev->getRevisionRecord()
1207 // This is a null-edit, so the old revision IS the new revision!
1208 $this->pageState
['oldId'] = $revision->getId();
1209 $this->pageState
['oldRevision'] = $revision;
1213 // "created" is forced here
1214 $this->options
['created'] = ( $this->pageState
['oldId'] === 0 );
1216 $this->revision
= $revision;
1218 $this->doTransition( 'has-revision' );
1220 // NOTE: in case we have a User object, don't override with a UserIdentity.
1221 // We already checked that $revision->getUser() mathces $this->user;
1222 if ( !$this->user
) {
1223 $this->user
= $revision->getUser( RevisionRecord
::RAW
);
1226 // Prune any output that depends on the revision ID.
1227 if ( $this->renderedRevision
) {
1228 $this->renderedRevision
->updateRevision( $revision );
1231 // NOTE: we want a canonical rendering, so don't pass $this->user or ParserOptions
1232 // NOTE: the revision is either new or current, so we can bypass audience checks.
1233 $this->renderedRevision
= $this->revisionRenderer
->getRenderedRevision(
1237 [ 'use-master' => $this->useMaster(), 'audience' => RevisionRecord
::RAW
]
1240 // XXX: Since we presumably are dealing with the current revision,
1241 // we could try to get the ParserOutput from the parser cache.
1244 // TODO: optionally get ParserOutput from the ParserCache here.
1245 // Move the logic used by RefreshLinksJob here!
1249 * @deprecated This only exists for B/C, use the getters on DerivedPageDataUpdater directly!
1250 * @return PreparedEdit
1252 public function getPreparedEdit() {
1253 $this->assertPrepared( __METHOD__
);
1255 $slotsUpdate = $this->getRevisionSlotsUpdate();
1256 $preparedEdit = new PreparedEdit();
1258 $preparedEdit->popts
= $this->getCanonicalParserOptions();
1259 $preparedEdit->parserOutputCallback
= [ $this, 'getCanonicalParserOutput' ];
1260 $preparedEdit->pstContent
= $this->revision
->getContent( SlotRecord
::MAIN
);
1261 $preparedEdit->newContent
=
1262 $slotsUpdate->isModifiedSlot( SlotRecord
::MAIN
)
1263 ?
$slotsUpdate->getModifiedSlot( SlotRecord
::MAIN
)->getContent()
1264 : $this->revision
->getContent( SlotRecord
::MAIN
); // XXX: can we just remove this?
1265 $preparedEdit->oldContent
= null; // unused. // XXX: could get this from the parent revision
1266 $preparedEdit->revid
= $this->revision ?
$this->revision
->getId() : null;
1267 $preparedEdit->timestamp
= $preparedEdit->output
->getCacheTime();
1268 $preparedEdit->format
= $preparedEdit->pstContent
->getDefaultFormat();
1270 return $preparedEdit;
1274 * @param string $role
1275 * @param bool $generateHtml
1276 * @return ParserOutput
1278 public function getSlotParserOutput( $role, $generateHtml = true ) {
1279 return $this->getRenderedRevision()->getSlotParserOutput(
1281 [ 'generate-html' => $generateHtml ]
1286 * @return ParserOutput
1288 public function getCanonicalParserOutput() {
1289 return $this->getRenderedRevision()->getRevisionParserOutput();
1293 * @return ParserOptions
1295 public function getCanonicalParserOptions() {
1296 return $this->getRenderedRevision()->getOptions();
1300 * @param bool $recursive
1302 * @return DeferrableUpdate[]
1304 public function getSecondaryDataUpdates( $recursive = false ) {
1305 if ( $this->isContentDeleted() ) {
1306 // This shouldn't happen, since the current content is always public,
1307 // and DataUpates are only needed for current content.
1311 $output = $this->getCanonicalParserOutput();
1313 // Construct a LinksUpdate for the combined canonical output.
1314 $linksUpdate = new LinksUpdate(
1320 $allUpdates = [ $linksUpdate ];
1322 // NOTE: Run updates for all slots, not just the modified slots! Otherwise,
1323 // info for an inherited slot may end up being removed. This is also needed
1324 // to ensure that purges are effective.
1325 $renderedRevision = $this->getRenderedRevision();
1326 foreach ( $this->getSlots()->getSlotRoles() as $role ) {
1327 $slot = $this->getRawSlot( $role );
1328 $content = $slot->getContent();
1329 $handler = $content->getContentHandler();
1331 $updates = $handler->getSecondaryDataUpdates(
1337 $allUpdates = array_merge( $allUpdates, $updates );
1339 // TODO: remove B/C hack in 1.32!
1340 // NOTE: we assume that the combined output contains all relevant meta-data for
1342 $legacyUpdates = $content->getSecondaryDataUpdates(
1349 // HACK: filter out redundant and incomplete LinksUpdates
1350 $legacyUpdates = array_filter( $legacyUpdates, function ( $update ) {
1351 return !( $update instanceof LinksUpdate
);
1354 $allUpdates = array_merge( $allUpdates, $legacyUpdates );
1357 // XXX: if a slot was removed by an earlier edit, but deletion updates failed to run at
1358 // that time, we don't know for which slots to run deletion updates when purging a page.
1359 // We'd have to examine the entire history of the page to determine that. Perhaps there
1360 // could be a "try extra hard" mode for that case that would run a DB query to find all
1361 // roles/models ever used on the page. On the other hand, removing slots should be quite
1362 // rare, so perhaps this isn't worth the trouble.
1364 // TODO: consolidate with similar logic in WikiPage::getDeletionUpdates()
1365 $wikiPage = $this->getWikiPage();
1366 $parentRevision = $this->getParentRevision();
1367 foreach ( $this->getRemovedSlotRoles() as $role ) {
1368 // HACK: we should get the content model of the removed slot from a SlotRoleHandler!
1369 // For now, find the slot in the parent revision - if the slot was removed, it should
1370 // always exist in the parent revision.
1371 $parentSlot = $parentRevision->getSlot( $role, RevisionRecord
::RAW
);
1372 $content = $parentSlot->getContent();
1373 $handler = $content->getContentHandler();
1375 $updates = $handler->getDeletionUpdates(
1379 $allUpdates = array_merge( $allUpdates, $updates );
1381 // TODO: remove B/C hack in 1.32!
1382 $legacyUpdates = $content->getDeletionUpdates( $wikiPage );
1384 // HACK: filter out redundant and incomplete LinksDeletionUpdate
1385 $legacyUpdates = array_filter( $legacyUpdates, function ( $update ) {
1386 return !( $update instanceof LinksDeletionUpdate
);
1389 $allUpdates = array_merge( $allUpdates, $legacyUpdates );
1392 // TODO: hard deprecate SecondaryDataUpdates in favor of RevisionDataUpdates in 1.33!
1394 'RevisionDataUpdates',
1395 [ $this->getTitle(), $renderedRevision, &$allUpdates ]
1402 * Do standard updates after page edit, purge, or import.
1403 * Update links tables, site stats, search index, title cache, message cache, etc.
1404 * Purges pages that depend on this page when appropriate.
1405 * With a 10% chance, triggers pruning the recent changes table.
1407 * @note prepareUpdate() must be called before calling this method!
1409 * MCR migration note: this replaces WikiPage::doEditUpdates.
1411 public function doUpdates() {
1412 $this->assertTransition( 'done' );
1414 // TODO: move logic into a PageEventEmitter service
1416 $wikiPage = $this->getWikiPage(); // TODO: use only for legacy hooks!
1418 $legacyUser = User
::newFromIdentity( $this->user
);
1419 $legacyRevision = new Revision( $this->revision
);
1421 $userParserOptions = ParserOptions
::newFromUser( $legacyUser );
1422 // Decide whether to save the final canonical parser ouput based on the fact that
1423 // users are typically redirected to viewing pages right after they edit those pages.
1424 // Due to vary-revision-id, getting/saving that output here might require a reparse.
1425 if ( $userParserOptions->matchesForCacheKey( $this->getCanonicalParserOptions() ) ) {
1426 // Whether getting the final output requires a reparse or not, the user will
1427 // need canonical output anyway, since that is what their parser options use.
1428 // A reparse now at least has the benefit of various warm process caches.
1429 $this->doParserCacheUpdate();
1431 // If the user does not have canonical parse options, then don't risk another parse
1432 // to make output they cannot use on the page refresh that typically occurs after
1433 // editing. Doing the parser output save post-send will still benefit *other* users.
1434 DeferredUpdates
::addCallableUpdate( function () {
1435 $this->doParserCacheUpdate();
1439 // Defer the getCannonicalParserOutput() call triggered by getSecondaryDataUpdates()
1440 DeferredUpdates
::addCallableUpdate( function () {
1441 $this->doSecondaryDataUpdates( [
1442 // T52785 do not update any other pages on a null edit
1443 'recursive' => $this->options
['changed']
1447 // TODO: MCR: check if *any* changed slot supports categories!
1448 if ( $this->rcWatchCategoryMembership
1449 && $this->getContentHandler( SlotRecord
::MAIN
)->supportsCategories() === true
1450 && ( $this->options
['changed'] ||
$this->options
['created'] )
1451 && !$this->options
['restored']
1453 // Note: jobs are pushed after deferred updates, so the job should be able to see
1454 // the recent change entry (also done via deferred updates) and carry over any
1455 // bot/deletion/IP flags, ect.
1456 $this->jobQueueGroup
->lazyPush(
1457 CategoryMembershipChangeJob
::newSpec(
1459 $this->revision
->getTimestamp()
1464 // TODO: replace legacy hook! Use a listener on PageEventEmitter instead!
1465 // @note: Extensions should *avoid* calling getCannonicalParserOutput() when using
1466 // this hook whenever possible in order to avoid unnecessary additional parses.
1467 $editInfo = $this->getPreparedEdit();
1468 Hooks
::run( 'ArticleEditUpdates',
1469 [ &$wikiPage, &$editInfo, $this->options
['changed'] ] );
1471 // TODO: replace legacy hook! Use a listener on PageEventEmitter instead!
1472 if ( Hooks
::run( 'ArticleEditUpdatesDeleteFromRecentchanges', [ &$wikiPage ] ) ) {
1473 // Flush old entries from the `recentchanges` table
1474 if ( mt_rand( 0, 9 ) == 0 ) {
1475 $this->jobQueueGroup
->lazyPush( RecentChangesUpdateJob
::newPurgeJob() );
1479 $id = $this->getPageId();
1480 $title = $this->getTitle();
1481 $dbKey = $title->getPrefixedDBkey();
1482 $shortTitle = $title->getDBkey();
1484 if ( !$title->exists() ) {
1485 wfDebug( __METHOD__
. ": Page doesn't exist any more, bailing out\n" );
1487 $this->doTransition( 'done' );
1491 DeferredUpdates
::addCallableUpdate( function () {
1493 $this->options
['oldcountable'] === 'no-change' ||
1494 ( !$this->options
['changed'] && !$this->options
['moved'] )
1497 } elseif ( $this->options
['created'] ) {
1498 $good = (int)$this->isCountable();
1499 } elseif ( $this->options
['oldcountable'] !== null ) {
1500 $good = (int)$this->isCountable()
1501 - (int)$this->options
['oldcountable'];
1502 } elseif ( isset( $this->pageState
['oldCountable'] ) ) {
1503 $good = (int)$this->isCountable()
1504 - (int)$this->pageState
['oldCountable'];
1508 $edits = $this->options
['changed'] ?
1 : 0;
1509 $pages = $this->options
['created'] ?
1 : 0;
1511 DeferredUpdates
::addUpdate( SiteStatsUpdate
::factory(
1512 [ 'edits' => $edits, 'articles' => $good, 'pages' => $pages ]
1516 // TODO: make search infrastructure aware of slots!
1517 $mainSlot = $this->revision
->getSlot( SlotRecord
::MAIN
);
1518 if ( !$mainSlot->isInherited() && !$this->isContentDeleted() ) {
1519 DeferredUpdates
::addUpdate( new SearchUpdate( $id, $dbKey, $mainSlot->getContent() ) );
1522 // If this is another user's talk page, update newtalk.
1523 // Don't do this if $options['changed'] = false (null-edits) nor if
1524 // it's a minor edit and the user making the edit doesn't generate notifications for those.
1525 if ( $this->options
['changed']
1526 && $title->getNamespace() == NS_USER_TALK
1527 && $shortTitle != $legacyUser->getTitleKey()
1528 && !( $this->revision
->isMinor() && $legacyUser->isAllowed( 'nominornewtalk' ) )
1530 $recipient = User
::newFromName( $shortTitle, false );
1531 if ( !$recipient ) {
1532 wfDebug( __METHOD__
. ": invalid username\n" );
1534 // Allow extensions to prevent user notification
1535 // when a new message is added to their talk page
1536 // TODO: replace legacy hook! Use a listener on PageEventEmitter instead!
1537 if ( Hooks
::run( 'ArticleEditUpdateNewTalk', [ &$wikiPage, $recipient ] ) ) {
1538 if ( User
::isIP( $shortTitle ) ) {
1539 // An anonymous user
1540 $recipient->setNewtalk( true, $legacyRevision );
1541 } elseif ( $recipient->isLoggedIn() ) {
1542 $recipient->setNewtalk( true, $legacyRevision );
1544 wfDebug( __METHOD__
. ": don't need to notify a nonexistent user\n" );
1550 if ( $title->getNamespace() == NS_MEDIAWIKI
1551 && $this->getRevisionSlotsUpdate()->isModifiedSlot( SlotRecord
::MAIN
)
1553 $mainContent = $this->isContentDeleted() ?
null : $this->getRawContent( SlotRecord
::MAIN
);
1555 $this->messageCache
->updateMessageOverride( $title, $mainContent );
1558 // TODO: move onArticleCreate and onArticle into a PageEventEmitter service
1559 if ( $this->options
['created'] ) {
1560 WikiPage
::onArticleCreate( $title );
1561 } elseif ( $this->options
['changed'] ) { // T52785
1562 WikiPage
::onArticleEdit( $title, $legacyRevision, $this->getTouchedSlotRoles() );
1565 $oldRevision = $this->getParentRevision();
1566 $oldLegacyRevision = $oldRevision ?
new Revision( $oldRevision ) : null;
1568 // TODO: In the wiring, register a listener for this on the new PageEventEmitter
1569 ResourceLoaderWikiModule
::invalidateModuleCache(
1570 $title, $oldLegacyRevision, $legacyRevision, $this->getWikiId() ?
: wfWikiID()
1573 $this->doTransition( 'done' );
1577 * Do secondary data updates (such as updating link tables).
1579 * MCR note: this method is temporarily exposed via WikiPage::doSecondaryDataUpdates.
1581 * @param array $options
1582 * - recursive: make the update recursive, i.e. also update pages which transclude the
1583 * current page or otherwise depend on it (default: false)
1584 * - defer: one of the DeferredUpdates constants, or false to run immediately after waiting
1585 * for replication of the changes from the SecondaryDataUpdates hooks (default: false)
1586 * - transactionTicket: a transaction ticket from LBFactory::getEmptyTransactionTicket(),
1587 * only when defer is false (default: null)
1590 public function doSecondaryDataUpdates( array $options = [] ) {
1591 $this->assertHasRevision( __METHOD__
);
1593 'recursive' => false,
1595 'transactionTicket' => null,
1597 $deferValues = [ false, DeferredUpdates
::PRESEND
, DeferredUpdates
::POSTSEND
];
1598 if ( !in_array( $options['defer'], $deferValues, true ) ) {
1599 throw new InvalidArgumentException( 'Invalid value for defer: ' . $options['defer'] );
1601 Assert
::parameterType(
1602 'integer|null', $options['transactionTicket'], '$options[\'transactionTicket\']' );
1604 $updates = $this->getSecondaryDataUpdates( $options['recursive'] );
1606 $triggeringUser = $this->options
['triggeringUser'] ??
$this->user
;
1607 if ( !$triggeringUser instanceof User
) {
1608 $triggeringUser = User
::newFromIdentity( $triggeringUser );
1610 $causeAction = $this->options
['causeAction'] ??
'unknown';
1611 $causeAgent = $this->options
['causeAgent'] ??
'unknown';
1612 $legacyRevision = new Revision( $this->revision
);
1613 $ticket = $options['transactionTicket'];
1615 if ( $options['defer'] === false && $ticket !== null ) {
1616 // For legacy hook handlers doing updates via LinksUpdateConstructed, make sure
1617 // any pending writes they made get flushed before the doUpdate() calls below.
1618 // This avoids snapshot-clearing errors in LinksUpdate::acquirePageLock().
1619 $this->loadbalancerFactory
->commitAndWaitForReplication( __METHOD__
, $ticket );
1622 foreach ( $updates as $update ) {
1623 if ( $update instanceof DataUpdate
) {
1624 $update->setCause( $causeAction, $causeAgent );
1626 if ( $update instanceof LinksUpdate
) {
1627 $update->setRevision( $legacyRevision );
1628 $update->setTriggeringUser( $triggeringUser );
1631 if ( $options['defer'] === false ) {
1632 if ( $update instanceof DataUpdate
&& $ticket !== null ) {
1633 $update->setTransactionTicket( $ticket );
1635 $update->doUpdate();
1637 DeferredUpdates
::addUpdate( $update, $options['defer'] );
1642 public function doParserCacheUpdate() {
1643 $this->assertHasRevision( __METHOD__
);
1645 $wikiPage = $this->getWikiPage(); // TODO: ParserCache should accept a RevisionRecord instead
1647 // NOTE: this may trigger the first parsing of the new content after an edit (when not
1648 // using pre-generated stashed output).
1649 // XXX: we may want to use the PoolCounter here. This would perhaps allow the initial parse
1650 // to be performed post-send. The client could already follow a HTTP redirect to the
1651 // page view, but would then have to wait for a response until rendering is complete.
1652 $output = $this->getCanonicalParserOutput();
1654 // Save it to the parser cache. Use the revision timestamp in the case of a
1655 // freshly saved edit, as that matches page_touched and a mismatch would trigger an
1656 // unnecessary reparse.
1657 $timestamp = $this->options
['newrev'] ?
$this->revision
->getTimestamp()
1658 : $output->getCacheTime();
1659 $this->parserCache
->save(
1660 $output, $wikiPage, $this->getCanonicalParserOptions(),
1661 $timestamp, $this->revision
->getId()