PoolWorkArticleViewCurrent.php

Go to the documentation of this file.

<?php
namespace MediaWiki\PoolCounter;
 
use InvalidArgumentException;
use MediaWiki\Logger\Spi as LoggerSpi;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageRecord;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionRenderer;
use MediaWiki\Status\Status;
use MediaWiki\Utils\MWTimestamp;
use ParserCache;
use ParserOptions;
use Wikimedia\Rdbms\ChronologyProtector;
use Wikimedia\Rdbms\ILBFactory;
 
class PoolWorkArticleViewCurrent extends PoolWorkArticleView {
    private $workKey;
    private $page;
    private $parserCache;
    private $lbFactory;
    private $wikiPageFactory;
    private bool $triggerLinksUpdate;
    private ChronologyProtector $chronologyProtector;
 
    public function __construct(
        string $workKey,
        PageRecord $page,
        RevisionRecord $revision,
        ParserOptions $parserOptions,
        RevisionRenderer $revisionRenderer,
        ParserCache $parserCache,
        ILBFactory $lbFactory,
        ChronologyProtector $chronologyProtector,
        LoggerSpi $loggerSpi,
        WikiPageFactory $wikiPageFactory,
        bool $cacheable = true,
        bool $triggerLinksUpdate = false
    ) {
        // TODO: Remove support for partially initialized RevisionRecord instances once
        //       Article no longer uses fake revisions.
        if ( $revision->getPageId() && $revision->getPageId() !== $page->getId() ) {
            throw new InvalidArgumentException( '$page parameter mismatches $revision parameter' );
        }
 
        parent::__construct( $workKey, $revision, $parserOptions, $revisionRenderer, $loggerSpi );
 
        $this->workKey = $workKey;
        $this->page = $page;
        $this->parserCache = $parserCache;
        $this->lbFactory = $lbFactory;
        $this->chronologyProtector = $chronologyProtector;
        $this->wikiPageFactory = $wikiPageFactory;
        $this->cacheable = $cacheable;
        $this->triggerLinksUpdate = $triggerLinksUpdate;
    }
 
    public function doWork() {
        // T371713: Temporary statistics collection code to determine
        // feasibility of Parsoid selective update
        $sampleRate = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ParsoidSelectiveUpdateSampleRate
        );
        $doSample = ( $sampleRate && mt_rand( 1, $sampleRate ) === 1 );
 
        $previousOutput = null;
        if ( $this->parserOptions->getUseParsoid() || $doSample ) {
            // Parsoid can do selective updates, so it is worth checking the
            // cache for an existing entry.  Not worth it for the legacy
            // parser, though.
            $previousOutput = $this->parserCache->getDirty( $this->page, $this->parserOptions ) ?: null;
        }
        $status = $this->renderRevision( $previousOutput, $doSample, 'PoolWorkArticleViewCurrent' );
        $output = $status->getValue();
 
        if ( $output ) {
            if ( $this->cacheable && $output->isCacheable() ) {
                $this->parserCache->save(
                    $output,
                    $this->page,
                    $this->parserOptions
                );
            }
 
            if ( $this->triggerLinksUpdate ) {
                $this->wikiPageFactory->newFromTitle( $this->page )->triggerOpportunisticLinksUpdate( $output );
            }
        }
 
        return $status;
    }
 
    public function getCachedWork() {
        $parserOutput = $this->parserCache->get( $this->page, $this->parserOptions );
 
        $logger = $this->loggerSpi->getLogger( 'PoolWorkArticleView' );
        $logger->debug( $parserOutput ? 'parser cache hit' : 'parser cache miss' );
 
        return $parserOutput ? Status::newGood( $parserOutput ) : false;
    }
 
    public function fallback( $fast ) {
        $parserOutput = $this->parserCache->getDirty( $this->page, $this->parserOptions );
 
        $logger = $this->loggerSpi->getLogger( 'dirty' );
 
        if ( !$parserOutput ) {
            $logger->info( 'dirty missing' );
            return false;
        }
 
        if ( $fast ) {
            /* Check if the stale response is from before the last write to the
             * DB by this user. Declining to return a stale response in this
             * case ensures that the user will see their own edit after page
             * save.
             *
             * Note that the CP touch time is the timestamp of the shutdown of
             * the save request, so there is a bias towards avoiding fast stale
             * responses of potentially several seconds.
             */
            $lastWriteTime = $this->chronologyProtector->getTouched( $this->lbFactory->getMainLB() );
            $cacheTime = MWTimestamp::convert( TS_UNIX, $parserOutput->getCacheTime() );
            if ( $lastWriteTime && $cacheTime <= $lastWriteTime ) {
                $logger->info(
                    'declining to send dirty output since cache time ' .
                    '{cacheTime} is before last write time {lastWriteTime}',
                    [
                        'workKey' => $this->workKey,
                        'cacheTime' => $cacheTime,
                        'lastWriteTime' => $lastWriteTime,
                    ]
                );
                // Forget this ParserOutput -- we will request it again if
                // necessary in slow mode. There might be a newer entry
                // available by that time.
                return false;
            }
        }
 
        $logger->info( $fast ? 'fast dirty output' : 'dirty output', [ 'workKey' => $this->workKey ] );
 
        $status = Status::newGood( $parserOutput );
        $status->warning( 'view-pool-dirty-output' );
        $status->warning( $fast ? 'view-pool-contention' : 'view-pool-overload' );
        return $status;
    }
 
}
 
class_alias( PoolWorkArticleViewCurrent::class, 'PoolWorkArticleViewCurrent' );