ParserCache.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
class ParserCache {
    const USE_CURRENT_ONLY = 0;
 
    const USE_EXPIRED = 1;
 
    const USE_OUTDATED = 2;
 
    const USE_ANYTHING = 3;
 
    private $mMemc;
 
    private $cacheEpoch;
    public static function singleton() {
        return MediaWikiServices::getInstance()->getParserCache();
    }
 
    public function __construct( BagOStuff $cache, $cacheEpoch = '20030516000000' ) {
        $this->mMemc = $cache;
        $this->cacheEpoch = $cacheEpoch;
    }
 
    protected function getParserOutputKey( $article, $hash ) {
        global $wgRequest;
 
        // idhash seem to mean 'page id' + 'rendering hash' (r3710)
        $pageid = $article->getId();
        $renderkey = (int)( $wgRequest->getVal( 'action' ) == 'render' );
 
        $key = $this->mMemc->makeKey( 'pcache', 'idhash', "{$pageid}-{$renderkey}!{$hash}" );
        return $key;
    }
 
    protected function getOptionsKey( $page ) {
        return $this->mMemc->makeKey( 'pcache', 'idoptions', $page->getId() );
    }
 
    public function deleteOptionsKey( $page ) {
        $this->mMemc->delete( $this->getOptionsKey( $page ) );
    }
 
    public function getETag( $article, $popts ) {
        return 'W/"' . $this->getParserOutputKey( $article,
            $popts->optionsHash( ParserOptions::allCacheVaryingOptions(), $article->getTitle() ) ) .
                "--" . $article->getTouched() . '"';
    }
 
    public function getDirty( $article, $popts ) {
        $value = $this->get( $article, $popts, true );
        return is_object( $value ) ? $value : false;
    }
 
    public function getKey( $article, $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( &\$article, &\$user )\n" );
            $popts = ParserOptions::newFromUser( $popts );
        }
 
        // Determine the options which affect this article
        $casToken = null;
        $optionsKey = $this->mMemc->get(
            $this->getOptionsKey( $article ), $casToken, BagOStuff::READ_VERIFIED );
        if ( $optionsKey instanceof CacheTime ) {
            if ( $useOutdated < self::USE_EXPIRED && $optionsKey->expired( $article->getTouched() ) ) {
                wfIncrStats( "pcache.miss.expired" );
                $cacheTime = $optionsKey->getCacheTime();
                wfDebugLog( "ParserCache",
                    "Parser options key expired, touched " . $article->getTouched()
                    . ", epoch {$this->cacheEpoch}, cached $cacheTime\n" );
                return false;
            } elseif ( $useOutdated < self::USE_OUTDATED &&
                $optionsKey->isDifferentRevision( $article->getLatest() )
            ) {
                wfIncrStats( "pcache.miss.revid" );
                $revId = $article->getLatest();
                $cachedRevId = $optionsKey->getCacheRevisionId();
                wfDebugLog( "ParserCache",
                    "ParserOutput key is for an old revision, latest $revId, cached $cachedRevId\n"
                );
                return false;
            }
 
            // $optionsKey->mUsedOptions is set by save() by calling ParserOutput::getUsedOptions()
            $usedOptions = $optionsKey->mUsedOptions;
            wfDebug( "Parser cache options found.\n" );
        } else {
            if ( $useOutdated < self::USE_ANYTHING ) {
                return false;
            }
            $usedOptions = ParserOptions::allCacheVaryingOptions();
        }
 
        return $this->getParserOutputKey(
            $article,
            $popts->optionsHash( $usedOptions, $article->getTitle() )
        );
    }
 
    public function get( $article, $popts, $useOutdated = false ) {
        $canCache = $article->checkTouched();
        if ( !$canCache ) {
            // It's a redirect now
            return false;
        }
 
        $touched = $article->getTouched();
 
        $parserOutputKey = $this->getKey( $article, $popts,
            $useOutdated ? self::USE_OUTDATED : self::USE_CURRENT_ONLY
        );
        if ( $parserOutputKey === false ) {
            wfIncrStats( 'pcache.miss.absent' );
            return false;
        }
 
        $casToken = null;
        $value = $this->mMemc->get( $parserOutputKey, $casToken, BagOStuff::READ_VERIFIED );
        if ( !$value ) {
            wfDebug( "ParserOutput cache miss.\n" );
            wfIncrStats( "pcache.miss.absent" );
            return false;
        }
 
        wfDebug( "ParserOutput cache found.\n" );
 
        $wikiPage = method_exists( $article, 'getPage' )
            ? $article->getPage()
            : $article;
 
        if ( !$useOutdated && $value->expired( $touched ) ) {
            wfIncrStats( "pcache.miss.expired" );
            $cacheTime = $value->getCacheTime();
            wfDebugLog( "ParserCache",
                "ParserOutput key expired, touched $touched, "
                . "epoch {$this->cacheEpoch}, cached $cacheTime\n" );
            $value = false;
        } elseif ( !$useOutdated && $value->isDifferentRevision( $article->getLatest() ) ) {
            wfIncrStats( "pcache.miss.revid" );
            $revId = $article->getLatest();
            $cachedRevId = $value->getCacheRevisionId();
            wfDebugLog( "ParserCache",
                "ParserOutput key is for an old revision, latest $revId, cached $cachedRevId\n"
            );
            $value = false;
        } elseif (
            Hooks::run( 'RejectParserCacheValue', [ $value, $wikiPage, $popts ] ) === false
        ) {
            wfIncrStats( 'pcache.miss.rejected' );
            wfDebugLog( "ParserCache",
                "ParserOutput key valid, but rejected by RejectParserCacheValue hook handler.\n"
            );
            $value = false;
        } else {
            wfIncrStats( "pcache.hit" );
        }
 
        return $value;
    }
 
    public function save( $parserOutput, $page, $popts, $cacheTime = null, $revId = null ) {
        $expire = $parserOutput->getCacheExpiry();
        if ( $expire > 0 && !$this->mMemc instanceof EmptyBagOStuff ) {
            $cacheTime = $cacheTime ?: wfTimestampNow();
            if ( !$revId ) {
                $revision = $page->getRevision();
                $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( $page,
                $popts->optionsHash( $optionsKey->mUsedOptions, $page->getTitle() ) );
 
            // Save the timestamp so that we don't have to load the revision row on view
            $parserOutput->setTimestamp( $page->getTimestamp() );
 
            $msg = "Saved in parser cache with key $parserOutputKey" .
                " and timestamp $cacheTime" .
                " and revision id $revId" .
                "\n";
 
            $parserOutput->mText .= "\n<!-- $msg -->\n";
            wfDebug( $msg );
 
            // Save the parser output
            $this->mMemc->set( $parserOutputKey, $parserOutput, $expire );
 
            // ...and its pointer
            $this->mMemc->set( $this->getOptionsKey( $page ), $optionsKey, $expire );
 
            Hooks::run(
                'ParserCacheSaveComplete',
                [ $this, $parserOutput, $page->getTitle(), $popts, $revId ]
            );
        } elseif ( $expire <= 0 ) {
            wfDebug( "Parser output was marked as uncacheable and has not been saved.\n" );
        }
    }
 
    public function getCacheStorage() {
        return $this->mMemc;
    }
}