dépôts / lhc / web / wiklou.git / blob
? search:


ad29f91e99de7e7d1b99a361c09643bf624aacee
[lhc/web/wiklou.git] / includes / Storage / DerivedPageDataUpdater.php
1 <?php
2 /**
3 * A handle for managing updates for derived page data on edit, import, purge, etc.
4 *
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.
9 *
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.
14 *
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
19 *
20 * @file
21 */
22
23 namespace MediaWiki\Storage;
24
25 use ApiStashEdit;
26 use CategoryMembershipChangeJob;
27 use Content;
28 use ContentHandler;
29 use DataUpdate;
30 use DeferrableUpdate;
31 use DeferredUpdates;
32 use Hooks;
33 use IDBAccessObject;
34 use InvalidArgumentException;
35 use JobQueueGroup;
36 use Language;
37 use LinksDeletionUpdate;
38 use LinksUpdate;
39 use LogicException;
40 use MediaWiki\Edit\PreparedEdit;
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\SlotRecord;
48 use MediaWiki\User\UserIdentity;
49 use MessageCache;
50 use ParserCache;
51 use ParserOptions;
52 use ParserOutput;
53 use RecentChangesUpdateJob;
54 use ResourceLoaderWikiModule;
55 use Revision;
56 use SearchUpdate;
57 use SiteStatsUpdate;
58 use Title;
59 use User;
60 use Wikimedia\Assert\Assert;
61 use Wikimedia\Rdbms\LBFactory;
62 use WikiPage;
63
64 /**
65 * A handle for managing updates for derived page data on edit, import, purge, etc.
66 *
67 * @note Avoid direct usage of DerivedPageDataUpdater.
68 *
69 * @todo Define interfaces for the different use cases of DerivedPageDataUpdater, particularly
70 * providing access to post-PST content and ParserOutput to callbacks during revision creation,
71 * which currently use WikiPage::prepareContentForEdit, and allowing updates to be triggered on
72 * purge, import, and undeletion, which currently use WikiPage::doEditUpdates() and
73 * Content::getSecondaryDataUpdates().
74 *
75 * DerivedPageDataUpdater instances are designed to be cached inside a WikiPage instance,
76 * and re-used by callback code over the course of an update operation. It's a stepping stone
77 * one the way to a more complete refactoring of WikiPage.
78 *
79 * When using a DerivedPageDataUpdater, the following life cycle must be observed:
80 * grabCurrentRevision (optional), prepareContent (optional), prepareUpdate (required
81 * for doUpdates). getCanonicalParserOutput, getSlots, and getSecondaryDataUpdates
82 * require prepareContent or prepareUpdate to have been called first, to initialize the
83 * DerivedPageDataUpdater.
84 *
85 * @see docs/pageupdater.txt for more information.
86 *
87 * MCR migration note: this replaces the relevant methods in WikiPage, and covers the use cases
88 * of PreparedEdit.
89 *
90 * @internal
91 *
92 * @since 1.32
93 * @ingroup Page
94 */
95 class DerivedPageDataUpdater implements IDBAccessObject {
96
97 /**
98 * @var UserIdentity|null
99 */
100 private $user = null;
101
102 /**
103 * @var WikiPage
104 */
105 private $wikiPage;
106
107 /**
108 * @var ParserCache
109 */
110 private $parserCache;
111
112 /**
113 * @var RevisionStore
114 */
115 private $revisionStore;
116
117 /**
118 * @var Language
119 */
120 private $contLang;
121
122 /**
123 * @var JobQueueGroup
124 */
125 private $jobQueueGroup;
126
127 /**
128 * @var MessageCache
129 */
130 private $messageCache;
131
132 /**
133 * @var LBFactory
134 */
135 private $loadbalancerFactory;
136
137 /**
138 * @var string see $wgArticleCountMethod
139 */
140 private $articleCountMethod;
141
142 /**
143 * @var boolean see $wgRCWatchCategoryMembership
144 */
145 private $rcWatchCategoryMembership = false;
146
147 /**
148 * Stores (most of) the $options parameter of prepareUpdate().
149 * @see prepareUpdate()
150 */
151 private $options = [
152 'changed' => true,
153 'created' => false,
154 'moved' => false,
155 'restored' => false,
156 'oldrevision' => null,
157 'oldcountable' => null,
158 'oldredirect' => null,
159 'triggeringUser' => null,
160 // causeAction/causeAgent default to 'unknown' but that's handled where it's read,
161 // to make the life of prepareUpdate() callers easier.
162 'causeAction' => null,
163 'causeAgent' => null,
164 ];
165
166 /**
167 * The state of the relevant row in page table before the edit.
168 * This is determined by the first call to grabCurrentRevision, prepareContent,
169 * or prepareUpdate (so it is only accessible in 'knows-current' or a later stage).
170 * If pageState was not initialized when prepareUpdate() is called, prepareUpdate() will
171 * attempt to emulate the state of the page table before the edit.
172 *
173 * Contains the following fields:
174 * - oldRevision (RevisionRecord|null): the revision that was current before the change
175 * associated with this update. Might not be set, use getParentRevision().
176 * - oldId (int|null): the id of the above revision. 0 if there is no such revision (the change
177 * was about creating a new page); null if not known (that should not happen).
178 * - oldIsRedirect (bool|null): whether the page was a redirect before the change. Lazy-loaded,
179 * can be null; use wasRedirect() instead of direct access.
180 * - oldCountable (bool|null): whether the page was countable before the change (or null
181 * if we don't have that information)
182 *
183 * @var array
184 */
185 private $pageState = null;
186
187 /**
188 * @var RevisionSlotsUpdate|null
189 */
190 private $slotsUpdate = null;
191
192 /**
193 * @var RevisionRecord|null
194 */
195 private $parentRevision = null;
196
197 /**
198 * @var RevisionRecord|null
199 */
200 private $revision = null;
201
202 /**
203 * @var RenderedRevision
204 */
205 private $renderedRevision = null;
206
207 /**
208 * @var RevisionRenderer
209 */
210 private $revisionRenderer;
211
212 /**
213 * A stage identifier for managing the life cycle of this instance.
214 * Possible stages are 'new', 'knows-current', 'has-content', 'has-revision', and 'done'.
215 *
216 * @see docs/pageupdater.txt for documentation of the life cycle.
217 *
218 * @var string
219 */
220 private $stage = 'new';
221
222 /**
223 * Transition table for managing the life cycle of DerivedPageDateUpdater instances.
224 *
225 * XXX: Overkill. This is a linear order, we could just count. Names are nice though,
226 * and constants are also overkill...
227 *
228 * @see docs/pageupdater.txt for documentation of the life cycle.
229 *
230 * @var array[]
231 */
232 private static $transitions = [
233 'new' => [
234 'new' => true,
235 'knows-current' => true,
236 'has-content' => true,
237 'has-revision' => true,
238 ],
239 'knows-current' => [
240 'knows-current' => true,
241 'has-content' => true,
242 'has-revision' => true,
243 ],
244 'has-content' => [
245 'has-content' => true,
246 'has-revision' => true,
247 ],
248 'has-revision' => [
249 'has-revision' => true,
250 'done' => true,
251 ],
252 ];
253
254 /**
255 * @param WikiPage $wikiPage ,
256 * @param RevisionStore $revisionStore
257 * @param RevisionRenderer $revisionRenderer
258 * @param ParserCache $parserCache
259 * @param JobQueueGroup $jobQueueGroup
260 * @param MessageCache $messageCache
261 * @param Language $contLang
262 * @param LBFactory $loadbalancerFactory
263 */
264 public function __construct(
265 WikiPage $wikiPage,
266 RevisionStore $revisionStore,
267 RevisionRenderer $revisionRenderer,
268 ParserCache $parserCache,
269 JobQueueGroup $jobQueueGroup,
270 MessageCache $messageCache,
271 Language $contLang,
272 LBFactory $loadbalancerFactory
273 ) {
274 $this->wikiPage = $wikiPage;
275
276 $this->parserCache = $parserCache;
277 $this->revisionStore = $revisionStore;
278 $this->revisionRenderer = $revisionRenderer;
279 $this->jobQueueGroup = $jobQueueGroup;
280 $this->messageCache = $messageCache;
281 $this->contLang = $contLang;
282 // XXX only needed for waiting for replicas to catch up; there should be a narrower
283 // interface for that.
284 $this->loadbalancerFactory = $loadbalancerFactory;
285 }
286
287 /**
288 * Transition function for managing the life cycle of this instances.
289 *
290 * @see docs/pageupdater.txt for documentation of the life cycle.
291 *
292 * @param string $newStage the new stage
293 * @return string the previous stage
294 *
295 * @throws LogicException If a transition to the given stage is not possible in the current
296 * stage.
297 */
298 private function doTransition( $newStage ) {
299 $this->assertTransition( $newStage );
300
301 $oldStage = $this->stage;
302 $this->stage = $newStage;
303
304 return $oldStage;
305 }
306
307 /**
308 * Asserts that a transition to the given stage is possible, without performing it.
309 *
310 * @see docs/pageupdater.txt for documentation of the life cycle.
311 *
312 * @param string $newStage the new stage
313 *
314 * @throws LogicException If this instance is not in the expected stage
315 */
316 private function assertTransition( $newStage ) {
317 if ( empty( self::$transitions[$this->stage][$newStage] ) ) {
318 throw new LogicException( "Cannot transition from {$this->stage} to $newStage" );
319 }
320 }
321
322 /**
323 * @return bool|string
324 */
325 private function getWikiId() {
326 // TODO: get from RevisionStore
327 return false;
328 }
329
330 /**
331 * Checks whether this DerivedPageDataUpdater can be re-used for running updates targeting
332 * the given revision.
333 *
334 * @param UserIdentity|null $user The user creating the revision in question
335 * @param RevisionRecord|null $revision New revision (after save, if already saved)
336 * @param RevisionSlotsUpdate|null $slotsUpdate New content (before PST)
337 * @param null|int $parentId Parent revision of the edit (use 0 for page creation)
338 *
339 * @return bool
340 */
341 public function isReusableFor(
342 UserIdentity $user = null,
343 RevisionRecord $revision = null,
344 RevisionSlotsUpdate $slotsUpdate = null,
345 $parentId = null
346 ) {
347 if ( $revision
348 && $parentId
349 && $revision->getParentId() !== $parentId
350 ) {
351 throw new InvalidArgumentException( '$parentId should match the parent of $revision' );
352 }
353
354 if ( $revision
355 && $user
356 && $revision->getUser( RevisionRecord::RAW )->getName() !== $user->getName()
357 ) {
358 throw new InvalidArgumentException( '$user should match the author of $revision' );
359 }
360
361 if ( $user && $this->user && $user->getName() !== $this->user->getName() ) {
362 return false;
363 }
364
365 if ( $revision && $this->revision && $this->revision->getId()
366 && $this->revision->getId() !== $revision->getId()
367 ) {
368 return false;
369 }
370
371 if ( $revision && !$user ) {
372 $user = $revision->getUser( RevisionRecord::RAW );
373 }
374
375 if ( $this->pageState
376 && $revision
377 && $revision->getParentId() !== null
378 && $this->pageState['oldId'] !== $revision->getParentId()
379 ) {
380 return false;
381 }
382
383 if ( $this->pageState
384 && $parentId !== null
385 && $this->pageState['oldId'] !== $parentId
386 ) {
387 return false;
388 }
389
390 if ( $this->revision
391 && $user
392 && $this->revision->getUser( RevisionRecord::RAW )
393 && $this->revision->getUser( RevisionRecord::RAW )->getName() !== $user->getName()
394 ) {
395 return false;
396 }
397
398 if ( $revision
399 && $this->user
400 && $this->revision->getUser( RevisionRecord::RAW )
401 && $revision->getUser( RevisionRecord::RAW )->getName() !== $this->user->getName()
402 ) {
403 return false;
404 }
405
406 // NOTE: this check is the primary reason for having the $this->slotsUpdate field!
407 if ( $this->slotsUpdate
408 && $slotsUpdate
409 && !$this->slotsUpdate->hasSameUpdates( $slotsUpdate )
410 ) {
411 return false;
412 }
413
414 if ( $revision
415 && $this->revision
416 && !$this->revision->getSlots()->hasSameContent( $revision->getSlots() )
417 ) {
418 return false;
419 }
420
421 return true;
422 }
423
424 /**
425 * @param string $articleCountMethod "any" or "link".
426 * @see $wgArticleCountMethod
427 */
428 public function setArticleCountMethod( $articleCountMethod ) {
429 $this->articleCountMethod = $articleCountMethod;
430 }
431
432 /**
433 * @param bool $rcWatchCategoryMembership
434 * @see $wgRCWatchCategoryMembership
435 */
436 public function setRcWatchCategoryMembership( $rcWatchCategoryMembership ) {
437 $this->rcWatchCategoryMembership = $rcWatchCategoryMembership;
438 }
439
440 /**
441 * @return Title
442 */
443 private function getTitle() {
444 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
445 return $this->wikiPage->getTitle();
446 }
447
448 /**
449 * @return WikiPage
450 */
451 private function getWikiPage() {
452 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
453 return $this->wikiPage;
454 }
455
456 /**
457 * Determines whether the page being edited already existed.
458 * Only defined after calling grabCurrentRevision() or prepareContent() or prepareUpdate()!
459 *
460 * @return bool
461 * @throws LogicException if called before grabCurrentRevision
462 */
463 public function pageExisted() {
464 $this->assertHasPageState( __METHOD__ );
465
466 return $this->pageState['oldId'] > 0;
467 }
468
469 /**
470 * Returns the parent revision of the new revision wrapped by this update.
471 * If the update is a null-edit, this will return the parent of the current (and new) revision.
472 * This will return null if the revision wrapped by this update created the page.
473 * Only defined after calling prepareContent() or prepareUpdate()!
474 *
475 * @return RevisionRecord|null the parent revision of the new revision, or null if
476 * the update created the page.
477 */
478 private function getParentRevision() {
479 $this->assertPrepared( __METHOD__ );
480
481 if ( $this->parentRevision ) {
482 return $this->parentRevision;
483 }
484
485 if ( !$this->pageState['oldId'] ) {
486 // If there was no current revision, there is no parent revision,
487 // since the page didn't exist.
488 return null;
489 }
490
491 $oldId = $this->revision->getParentId();
492 $flags = $this->useMaster() ? RevisionStore::READ_LATEST : 0;
493 $this->parentRevision = $oldId
494 ? $this->revisionStore->getRevisionById( $oldId, $flags )
495 : null;
496
497 return $this->parentRevision;
498 }
499
500 /**
501 * Returns the revision that was the page's current revision when grabCurrentRevision()
502 * was first called.
503 *
504 * During an edit, that revision will act as the logical parent of the new revision.
505 *
506 * Some updates are performed based on the difference between the database state at the
507 * moment this method is first called, and the state after the edit.
508 *
509 * @see docs/pageupdater.txt for more information on when thie method can and should be called.
510 *
511 * @note After prepareUpdate() was called, grabCurrentRevision() will throw an exception
512 * to avoid confusion, since the page's current revision is then the new revision after
513 * the edit, which was presumably passed to prepareUpdate() as the $revision parameter.
514 * Use getParentRevision() instead to access the revision that is the parent of the
515 * new revision.
516 *
517 * @return RevisionRecord|null the page's current revision, or null if the page does not
518 * yet exist.
519 */
520 public function grabCurrentRevision() {
521 if ( $this->pageState ) {
522 return $this->pageState['oldRevision'];
523 }
524
525 $this->assertTransition( 'knows-current' );
526
527 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
528 $wikiPage = $this->getWikiPage();
529
530 // Do not call WikiPage::clear(), since the caller may already have caused page data
531 // to be loaded with SELECT FOR UPDATE. Just assert it's loaded now.
532 $wikiPage->loadPageData( self::READ_LATEST );
533 $rev = $wikiPage->getRevision();
534 $current = $rev ? $rev->getRevisionRecord() : null;
535
536 $this->pageState = [
537 'oldRevision' => $current,
538 'oldId' => $rev ? $rev->getId() : 0,
539 'oldIsRedirect' => $wikiPage->isRedirect(), // NOTE: uses page table
540 'oldCountable' => $wikiPage->isCountable(), // NOTE: uses pagelinks table
541 ];
542
543 $this->doTransition( 'knows-current' );
544
545 return $this->pageState['oldRevision'];
546 }
547
548 /**
549 * Whether prepareUpdate() or prepareContent() have been called on this instance.
550 *
551 * @return bool
552 */
553 public function isContentPrepared() {
554 return $this->revision !== null;
555 }
556
557 /**
558 * Whether prepareUpdate() has been called on this instance.
559 *
560 * @note will also return null in case of a null-edit!
561 *
562 * @return bool
563 */
564 public function isUpdatePrepared() {
565 return $this->revision !== null && $this->revision->getId() !== null;
566 }
567
568 /**
569 * @return int
570 */
571 private function getPageId() {
572 // NOTE: eventually, we won't get a WikiPage passed into the constructor any more
573 return $this->wikiPage->getId();
574 }
575
576 /**
577 * Whether the content is deleted and thus not visible to the public.
578 *
579 * @return bool
580 */
581 public function isContentDeleted() {
582 if ( $this->revision ) {
583 // XXX: if that revision is the current revision, this should be skipped
584 return $this->revision->isDeleted( RevisionRecord::DELETED_TEXT );
585 } else {
586 // If the content has not been saved yet, it cannot have been deleted yet.
587 return false;
588 }
589 }
590
591 /**
592 * Returns the slot, modified or inherited, after PST, with no audience checks applied.
593 *
594 * @param string $role slot role name
595 *
596 * @throws PageUpdateException If the slot is neither set for update nor inherited from the
597 * parent revision.
598 * @return SlotRecord
599 */
600 public function getRawSlot( $role ) {
601 return $this->getSlots()->getSlot( $role );
602 }
603
604 /**
605 * Returns the content of the given slot, with no audience checks.
606 *
607 * @throws PageUpdateException If the slot is neither set for update nor inherited from the
608 * parent revision.
609 * @param string $role slot role name
610 * @return Content
611 */
612 public function getRawContent( $role ) {
613 return $this->getRawSlot( $role )->getContent();
614 }
615
616 /**
617 * Returns the content model of the given slot
618 *
619 * @param string $role slot role name
620 * @return string
621 */
622 private function getContentModel( $role ) {
623 return $this->getRawSlot( $role )->getModel();
624 }
625
626 /**
627 * @param string $role slot role name
628 * @return ContentHandler
629 */
630 private function getContentHandler( $role ) {
631 // TODO: inject something like a ContentHandlerRegistry
632 return ContentHandler::getForModelID( $this->getContentModel( $role ) );
633 }
634
635 private function useMaster() {
636 // TODO: can we just set a flag to true in prepareContent()?
637 return $this->wikiPage->wasLoadedFrom( self::READ_LATEST );
638 }
639
640 /**
641 * @return bool
642 */
643 public function isCountable() {
644 // NOTE: Keep in sync with WikiPage::isCountable.
645
646 if ( !$this->getTitle()->isContentPage() ) {
647 return false;
648 }
649
650 if ( $this->isContentDeleted() ) {
651 // This should be irrelevant: countability only applies to the current revision,
652 // and the current revision is never suppressed.
653 return false;
654 }
655
656 if ( $this->isRedirect() ) {
657 return false;
658 }
659
660 $hasLinks = null;
661
662 if ( $this->articleCountMethod === 'link' ) {
663 $hasLinks = (bool)count( $this->getCanonicalParserOutput()->getLinks() );
664 }
665
666 // TODO: MCR: ask all slots if they have links [SlotHandler/PageTypeHandler]
667 $mainContent = $this->getRawContent( SlotRecord::MAIN );
668 return $mainContent->isCountable( $hasLinks );
669 }
670
671 /**
672 * @return bool
673 */
674 public function isRedirect() {
675 // NOTE: main slot determines redirect status
676 $mainContent = $this->getRawContent( SlotRecord::MAIN );
677
678 return $mainContent->isRedirect();
679 }
680
681 /**
682 * @param RevisionRecord $rev
683 *
684 * @return bool
685 */
686 private function revisionIsRedirect( RevisionRecord $rev ) {
687 // NOTE: main slot determines redirect status
688 $mainContent = $rev->getContent( SlotRecord::MAIN, RevisionRecord::RAW );
689
690 return $mainContent->isRedirect();
691 }
692
693 /**
694 * Prepare updates based on an update which has not yet been saved.
695 *
696 * This may be used to create derived data that is needed when creating a new revision;
697 * particularly, this makes available the slots of the new revision via the getSlots()
698 * method, after applying PST and slot inheritance.
699 *
700 * The derived data prepared for revision creation may then later be re-used by doUpdates(),
701 * without the need to re-calculate.
702 *
703 * @see docs/pageupdater.txt for more information on when thie method can and should be called.
704 *
705 * @note Calling this method more than once with the same $slotsUpdate
706 * has no effect. Calling this method multiple times with different content will cause
707 * an exception.
708 *
709 * @note Calling this method after prepareUpdate() has been called will cause an exception.
710 *
711 * @param User $user The user to act as context for pre-save transformation (PST).
712 * Type hint should be reduced to UserIdentity at some point.
713 * @param RevisionSlotsUpdate $slotsUpdate The new content of the slots to be updated
714 * by this edit, before PST.
715 * @param bool $useStash Whether to use stashed ParserOutput
716 */
717 public function prepareContent(
718 User $user,
719 RevisionSlotsUpdate $slotsUpdate,
720 $useStash = true
721 ) {
722 if ( $this->slotsUpdate ) {
723 if ( !$this->user ) {
724 throw new LogicException(
725 'Unexpected state: $this->slotsUpdate was initialized, '
726 . 'but $this->user was not.'
727 );
728 }
729
730 if ( $this->user->getName() !== $user->getName() ) {
731 throw new LogicException( 'Can\'t call prepareContent() again for different user! '
732 . 'Expected ' . $this->user->getName() . ', got ' . $user->getName()
733 );
734 }
735
736 if ( !$this->slotsUpdate->hasSameUpdates( $slotsUpdate ) ) {
737 throw new LogicException(
738 'Can\'t call prepareContent() again with different slot content!'
739 );
740 }
741
742 return; // prepareContent() already done, nothing to do
743 }
744
745 $this->assertTransition( 'has-content' );
746
747 $wikiPage = $this->getWikiPage(); // TODO: use only for legacy hooks!
748 $title = $this->getTitle();
749
750 $parentRevision = $this->grabCurrentRevision();
751
752 $this->slotsOutput = [];
753 $this->canonicalParserOutput = null;
754
755 // The edit may have already been prepared via api.php?action=stashedit
756 $stashedEdit = false;
757
758 // TODO: MCR: allow output for all slots to be stashed.
759 if ( $useStash && $slotsUpdate->isModifiedSlot( SlotRecord::MAIN ) ) {
760 $mainContent = $slotsUpdate->getModifiedSlot( SlotRecord::MAIN )->getContent();
761 $legacyUser = User::newFromIdentity( $user );
762 $stashedEdit = ApiStashEdit::checkCache( $title, $mainContent, $legacyUser );
763 }
764
765 if ( $stashedEdit ) {
766 /** @var ParserOutput $output */
767 $output = $stashedEdit->output;
768
769 // TODO: this should happen when stashing the ParserOutput, not now!
770 $output->setCacheTime( $stashedEdit->timestamp );
771
772 // TODO: MCR: allow output for all slots to be stashed.
773 $this->canonicalParserOutput = $output;
774 }
775
776 $userPopts = ParserOptions::newFromUserAndLang( $user, $this->contLang );
777 Hooks::run( 'ArticlePrepareTextForEdit', [ $wikiPage, $userPopts ] );
778
779 $this->user = $user;
780 $this->slotsUpdate = $slotsUpdate;
781
782 if ( $parentRevision ) {
783 $this->revision = MutableRevisionRecord::newFromParentRevision( $parentRevision );
784 } else {
785 $this->revision = new MutableRevisionRecord( $title );
786 }
787
788 // NOTE: user and timestamp must be set, so they can be used for
789 // {{subst:REVISIONUSER}} and {{subst:REVISIONTIMESTAMP}} in PST!
790 $this->revision->setTimestamp( wfTimestampNow() );
791 $this->revision->setUser( $user );
792
793 // Set up ParserOptions to operate on the new revision
794 $oldCallback = $userPopts->getCurrentRevisionCallback();
795 $userPopts->setCurrentRevisionCallback(
796 function ( Title $parserTitle, $parser = false ) use ( $title, $oldCallback ) {
797 if ( $parserTitle->equals( $title ) ) {
798 $legacyRevision = new Revision( $this->revision );
799 return $legacyRevision;
800 } else {
801 return call_user_func( $oldCallback, $parserTitle, $parser );
802 }
803 }
804 );
805
806 $pstContentSlots = $this->revision->getSlots();
807
808 foreach ( $slotsUpdate->getModifiedRoles() as $role ) {
809 $slot = $slotsUpdate->getModifiedSlot( $role );
810
811 if ( $slot->isInherited() ) {
812 // No PST for inherited slots! Note that "modified" slots may still be inherited
813 // from an earlier version, e.g. for rollbacks.
814 $pstSlot = $slot;
815 } elseif ( $role === SlotRecord::MAIN && $stashedEdit ) {
816 // TODO: MCR: allow PST content for all slots to be stashed.
817 $pstSlot = SlotRecord::newUnsaved( $role, $stashedEdit->pstContent );
818 } else {
819 $content = $slot->getContent();
820 $pstContent = $content->preSaveTransform( $title, $this->user, $userPopts );
821 $pstSlot = SlotRecord::newUnsaved( $role, $pstContent );
822 }
823
824 $pstContentSlots->setSlot( $pstSlot );
825 }
826
827 foreach ( $slotsUpdate->getRemovedRoles() as $role ) {
828 $pstContentSlots->removeSlot( $role );
829 }
830
831 $this->options['created'] = ( $parentRevision === null );
832 $this->options['changed'] = ( $parentRevision === null
833 || !$pstContentSlots->hasSameContent( $parentRevision->getSlots() ) );
834
835 $this->doTransition( 'has-content' );
836
837 if ( !$this->options['changed'] ) {
838 // null-edit!
839
840 // TODO: move this into MutableRevisionRecord
841 // TODO: This needs to behave differently for a forced dummy edit!
842 $this->revision->setId( $parentRevision->getId() );
843 $this->revision->setTimestamp( $parentRevision->getTimestamp() );
844 $this->revision->setPageId( $parentRevision->getPageId() );
845 $this->revision->setParentId( $parentRevision->getParentId() );
846 $this->revision->setUser( $parentRevision->getUser( RevisionRecord::RAW ) );
847 $this->revision->setComment( $parentRevision->getComment( RevisionRecord::RAW ) );
848 $this->revision->setMinorEdit( $parentRevision->isMinor() );
849 $this->revision->setVisibility( $parentRevision->getVisibility() );
850
851 // prepareUpdate() is redundant for null-edits
852 $this->doTransition( 'has-revision' );
853 } else {
854 $this->parentRevision = $parentRevision;
855 }
856 }
857
858 /**
859 * Returns the update's target revision - that is, the revision that will be the current
860 * revision after the update.
861 *
862 * @note Callers must treat the returned RevisionRecord's content as immutable, even
863 * if it is a MutableRevisionRecord instance. Other aspects of a MutableRevisionRecord
864 * returned from here, such as the user or the comment, may be changed, but may not
865 * be reflected in ParserOutput until after prepareUpdate() has been called.
866 *
867 * @todo This is currently used by PageUpdater::makeNewRevision() to construct an unsaved
868 * MutableRevisionRecord instance. Introduce something like an UnsavedRevisionFactory service
869 * for that purpose instead!
870 *
871 * @return RevisionRecord
872 */
873 public function getRevision() {
874 $this->assertPrepared( __METHOD__ );
875 return $this->revision;
876 }
877
878 /**
879 * @return RenderedRevision
880 */
881 public function getRenderedRevision() {
882 if ( !$this->renderedRevision ) {
883 $this->assertPrepared( __METHOD__ );
884
885 // NOTE: we want a canonical rendering, so don't pass $this->user or ParserOptions
886 // NOTE: the revision is either new or current, so we can bypass audience checks.
887 $this->renderedRevision = $this->revisionRenderer->getRenderedRevision(
888 $this->revision,
889 null,
890 null,
891 [ 'use-master' => $this->useMaster(), 'audience' => RevisionRecord::RAW ]
892 );
893 }
894
895 return $this->renderedRevision;
896 }
897
898 private function assertHasPageState( $method ) {
899 if ( !$this->pageState ) {
900 throw new LogicException(
901 'Must call grabCurrentRevision() or prepareContent() '
902 . 'or prepareUpdate() before calling ' . $method
903 );
904 }
905 }
906
907 private function assertPrepared( $method ) {
908 if ( !$this->revision ) {
909 throw new LogicException(
910 'Must call prepareContent() or prepareUpdate() before calling ' . $method
911 );
912 }
913 }
914
915 private function assertHasRevision( $method ) {
916 if ( !$this->revision->getId() ) {
917 throw new LogicException(
918 'Must call prepareUpdate() before calling ' . $method
919 );
920 }
921 }
922
923 /**
924 * Whether the edit creates the page.
925 *
926 * @return bool
927 */
928 public function isCreation() {
929 $this->assertPrepared( __METHOD__ );
930 return $this->options['created'];
931 }
932
933 /**
934 * Whether the edit created, or should create, a new revision (that is, it's not a null-edit).
935 *
936 * @warning at present, "null-revisions" that do not change content but do have a revision
937 * record would return false after prepareContent(), but true after prepareUpdate()!
938 * This should probably be fixed.
939 *
940 * @return bool
941 */
942 public function isChange() {
943 $this->assertPrepared( __METHOD__ );
944 return $this->options['changed'];
945 }
946
947 /**
948 * Whether the page was a redirect before the edit.
949 *
950 * @return bool
951 */
952 public function wasRedirect() {
953 $this->assertHasPageState( __METHOD__ );
954
955 if ( $this->pageState['oldIsRedirect'] === null ) {
956 /** @var RevisionRecord $rev */
957 $rev = $this->pageState['oldRevision'];
958 if ( $rev ) {
959 $this->pageState['oldIsRedirect'] = $this->revisionIsRedirect( $rev );
960 } else {
961 $this->pageState['oldIsRedirect'] = false;
962 }
963 }
964
965 return $this->pageState['oldIsRedirect'];
966 }
967
968 /**
969 * Returns the slots of the target revision, after PST.
970 *
971 * @note Callers must treat the returned RevisionSlots instance as immutable, even
972 * if it is a MutableRevisionSlots instance.
973 *
974 * @return RevisionSlots
975 */
976 public function getSlots() {
977 $this->assertPrepared( __METHOD__ );
978 return $this->revision->getSlots();
979 }
980
981 /**
982 * Returns the RevisionSlotsUpdate for this updater.
983 *
984 * @return RevisionSlotsUpdate
985 */
986 private function getRevisionSlotsUpdate() {
987 $this->assertPrepared( __METHOD__ );
988
989 if ( !$this->slotsUpdate ) {
990 $old = $this->getParentRevision();
991 $this->slotsUpdate = RevisionSlotsUpdate::newFromRevisionSlots(
992 $this->revision->getSlots(),
993 $old ? $old->getSlots() : null
994 );
995 }
996 return $this->slotsUpdate;
997 }
998
999 /**
1000 * Returns the role names of the slots touched by the new revision,
1001 * including removed roles.
1002 *
1003 * @return string[]
1004 */
1005 public function getTouchedSlotRoles() {
1006 return $this->getRevisionSlotsUpdate()->getTouchedRoles();
1007 }
1008
1009 /**
1010 * Returns the role names of the slots modified by the new revision,
1011 * not including removed roles.
1012 *
1013 * @return string[]
1014 */
1015 public function getModifiedSlotRoles() {
1016 return $this->getRevisionSlotsUpdate()->getModifiedRoles();
1017 }
1018
1019 /**
1020 * Returns the role names of the slots removed by the new revision.
1021 *
1022 * @return string[]
1023 */
1024 public function getRemovedSlotRoles() {
1025 return $this->getRevisionSlotsUpdate()->getRemovedRoles();
1026 }
1027
1028 /**
1029 * Prepare derived data updates targeting the given Revision.
1030 *
1031 * Calling this method requires the given revision to be present in the database.
1032 * This may be right after a new revision has been created, or when re-generating
1033 * derived data e.g. in ApiPurge, RefreshLinksJob, and the refreshLinks
1034 * script.
1035 *
1036 * @see docs/pageupdater.txt for more information on when thie method can and should be called.
1037 *
1038 * @note Calling this method more than once with the same revision has no effect.
1039 * $options are only used for the first call. Calling this method multiple times with
1040 * different revisions will cause an exception.
1041 *
1042 * @note If grabCurrentRevision() (or prepareContent()) has been called before
1043 * calling this method, $revision->getParentRevision() has to refer to the revision that
1044 * was the current revision at the time grabCurrentRevision() was called.
1045 *
1046 * @param RevisionRecord $revision
1047 * @param array $options Array of options, following indexes are used:
1048 * - changed: bool, whether the revision changed the content (default true)
1049 * - created: bool, whether the revision created the page (default false)
1050 * - moved: bool, whether the page was moved (default false)
1051 * - restored: bool, whether the page was undeleted (default false)
1052 * - oldrevision: Revision object for the pre-update revision (default null)
1053 * - triggeringUser: The user triggering the update (UserIdentity, defaults to the
1054 * user who created the revision)
1055 * - oldredirect: bool, null, or string 'no-change' (default null):
1056 * - bool: whether the page was counted as a redirect before that
1057 * revision, only used in changed is true and created is false
1058 * - null or 'no-change': don't update the redirect status.
1059 * - oldcountable: bool, null, or string 'no-change' (default null):
1060 * - bool: whether the page was counted as an article before that
1061 * revision, only used in changed is true and created is false
1062 * - null: if created is false, don't update the article count; if created
1063 * is true, do update the article count
1064 * - 'no-change': don't update the article count, ever
1065 * When set to null, pageState['oldCountable'] will be used instead if available.
1066 * - causeAction: an arbitrary string identifying the reason for the update.
1067 * See DataUpdate::getCauseAction(). (default 'unknown')
1068 * - causeAgent: name of the user who caused the update. See DataUpdate::getCauseAgent().
1069 * (string, default 'unknown')
1070 */
1071 public function prepareUpdate( RevisionRecord $revision, array $options = [] ) {
1072 Assert::parameter(
1073 !isset( $options['oldrevision'] )
1074 || $options['oldrevision'] instanceof Revision
1075 || $options['oldrevision'] instanceof RevisionRecord,
1076 '$options["oldrevision"]',
1077 'must be a RevisionRecord (or Revision)'
1078 );
1079 Assert::parameter(
1080 !isset( $options['triggeringUser'] )
1081 || $options['triggeringUser'] instanceof UserIdentity,
1082 '$options["triggeringUser"]',
1083 'must be a UserIdentity'
1084 );
1085
1086 if ( !$revision->getId() ) {
1087 throw new InvalidArgumentException(
1088 'Revision must have an ID set for it to be used with prepareUpdate()!'
1089 );
1090 }
1091
1092 if ( $this->revision && $this->revision->getId() ) {
1093 if ( $this->revision->getId() === $revision->getId() ) {
1094 return; // nothing to do!
1095 } else {
1096 throw new LogicException(
1097 'Trying to re-use DerivedPageDataUpdater with revision '
1098 . $revision->getId()
1099 . ', but it\'s already bound to revision '
1100 . $this->revision->getId()
1101 );
1102 }
1103 }
1104
1105 if ( $this->revision
1106 && !$this->revision->getSlots()->hasSameContent( $revision->getSlots() )
1107 ) {
1108 throw new LogicException(
1109 'The Revision provided has mismatching content!'
1110 );
1111 }
1112
1113 // Override fields defined in $this->options with values from $options.
1114 $this->options = array_intersect_key( $options, $this->options ) + $this->options;
1115
1116 if ( isset( $this->pageState['oldId'] ) ) {
1117 $oldId = $this->pageState['oldId'];
1118 } elseif ( isset( $this->options['oldrevision'] ) ) {
1119 /** @var Revision|RevisionRecord $oldRev */
1120 $oldRev = $this->options['oldrevision'];
1121 $oldId = $oldRev->getId();
1122 } else {
1123 $oldId = $revision->getParentId();
1124 }
1125
1126 if ( $oldId !== null ) {
1127 // XXX: what if $options['changed'] disagrees?
1128 // MovePage creates a dummy revision with changed = false!
1129 // We may want to explicitly distinguish between "no new revision" (null-edit)
1130 // and "new revision without new content" (dummy revision).
1131
1132 if ( $oldId === $revision->getParentId() ) {
1133 // NOTE: this may still be a NullRevision!
1134 // New revision!
1135 $this->options['changed'] = true;
1136 } elseif ( $oldId === $revision->getId() ) {
1137 // Null-edit!
1138 $this->options['changed'] = false;
1139 } else {
1140 // This indicates that calling code has given us the wrong Revision object
1141 throw new LogicException(
1142 'The Revision mismatches old revision ID: '
1143 . 'Old ID is ' . $oldId
1144 . ', parent ID is ' . $revision->getParentId()
1145 . ', revision ID is ' . $revision->getId()
1146 );
1147 }
1148 }
1149
1150 // If prepareContent() was used to generate the PST content (which is indicated by
1151 // $this->slotsUpdate being set), and this is not a null-edit, then the given
1152 // revision must have the acting user as the revision author. Otherwise, user
1153 // signatures generated by PST would mismatch the user in the revision record.
1154 if ( $this->user !== null && $this->options['changed'] && $this->slotsUpdate ) {
1155 $user = $revision->getUser();
1156 if ( !$this->user->equals( $user ) ) {
1157 throw new LogicException(
1158 'The Revision provided has a mismatching actor: expected '
1159 . $this->user->getName()
1160 . ', got '
1161 . $user->getName()
1162 );
1163 }
1164 }
1165
1166 // If $this->pageState was not yet initialized by grabCurrentRevision or prepareContent,
1167 // emulate the state of the page table before the edit, as good as we can.
1168 if ( !$this->pageState ) {
1169 $this->pageState = [
1170 'oldIsRedirect' => isset( $this->options['oldredirect'] )
1171 && is_bool( $this->options['oldredirect'] )
1172 ? $this->options['oldredirect']
1173 : null,
1174 'oldCountable' => isset( $this->options['oldcountable'] )
1175 && is_bool( $this->options['oldcountable'] )
1176 ? $this->options['oldcountable']
1177 : null,
1178 ];
1179
1180 if ( $this->options['changed'] ) {
1181 // The edit created a new revision
1182 $this->pageState['oldId'] = $revision->getParentId();
1183
1184 if ( isset( $this->options['oldrevision'] ) ) {
1185 $rev = $this->options['oldrevision'];
1186 $this->pageState['oldRevision'] = $rev instanceof Revision
1187 ? $rev->getRevisionRecord()
1188 : $rev;
1189 }
1190 } else {
1191 // This is a null-edit, so the old revision IS the new revision!
1192 $this->pageState['oldId'] = $revision->getId();
1193 $this->pageState['oldRevision'] = $revision;
1194 }
1195 }
1196
1197 // "created" is forced here
1198 $this->options['created'] = ( $this->pageState['oldId'] === 0 );
1199
1200 $this->revision = $revision;
1201
1202 $this->doTransition( 'has-revision' );
1203
1204 // NOTE: in case we have a User object, don't override with a UserIdentity.
1205 // We already checked that $revision->getUser() mathces $this->user;
1206 if ( !$this->user ) {
1207 $this->user = $revision->getUser( RevisionRecord::RAW );
1208 }
1209
1210 // Prune any output that depends on the revision ID.
1211 if ( $this->renderedRevision ) {
1212 $this->renderedRevision->updateRevision( $revision );
1213 }
1214
1215 // TODO: optionally get ParserOutput from the ParserCache here.
1216 // Move the logic used by RefreshLinksJob here!
1217 }
1218
1219 /**
1220 * @deprecated This only exists for B/C, use the getters on DerivedPageDataUpdater directly!
1221 * @return PreparedEdit
1222 */
1223 public function getPreparedEdit() {
1224 $this->assertPrepared( __METHOD__ );
1225
1226 $slotsUpdate = $this->getRevisionSlotsUpdate();
1227 $preparedEdit = new PreparedEdit();
1228
1229 $preparedEdit->popts = $this->getCanonicalParserOptions();
1230 $preparedEdit->output = $this->getCanonicalParserOutput();
1231 $preparedEdit->pstContent = $this->revision->getContent( SlotRecord::MAIN );
1232 $preparedEdit->newContent =
1233 $slotsUpdate->isModifiedSlot( SlotRecord::MAIN )
1234 ? $slotsUpdate->getModifiedSlot( SlotRecord::MAIN )->getContent()
1235 : $this->revision->getContent( SlotRecord::MAIN ); // XXX: can we just remove this?
1236 $preparedEdit->oldContent = null; // unused. // XXX: could get this from the parent revision
1237 $preparedEdit->revid = $this->revision ? $this->revision->getId() : null;
1238 $preparedEdit->timestamp = $preparedEdit->output->getCacheTime();
1239 $preparedEdit->format = $preparedEdit->pstContent->getDefaultFormat();
1240
1241 return $preparedEdit;
1242 }
1243
1244 /**
1245 * @param string $role
1246 * @param bool $generateHtml
1247 * @return ParserOutput
1248 */
1249 public function getSlotParserOutput( $role, $generateHtml = true ) {
1250 return $this->getRenderedRevision()->getSlotParserOutput(
1251 $role,
1252 [ 'generate-html' => $generateHtml ]
1253 );
1254 }
1255
1256 /**
1257 * @return ParserOutput
1258 */
1259 public function getCanonicalParserOutput() {
1260 return $this->getRenderedRevision()->getRevisionParserOutput();
1261 }
1262
1263 /**
1264 * @return ParserOptions
1265 */
1266 public function getCanonicalParserOptions() {
1267 return $this->getRenderedRevision()->getOptions();
1268 }
1269
1270 /**
1271 * @param bool $recursive
1272 *
1273 * @return DeferrableUpdate[]
1274 */
1275 public function getSecondaryDataUpdates( $recursive = false ) {
1276 if ( $this->isContentDeleted() ) {
1277 // This shouldn't happen, since the current content is always public,
1278 // and DataUpates are only needed for current content.
1279 return [];
1280 }
1281
1282 $output = $this->getCanonicalParserOutput();
1283
1284 // Construct a LinksUpdate for the combined canonical output.
1285 $linksUpdate = new LinksUpdate(
1286 $this->getTitle(),
1287 $output,
1288 $recursive
1289 );
1290
1291 $allUpdates = [ $linksUpdate ];
1292
1293 // NOTE: Run updates for all slots, not just the modified slots! Otherwise,
1294 // info for an inherited slot may end up being removed. This is also needed
1295 // to ensure that purges are effective.
1296 $renderedRevision = $this->getRenderedRevision();
1297 foreach ( $this->getSlots()->getSlotRoles() as $role ) {
1298 $slot = $this->getRawSlot( $role );
1299 $content = $slot->getContent();
1300 $handler = $content->getContentHandler();
1301
1302 $updates = $handler->getSecondaryDataUpdates(
1303 $this->getTitle(),
1304 $content,
1305 $role,
1306 $renderedRevision
1307 );
1308 $allUpdates = array_merge( $allUpdates, $updates );
1309
1310 // TODO: remove B/C hack in 1.32!
1311 // NOTE: we assume that the combined output contains all relevant meta-data for
1312 // all slots!
1313 $legacyUpdates = $content->getSecondaryDataUpdates(
1314 $this->getTitle(),
1315 null,
1316 $recursive,
1317 $output
1318 );
1319
1320 // HACK: filter out redundant and incomplete LinksUpdates
1321 $legacyUpdates = array_filter( $legacyUpdates, function ( $update ) {
1322 return !( $update instanceof LinksUpdate );
1323 } );
1324
1325 $allUpdates = array_merge( $allUpdates, $legacyUpdates );
1326 }
1327
1328 // XXX: if a slot was removed by an earlier edit, but deletion updates failed to run at
1329 // that time, we don't know for which slots to run deletion updates when purging a page.
1330 // We'd have to examine the entire history of the page to determine that. Perhaps there
1331 // could be a "try extra hard" mode for that case that would run a DB query to find all
1332 // roles/models ever used on the page. On the other hand, removing slots should be quite
1333 // rare, so perhaps this isn't worth the trouble.
1334
1335 // TODO: consolidate with similar logic in WikiPage::getDeletionUpdates()
1336 $wikiPage = $this->getWikiPage();
1337 $parentRevision = $this->getParentRevision();
1338 foreach ( $this->getRemovedSlotRoles() as $role ) {
1339 // HACK: we should get the content model of the removed slot from a SlotRoleHandler!
1340 // For now, find the slot in the parent revision - if the slot was removed, it should
1341 // always exist in the parent revision.
1342 $parentSlot = $parentRevision->getSlot( $role, RevisionRecord::RAW );
1343 $content = $parentSlot->getContent();
1344 $handler = $content->getContentHandler();
1345
1346 $updates = $handler->getDeletionUpdates(
1347 $this->getTitle(),
1348 $role
1349 );
1350 $allUpdates = array_merge( $allUpdates, $updates );
1351
1352 // TODO: remove B/C hack in 1.32!
1353 $legacyUpdates = $content->getDeletionUpdates( $wikiPage );
1354
1355 // HACK: filter out redundant and incomplete LinksDeletionUpdate
1356 $legacyUpdates = array_filter( $legacyUpdates, function ( $update ) {
1357 return !( $update instanceof LinksDeletionUpdate );
1358 } );
1359
1360 $allUpdates = array_merge( $allUpdates, $legacyUpdates );
1361 }
1362
1363 // TODO: hard deprecate SecondaryDataUpdates in favor of RevisionDataUpdates in 1.33!
1364 Hooks::run(
1365 'RevisionDataUpdates',
1366 [ $this->getTitle(), $renderedRevision, &$allUpdates ]
1367 );
1368
1369 return $allUpdates;
1370 }
1371
1372 /**
1373 * Do standard updates after page edit, purge, or import.
1374 * Update links tables, site stats, search index, title cache, message cache, etc.
1375 * Purges pages that depend on this page when appropriate.
1376 * With a 10% chance, triggers pruning the recent changes table.
1377 *
1378 * @note prepareUpdate() must be called before calling this method!
1379 *
1380 * MCR migration note: this replaces WikiPage::doEditUpdates.
1381 */
1382 public function doUpdates() {
1383 $this->assertTransition( 'done' );
1384
1385 // TODO: move logic into a PageEventEmitter service
1386
1387 $wikiPage = $this->getWikiPage(); // TODO: use only for legacy hooks!
1388
1389 $legacyUser = User::newFromIdentity( $this->user );
1390 $legacyRevision = new Revision( $this->revision );
1391
1392 $this->doParserCacheUpdate();
1393
1394 $this->doSecondaryDataUpdates( [
1395 // T52785 do not update any other pages on a null edit
1396 'recursive' => $this->options['changed'],
1397 'defer' => DeferredUpdates::POSTSEND,
1398 ] );
1399
1400 // TODO: MCR: check if *any* changed slot supports categories!
1401 if ( $this->rcWatchCategoryMembership
1402 && $this->getContentHandler( SlotRecord::MAIN )->supportsCategories() === true
1403 && ( $this->options['changed'] || $this->options['created'] )
1404 && !$this->options['restored']
1405 ) {
1406 // Note: jobs are pushed after deferred updates, so the job should be able to see
1407 // the recent change entry (also done via deferred updates) and carry over any
1408 // bot/deletion/IP flags, ect.
1409 $this->jobQueueGroup->lazyPush(
1410 new CategoryMembershipChangeJob(
1411 $this->getTitle(),
1412 [
1413 'pageId' => $this->getPageId(),
1414 'revTimestamp' => $this->revision->getTimestamp(),
1415 ]
1416 )
1417 );
1418 }
1419
1420 // TODO: replace legacy hook! Use a listener on PageEventEmitter instead!
1421 $editInfo = $this->getPreparedEdit();
1422 Hooks::run( 'ArticleEditUpdates', [ &$wikiPage, &$editInfo, $this->options['changed'] ] );
1423
1424 // TODO: replace legacy hook! Use a listener on PageEventEmitter instead!
1425 if ( Hooks::run( 'ArticleEditUpdatesDeleteFromRecentchanges', [ &$wikiPage ] ) ) {
1426 // Flush old entries from the `recentchanges` table
1427 if ( mt_rand( 0, 9 ) == 0 ) {
1428 $this->jobQueueGroup->lazyPush( RecentChangesUpdateJob::newPurgeJob() );
1429 }
1430 }
1431
1432 $id = $this->getPageId();
1433 $title = $this->getTitle();
1434 $dbKey = $title->getPrefixedDBkey();
1435 $shortTitle = $title->getDBkey();
1436
1437 if ( !$title->exists() ) {
1438 wfDebug( __METHOD__ . ": Page doesn't exist any more, bailing out\n" );
1439
1440 $this->doTransition( 'done' );
1441 return;
1442 }
1443
1444 if ( $this->options['oldcountable'] === 'no-change' ||
1445 ( !$this->options['changed'] && !$this->options['moved'] )
1446 ) {
1447 $good = 0;
1448 } elseif ( $this->options['created'] ) {
1449 $good = (int)$this->isCountable();
1450 } elseif ( $this->options['oldcountable'] !== null ) {
1451 $good = (int)$this->isCountable()
1452 - (int)$this->options['oldcountable'];
1453 } elseif ( isset( $this->pageState['oldCountable'] ) ) {
1454 $good = (int)$this->isCountable()
1455 - (int)$this->pageState['oldCountable'];
1456 } else {
1457 $good = 0;
1458 }
1459 $edits = $this->options['changed'] ? 1 : 0;
1460 $pages = $this->options['created'] ? 1 : 0;
1461
1462 DeferredUpdates::addUpdate( SiteStatsUpdate::factory(
1463 [ 'edits' => $edits, 'articles' => $good, 'pages' => $pages ]
1464 ) );
1465
1466 // TODO: make search infrastructure aware of slots!
1467 $mainSlot = $this->revision->getSlot( SlotRecord::MAIN );
1468 if ( !$mainSlot->isInherited() && !$this->isContentDeleted() ) {
1469 DeferredUpdates::addUpdate( new SearchUpdate( $id, $dbKey, $mainSlot->getContent() ) );
1470 }
1471
1472 // If this is another user's talk page, update newtalk.
1473 // Don't do this if $options['changed'] = false (null-edits) nor if
1474 // it's a minor edit and the user making the edit doesn't generate notifications for those.
1475 if ( $this->options['changed']
1476 && $title->getNamespace() == NS_USER_TALK
1477 && $shortTitle != $legacyUser->getTitleKey()
1478 && !( $this->revision->isMinor() && $legacyUser->isAllowed( 'nominornewtalk' ) )
1479 ) {
1480 $recipient = User::newFromName( $shortTitle, false );
1481 if ( !$recipient ) {
1482 wfDebug( __METHOD__ . ": invalid username\n" );
1483 } else {
1484 // Allow extensions to prevent user notification
1485 // when a new message is added to their talk page
1486 // TODO: replace legacy hook! Use a listener on PageEventEmitter instead!
1487 if ( Hooks::run( 'ArticleEditUpdateNewTalk', [ &$wikiPage, $recipient ] ) ) {
1488 if ( User::isIP( $shortTitle ) ) {
1489 // An anonymous user
1490 $recipient->setNewtalk( true, $legacyRevision );
1491 } elseif ( $recipient->isLoggedIn() ) {
1492 $recipient->setNewtalk( true, $legacyRevision );
1493 } else {
1494 wfDebug( __METHOD__ . ": don't need to notify a nonexistent user\n" );
1495 }
1496 }
1497 }
1498 }
1499
1500 if ( $title->getNamespace() == NS_MEDIAWIKI
1501 && $this->getRevisionSlotsUpdate()->isModifiedSlot( SlotRecord::MAIN )
1502 ) {
1503 $mainContent = $this->isContentDeleted() ? null : $this->getRawContent( SlotRecord::MAIN );
1504
1505 $this->messageCache->updateMessageOverride( $title, $mainContent );
1506 }
1507
1508 // TODO: move onArticleCreate and onArticle into a PageEventEmitter service
1509 if ( $this->options['created'] ) {
1510 WikiPage::onArticleCreate( $title );
1511 } elseif ( $this->options['changed'] ) { // T52785
1512 WikiPage::onArticleEdit( $title, $legacyRevision, $this->getTouchedSlotRoles() );
1513 }
1514
1515 $oldRevision = $this->getParentRevision();
1516 $oldLegacyRevision = $oldRevision ? new Revision( $oldRevision ) : null;
1517
1518 // TODO: In the wiring, register a listener for this on the new PageEventEmitter
1519 ResourceLoaderWikiModule::invalidateModuleCache(
1520 $title, $oldLegacyRevision, $legacyRevision, $this->getWikiId() ?: wfWikiID()
1521 );
1522
1523 $this->doTransition( 'done' );
1524 }
1525
1526 /**
1527 * Do secondary data updates (such as updating link tables).
1528 *
1529 * MCR note: this method is temporarily exposed via WikiPage::doSecondaryDataUpdates.
1530 *
1531 * @param array $options
1532 * - recursive: make the update recursive, i.e. also update pages which transclude the
1533 * current page or otherwise depend on it (default: false)
1534 * - defer: one of the DeferredUpdates constants, or false to run immediately after waiting
1535 * for replication of the changes from the SecondaryDataUpdates hooks (default: false)
1536 * - transactionTicket: a transaction ticket from LBFactory::getEmptyTransactionTicket(),
1537 * only when defer is false (default: null)
1538 * @since 1.32
1539 */
1540 public function doSecondaryDataUpdates( array $options = [] ) {
1541 $this->assertHasRevision( __METHOD__ );
1542 $options += [
1543 'recursive' => false,
1544 'defer' => false,
1545 'transactionTicket' => null,
1546 ];
1547 $deferValues = [ false, DeferredUpdates::PRESEND, DeferredUpdates::POSTSEND ];
1548 if ( !in_array( $options['defer'], $deferValues, true ) ) {
1549 throw new InvalidArgumentException( 'invalid value for defer: ' . $options['defer'] );
1550 }
1551 Assert::parameterType( 'integer|null', $options['transactionTicket'],
1552 '$options[\'transactionTicket\']' );
1553
1554 $updates = $this->getSecondaryDataUpdates( $options['recursive'] );
1555
1556 $triggeringUser = $this->options['triggeringUser'] ?? $this->user;
1557 if ( !$triggeringUser instanceof User ) {
1558 $triggeringUser = User::newFromIdentity( $triggeringUser );
1559 }
1560 $causeAction = $this->options['causeAction'] ?? 'unknown';
1561 $causeAgent = $this->options['causeAgent'] ?? 'unknown';
1562 $legacyRevision = new Revision( $this->revision );
1563
1564 if ( $options['defer'] === false && $options['transactionTicket'] !== null ) {
1565 // For legacy hook handlers doing updates via LinksUpdateConstructed, make sure
1566 // any pending writes they made get flushed before the doUpdate() calls below.
1567 // This avoids snapshot-clearing errors in LinksUpdate::acquirePageLock().
1568 $this->loadbalancerFactory->commitAndWaitForReplication(
1569 __METHOD__, $options['transactionTicket']
1570 );
1571 }
1572
1573 foreach ( $updates as $update ) {
1574 if ( $update instanceof DataUpdate ) {
1575 $update->setCause( $causeAction, $causeAgent );
1576 }
1577 if ( $update instanceof LinksUpdate ) {
1578 $update->setRevision( $legacyRevision );
1579 $update->setTriggeringUser( $triggeringUser );
1580 }
1581 if ( $options['defer'] === false ) {
1582 if ( $options['transactionTicket'] !== null ) {
1583 $update->setTransactionTicket( $options['transactionTicket'] );
1584 }
1585 $update->doUpdate();
1586 } else {
1587 DeferredUpdates::addUpdate( $update, $options['defer'] );
1588 }
1589 }
1590 }
1591
1592 public function doParserCacheUpdate() {
1593 $this->assertHasRevision( __METHOD__ );
1594
1595 $wikiPage = $this->getWikiPage(); // TODO: ParserCache should accept a RevisionRecord instead
1596
1597 // NOTE: this may trigger the first parsing of the new content after an edit (when not
1598 // using pre-generated stashed output).
1599 // XXX: we may want to use the PoolCounter here. This would perhaps allow the initial parse
1600 // to be performed post-send. The client could already follow a HTTP redirect to the
1601 // page view, but would then have to wait for a response until rendering is complete.
1602 $output = $this->getCanonicalParserOutput();
1603
1604 // Save it to the parser cache. Use the revision timestamp in the case of a
1605 // freshly saved edit, as that matches page_touched and a mismatch would trigger an
1606 // unnecessary reparse.
1607 $timestamp = $this->options['changed'] ? $this->revision->getTimestamp()
1608 : $output->getTimestamp();
1609 $this->parserCache->save(
1610 $output, $wikiPage, $this->getCanonicalParserOptions(),
1611 $timestamp, $this->revision->getId()
1612 );
1613 }
1614
1615 }
Wiklou, le Wiki du Wiklou