PoolWorkArticleViewCurrent.php

Go to the documentation of this file.

<?php
use MediaWiki\Logger\Spi as LoggerSpi;
use MediaWiki\Page\PageRecord;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionRenderer;
use Wikimedia\Rdbms\ILBFactory;
 
class PoolWorkArticleViewCurrent extends PoolWorkArticleView {
 
    private $workKey;
 
    private $page;
 
    private $parserCache;
 
    private $lbFactory;
 
    private $wikiPageFactory;
 
    public function __construct(
        string $workKey,
        PageRecord $page,
        RevisionRecord $revision,
        ParserOptions $parserOptions,
        RevisionRenderer $revisionRenderer,
        ParserCache $parserCache,
        ILBFactory $lbFactory,
        LoggerSpi $loggerSpi,
        WikiPageFactory $wikiPageFactory
    ) {
        // 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->wikiPageFactory = $wikiPageFactory;
        $this->cacheable = true;
    }
 
    protected function saveInCache( ParserOutput $output, string $cacheTime ) {
        $this->parserCache->save(
            $output,
            $this->page,
            $this->parserOptions,
            $cacheTime,
            $this->revision->getId()
        );
    }
 
    protected function afterWork( ParserOutput $output ) {
        $this->wikiPageFactory->newFromTitle( $this->page )
            ->triggerOpportunisticLinksUpdate( $this->parserOutput );
    }
 
    public function getCachedWork() {
        $this->parserOutput = $this->parserCache->get( $this->page, $this->parserOptions );
 
        $logger = $this->getLogger();
        if ( $this->parserOutput === false ) {
            $logger->debug( 'parser cache miss' );
            return false;
        } else {
            $logger->debug( 'parser cache hit' );
            return true;
        }
    }
 
    public function fallback( $fast ) {
        $this->parserOutput = $this->parserCache->getDirty( $this->page, $this->parserOptions );
 
        $logger = $this->getLogger( 'dirty' );
 
        $fastMsg = '';
        if ( $this->parserOutput && $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->lbFactory->getChronologyProtectorTouched();
            $cacheTime = MWTimestamp::convert( TS_UNIX, $this->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.
                $this->parserOutput = false;
                return false;
            }
            $this->isFast = true;
            $fastMsg = 'fast ';
        }
 
        if ( $this->parserOutput === false ) {
            $logger->info( 'dirty missing' );
            return false;
        } else {
            $logger->info( "{$fastMsg}dirty output", [ 'workKey' => $this->workKey ] );
            $this->isDirty = true;
            return true;
        }
    }
}