LinksUpdate.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Deferred\LinksUpdate;
 
use InvalidArgumentException;
use MediaWiki\Cache\BacklinkCache;
use MediaWiki\Deferred\AutoCommitUpdate;
use MediaWiki\Deferred\DataUpdate;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\JobQueue\Job;
use MediaWiki\JobQueue\Jobs\RefreshLinksJob;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageReference;
use MediaWiki\Page\PageReferenceValue;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use RuntimeException;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\ScopedCallback;
 
class LinksUpdate extends DataUpdate {
    use ProtectedHookAccessorTrait;
 
    protected $mId;
 
    protected $mTitle;
 
    protected $mParserOutput;
 
    protected $mRecursive;
 
    protected $mMaybeRedirectChanged;
 
    private $mRevisionRecord;
 
    private $user;
 
    private $db;
 
    private $tableFactory;
 
    private IConnectionProvider $dbProvider;
 
    public function __construct(
        PageIdentity $page,
        ParserOutput $parserOutput,
        $recursive = true,
        $maybeRedirectChanged = true
    ) {
        parent::__construct();
 
        $this->mTitle = Title::newFromPageIdentity( $page );
        $this->mParserOutput = $parserOutput;
        $this->mRecursive = $recursive;
        $this->mMaybeRedirectChanged = $maybeRedirectChanged;
 
        $services = MediaWikiServices::getInstance();
        $config = $services->getMainConfig();
        $this->tableFactory = new LinksTableGroup(
            $services->getObjectFactory(),
            $services->getDBLoadBalancerFactory(),
            $services->getCollationFactory(),
            $page,
            $services->getLinkTargetLookup(),
            $config->get( MainConfigNames::UpdateRowsPerQuery ),
            $config->get( MainConfigNames::TempCategoryCollations )
        );
        // TODO: this does not have to be called in LinksDeletionUpdate
        $this->tableFactory->setParserOutput( $parserOutput );
        $this->dbProvider = $services->getDBLoadBalancerFactory();
    }
 
    public function setTransactionTicket( $ticket ) {
        parent::setTransactionTicket( $ticket );
        $this->tableFactory->setTransactionTicket( $ticket );
    }
 
    public function setMoveDetails( PageReference $oldPage ) {
        $this->tableFactory->setMoveDetails( $oldPage );
    }
 
    public function doUpdate() {
        if ( !$this->mId ) {
            // NOTE: subclasses may initialize mId directly!
            $this->mId = $this->mTitle->getArticleID( IDBAccessObject::READ_LATEST );
        }
 
        if ( !$this->mId ) {
            // Probably due to concurrent deletion or renaming of the page
            $logger = LoggerFactory::getInstance( 'SecondaryDataUpdate' );
            $logger->warning(
                'LinksUpdate: The Title object yields no ID. Perhaps the page was deleted?',
                [
                    'page_title' => $this->mTitle->getPrefixedDBkey(),
                    'cause_action' => $this->getCauseAction(),
                    'cause_agent' => $this->getCauseAgent()
                ]
            );
 
            // nothing to do
            return;
        }
 
        // Do any setup that needs to be done prior to acquiring the lock
        // Calling getAll() here has the side-effect of calling
        // LinksUpdateBatch::setParserOutput() on all subclasses, allowing
        // those methods to also do pre-lock operations.
        foreach ( $this->tableFactory->getAll() as $table ) {
            $table->beforeLock();
        }
 
        if ( $this->ticket ) {
            // Make sure all links update threads see the changes of each other.
            // This handles the case when updates have to batched into several COMMITs.
            $scopedLock = self::acquirePageLock( $this->getDB(), $this->mId );
            if ( !$scopedLock ) {
                throw new RuntimeException( "Could not acquire lock for page ID '{$this->mId}'." );
            }
        }
 
        $this->getHookRunner()->onLinksUpdate( $this );
        $this->doIncrementalUpdate();
 
        // Commit and release the lock (if set)
        ScopedCallback::consume( $scopedLock );
        // Run post-commit hook handlers without DBO_TRX
        DeferredUpdates::addUpdate( new AutoCommitUpdate(
            $this->getDB(),
            __METHOD__,
            function () {
                $this->getHookRunner()->onLinksUpdateComplete( $this, $this->ticket );
            }
        ) );
    }
 
    public static function acquirePageLock( IDatabase $dbw, $pageId, $why = 'atomicity' ) {
        $key = "{$dbw->getDomainID()}:LinksUpdate:$why:pageid:$pageId"; // per-wiki
        $scopedLock = $dbw->getScopedLockAndFlush( $key, __METHOD__, 15 );
        if ( !$scopedLock ) {
            $logger = LoggerFactory::getInstance( 'SecondaryDataUpdate' );
            $logger->info( "Could not acquire lock '{key}' for page ID '{page_id}'.", [
                'key' => $key,
                'page_id' => $pageId,
            ] );
            return null;
        }
 
        return $scopedLock;
    }
 
    protected function doIncrementalUpdate() {
        foreach ( $this->tableFactory->getAll() as $table ) {
            $table->update();
        }
 
        # Refresh links of all pages including this page
        # This will be in a separate transaction
        if ( $this->mRecursive ) {
            $this->queueRecursiveJobs();
        }
 
        # Update the links table freshness for this title
        $this->updateLinksTimestamp();
    }
 
    protected function queueRecursiveJobs() {
        $services = MediaWikiServices::getInstance();
        $backlinkCache = $services->getBacklinkCacheFactory()
            ->getBacklinkCache( $this->mTitle );
        $action = $this->getCauseAction();
        $agent = $this->getCauseAgent();
 
        self::queueRecursiveJobsForTable(
            $this->mTitle, 'templatelinks', $action, $agent, $backlinkCache
        );
        if ( $this->mMaybeRedirectChanged && $this->mTitle->getNamespace() === NS_FILE ) {
            // Process imagelinks in case the redirect target has changed
            self::queueRecursiveJobsForTable(
                $this->mTitle, 'imagelinks', $action, $agent, $backlinkCache
            );
        }
 
        // Get jobs for cascade-protected backlinks for a high priority queue.
        // If meta-templates change to using a new template, the new template
        // should be implicitly protected as soon as possible, if applicable.
        // These jobs duplicate a subset of the above ones, but can run sooner.
        // Which ever runs first generally no-ops the other one.
        $jobs = [];
        foreach ( $backlinkCache->getCascadeProtectedLinkPages() as $page ) {
            $jobs[] = RefreshLinksJob::newPrioritized(
                $page,
                [
                    'causeAction' => $action,
                    'causeAgent' => $agent
                ]
            );
        }
        $services->getJobQueueGroup()->push( $jobs );
    }
 
    public static function queueRecursiveJobsForTable(
        PageIdentity $page, $table, $action = 'LinksUpdate', $userName = 'unknown', ?BacklinkCache $backlinkCache = null
    ) {
        $title = Title::newFromPageIdentity( $page );
        if ( !$backlinkCache ) {
            wfDeprecatedMsg( __METHOD__ . " needs a BacklinkCache object, null passed", '1.37' );
            $backlinkCache = MediaWikiServices::getInstance()->getBacklinkCacheFactory()
                ->getBacklinkCache( $title );
        }
        if ( $backlinkCache->hasLinks( $table ) ) {
            $job = new RefreshLinksJob(
                $title,
                [
                    'table' => $table,
                    'recursive' => true,
                ] + Job::newRootJobParams( // "overall" refresh links job info
                    "refreshlinks:{$table}:{$title->getPrefixedText()}"
                ) + [ 'causeAction' => $action, 'causeAgent' => $userName ]
            );
 
            MediaWikiServices::getInstance()->getJobQueueGroup()->push( $job );
        }
    }
 
    public function setStrictTestMode( $mode = true ) {
        $this->tableFactory->setStrictTestMode( $mode );
    }
 
    public function getTitle() {
        return $this->mTitle;
    }
 
    public function getPageId() {
        if ( $this->mId ) {
            return $this->mId;
        } else {
            return $this->mTitle->getArticleID();
        }
    }
 
    public function getParserOutput() {
        return $this->mParserOutput;
    }
 
    public function getImages() {
        wfDeprecated( __METHOD__, '1.44' ); // unused
        return $this->getParserOutput()->getImages();
    }
 
    public function setRevisionRecord( RevisionRecord $revisionRecord ) {
        $this->mRevisionRecord = $revisionRecord;
        $this->tableFactory->setRevision( $revisionRecord );
    }
 
    public function getRevisionRecord() {
        return $this->mRevisionRecord;
    }
 
    public function setTriggeringUser( UserIdentity $user ) {
        $this->user = $user;
    }
 
    public function getTriggeringUser(): ?UserIdentity {
        return $this->user;
    }
 
    protected function getPageLinksTable(): PageLinksTable {
        // @phan-suppress-next-line PhanTypeMismatchReturnSuperType
        return $this->tableFactory->get( 'pagelinks' );
    }
 
    protected function getExternalLinksTable(): ExternalLinksTable {
        // @phan-suppress-next-line PhanTypeMismatchReturnSuperType
        return $this->tableFactory->get( 'externallinks' );
    }
 
    protected function getPagePropsTable(): PagePropsTable {
        // @phan-suppress-next-line PhanTypeMismatchReturnSuperType
        return $this->tableFactory->get( 'page_props' );
    }
 
    public function getAddedLinks() {
        wfDeprecated( __METHOD__, '1.43' );
        return $this->getPageLinksTable()->getTitleArray( LinksTable::INSERTED );
    }
 
    public function getRemovedLinks() {
        wfDeprecated( __METHOD__, '1.43' );
        return $this->getPageLinksTable()->getTitleArray( LinksTable::DELETED );
    }
 
    public function getAddedExternalLinks() {
        return $this->getExternalLinksTable()->getStringArray( LinksTable::INSERTED );
    }
 
    public function getRemovedExternalLinks() {
        return $this->getExternalLinksTable()->getStringArray( LinksTable::DELETED );
    }
 
    public function getAddedProperties() {
        return $this->getPagePropsTable()->getAssocArray( LinksTable::INSERTED );
    }
 
    public function getRemovedProperties() {
        return $this->getPagePropsTable()->getAssocArray( LinksTable::DELETED );
    }
 
    public function getPageReferenceIterator( $tableName, $setType ) {
        $table = $this->tableFactory->get( $tableName );
        if ( $table instanceof TitleLinksTable ) {
            return $table->getPageReferenceIterator( $setType );
        } else {
            throw new InvalidArgumentException(
                __METHOD__ . ": $tableName does not have a list of titles" );
        }
    }
 
    public function getPageReferenceArray( $tableName, $setType ) {
        return iterator_to_array( $this->getPageReferenceIterator( $tableName, $setType ) );
    }
 
    protected function updateLinksTimestamp() {
        if ( $this->mId ) {
            // The link updates made here only reflect the freshness of the parser output
            $timestamp = $this->mParserOutput->getCacheTime();
            $this->getDB()->newUpdateQueryBuilder()
                ->update( 'page' )
                ->set( [ 'page_links_updated' => $this->getDB()->timestamp( $timestamp ) ] )
                ->where( [ 'page_id' => $this->mId ] )
                ->caller( __METHOD__ )->execute();
        }
    }
 
    protected function getDB() {
        if ( !$this->db ) {
            $this->db = $this->dbProvider->getPrimaryDatabase();
        }
 
        return $this->db;
    }
 
    public function isRecursive() {
        return $this->mRecursive;
    }
}