ParserCache.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MediaWikiServices;
 
class ParserCache {
    private const USE_CURRENT_ONLY = 0;
 
    private const USE_EXPIRED = 1;
 
    private const USE_OUTDATED = 2;
 
    private const USE_ANYTHING = 3;
 
    private $cache;
 
    private $cacheEpoch;
 
    private $hookRunner;
 
    private $stats;
 
    public static function singleton() {
        wfDeprecated( __METHOD__, '1.30' );
        return MediaWikiServices::getInstance()->getParserCache();
    }
 
    public function __construct(
        BagOStuff $cache,
        $cacheEpoch = '20030516000000',
        HookContainer $hookContainer = null,
        IBufferingStatsdDataFactory $stats = null
    ) {
        $this->cache = $cache;
        $this->cacheEpoch = $cacheEpoch;
        $this->hookRunner = new HookRunner(
            $hookContainer ?: MediaWikiServices::getInstance()->getHookContainer()
        );
        $this->stats = $stats ?: MediaWikiServices::getInstance()->getStatsdDataFactory();
    }
 
    protected function getParserOutputKey( WikiPage $wikiPage, $hash ) {
        global $wgRequest;
 
        // idhash seem to mean 'page id' + 'rendering hash' (r3710)
        $pageid = $wikiPage->getId();
        $renderkey = (int)( $wgRequest->getVal( 'action' ) == 'render' );
 
        $key = $this->cache->makeKey( 'pcache', 'idhash', "{$pageid}-{$renderkey}!{$hash}" );
        return $key;
    }
 
    protected function getOptionsKey( WikiPage $wikiPage ) {
        return $this->cache->makeKey( 'pcache', 'idoptions', $wikiPage->getId() );
    }
 
    public function deleteOptionsKey( WikiPage $wikiPage ) {
        $this->cache->delete( $this->getOptionsKey( $wikiPage ) );
    }
 
    public function getETag( WikiPage $wikiPage, $popts ) {
        return 'W/"'
            . $this->getParserOutputKey(
                $wikiPage,
                $popts->optionsHash(
                    ParserOptions::allCacheVaryingOptions(),
                    $wikiPage->getTitle()
                )
            )
            . "--" . $wikiPage->getTouched() . '"';
    }
 
    public function getDirty( WikiPage $wikiPage, $popts ) {
        $value = $this->get( $wikiPage, $popts, true );
        return is_object( $value ) ? $value : false;
    }
 
    private function incrementStats( WikiPage $wikiPage, $metricSuffix ) {
        $contentModel = str_replace( '.', '_', $wikiPage->getContentModel() );
        $metricSuffix = str_replace( '.', '_', $metricSuffix );
        $this->stats->increment( 'pcache.' . $contentModel . '.' . $metricSuffix );
    }
 
    public function getKey( WikiPage $wikiPage, $popts, $useOutdated = self::USE_ANYTHING ) {
        if ( is_bool( $useOutdated ) ) {
            $useOutdated = $useOutdated ? self::USE_ANYTHING : self::USE_CURRENT_ONLY;
        }
 
        if ( $popts instanceof User ) {
            wfWarn( "Use of outdated prototype ParserCache::getKey( &\$wikiPage, &\$user )\n" );
            $popts = ParserOptions::newFromUser( $popts );
        }
 
        // Determine the options which affect this article
        $optionsKey = $this->cache->get(
            $this->getOptionsKey( $wikiPage ), BagOStuff::READ_VERIFIED );
        if ( $optionsKey instanceof CacheTime ) {
            if (
                $useOutdated < self::USE_EXPIRED
                && $optionsKey->expired( $wikiPage->getTouched() )
            ) {
                $this->incrementStats( $wikiPage, "miss.expired" );
                $cacheTime = $optionsKey->getCacheTime();
                wfDebugLog( "ParserCache",
                    "Parser options key expired, touched {$wikiPage->getTouched()}"
                    . ", epoch {$this->cacheEpoch}, cached $cacheTime" );
                return false;
            } elseif ( $useOutdated < self::USE_OUTDATED &&
                $optionsKey->isDifferentRevision( $wikiPage->getLatest() )
            ) {
                $this->incrementStats( $wikiPage, "miss.revid" );
                $revId = $wikiPage->getLatest();
                $cachedRevId = $optionsKey->getCacheRevisionId();
                wfDebugLog( "ParserCache",
                    "ParserOutput key is for an old revision, latest $revId, cached $cachedRevId"
                );
                return false;
            }
 
            // $optionsKey->mUsedOptions is set by save() by calling ParserOutput::getUsedOptions()
            $usedOptions = $optionsKey->mUsedOptions;
            wfDebug( "Parser cache options found." );
        } else {
            if ( $useOutdated < self::USE_ANYTHING ) {
                return false;
            }
            $usedOptions = ParserOptions::allCacheVaryingOptions();
        }
 
        return $this->getParserOutputKey(
            $wikiPage,
            $popts->optionsHash( $usedOptions, $wikiPage->getTitle() )
        );
    }
 
    public function get( Page $wikiPage, $popts, $useOutdated = false ) {
        if ( $wikiPage instanceof Article ) {
            wfDeprecated(
                __METHOD__ . ' with Article parameter',
                '1.35'
            );
            $wikiPage = $wikiPage->getPage();
        }
 
        $canCache = $wikiPage->checkTouched();
        if ( !$canCache ) {
            // It's a redirect now
            return false;
        }
 
        $touched = $wikiPage->getTouched();
 
        $parserOutputKey = $this->getKey( $wikiPage, $popts,
            $useOutdated ? self::USE_OUTDATED : self::USE_CURRENT_ONLY
        );
        if ( $parserOutputKey === false ) {
            $this->incrementStats( $wikiPage, 'miss.absent' );
            return false;
        }
 
        $casToken = null;
        $value = $this->cache->get( $parserOutputKey, BagOStuff::READ_VERIFIED );
        if ( !$value ) {
            wfDebug( "ParserOutput cache miss." );
            $this->incrementStats( $wikiPage, "miss.absent" );
            return false;
        }
 
        wfDebug( "ParserOutput cache found." );
 
        if ( !$useOutdated && $value->expired( $touched ) ) {
            $this->incrementStats( $wikiPage, "miss.expired" );
            $cacheTime = $value->getCacheTime();
            wfDebugLog( "ParserCache",
                "ParserOutput key expired, touched $touched, "
                . "epoch {$this->cacheEpoch}, cached $cacheTime" );
            $value = false;
        } elseif (
            !$useOutdated
            && $value->isDifferentRevision( $wikiPage->getLatest() )
        ) {
            $this->incrementStats( $wikiPage, "miss.revid" );
            $revId = $wikiPage->getLatest();
            $cachedRevId = $value->getCacheRevisionId();
            wfDebugLog( "ParserCache",
                "ParserOutput key is for an old revision, latest $revId, cached $cachedRevId"
            );
            $value = false;
        } elseif (
            $this->hookRunner->onRejectParserCacheValue( $value, $wikiPage, $popts ) === false
        ) {
            $this->incrementStats( $wikiPage, 'miss.rejected' );
            wfDebugLog( "ParserCache",
                "ParserOutput key valid, but rejected by RejectParserCacheValue hook handler."
            );
            $value = false;
        } else {
            $this->incrementStats( $wikiPage, "hit" );
        }
 
        return $value;
    }
 
    public function save(
        ParserOutput $parserOutput,
        WikiPage $wikiPage,
        $popts,
        $cacheTime = null,
        $revId = null
    ) {
        if ( !$parserOutput->hasText() ) {
            throw new InvalidArgumentException( 'Attempt to cache a ParserOutput with no text set!' );
        }
 
        $expire = $parserOutput->getCacheExpiry();
        if ( $expire > 0 && !$this->cache instanceof EmptyBagOStuff ) {
            $cacheTime = $cacheTime ?: wfTimestampNow();
            if ( !$revId ) {
                $revision = $wikiPage->getRevisionRecord();
                $revId = $revision ? $revision->getId() : null;
            }
 
            $optionsKey = new CacheTime;
            $optionsKey->mUsedOptions = $parserOutput->getUsedOptions();
            $optionsKey->updateCacheExpiry( $expire );
 
            $optionsKey->setCacheTime( $cacheTime );
            $parserOutput->setCacheTime( $cacheTime );
            $optionsKey->setCacheRevisionId( $revId );
            $parserOutput->setCacheRevisionId( $revId );
 
            $parserOutputKey = $this->getParserOutputKey( $wikiPage,
                $popts->optionsHash( $optionsKey->mUsedOptions, $wikiPage->getTitle() ) );
 
            // Save the timestamp so that we don't have to load the revision row on view
            $parserOutput->setTimestamp( $wikiPage->getTimestamp() );
 
            $msg = "Saved in parser cache with key $parserOutputKey" .
                " and timestamp $cacheTime" .
                " and revision id $revId";
 
            $parserOutput->mText .= "\n<!-- $msg\n -->\n";
            wfDebug( $msg );
 
            // Save the parser output
            $this->cache->set(
                $parserOutputKey,
                $parserOutput,
                $expire,
                BagOStuff::WRITE_ALLOW_SEGMENTS
            );
 
            // ...and its pointer
            $this->cache->set( $this->getOptionsKey( $wikiPage ), $optionsKey, $expire );
 
            $this->hookRunner->onParserCacheSaveComplete(
                $this, $parserOutput, $wikiPage->getTitle(), $popts, $revId );
        } elseif ( $expire <= 0 ) {
            wfDebug( "Parser output was marked as uncacheable and has not been saved." );
        }
    }
 
    public function getCacheStorage() {
        return $this->cache;
    }
}