ParserCache.php

Go to the documentation of this file.

<?php
class ParserCache {
    private $mMemc;
    public static function singleton() {
        static $instance;
        if ( !isset( $instance ) ) {
            global $parserMemc;
            $instance = new ParserCache( $parserMemc );
        }
        return $instance;
    }

    protected function __construct( $memCached ) {
        if ( !$memCached ) {
            throw new MWException( "Tried to create a ParserCache with an invalid memcached" );
        }
        $this->mMemc = $memCached;
    }

    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 = wfMemcKey( 'pcache', 'idhash', "{$pageid}-{$renderkey}!{$hash}" );
        return $key;
    }

    protected function getOptionsKey( $article ) {
        $pageid = $article->getID();
        return wfMemcKey( 'pcache', 'idoptions', "{$pageid}" );
    }

    public function getETag( $article, $popts ) {
        return 'W/"' . $this->getParserOutputKey( $article,
            $popts->optionsHash( ParserOptions::legacyOptions(), $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 = true ) {
        global $wgCacheEpoch;

        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
        $optionsKey = $this->mMemc->get( $this->getOptionsKey( $article ) );
        if ( $optionsKey != false ) {
            if ( !$useOutdated && $optionsKey->expired( $article->getTouched() ) ) {
                wfIncrStats( "pcache_miss_expired" );
                $cacheTime = $optionsKey->getCacheTime();
                wfDebug( "Parser options key expired, touched " . $article->getTouched()
                    . ", epoch $wgCacheEpoch, cached $cacheTime\n" );
                return false;
            } elseif ( $optionsKey->isDifferentRevision( $article->getLatest() ) ) {
                wfIncrStats( "pcache_miss_revid" );
                $revId = $article->getLatest();
                $cachedRevId = $optionsKey->getCacheRevisionId();
                wfDebug( "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 ) {
                return false;
            }
            $usedOptions = ParserOptions::legacyOptions();
        }

        return $this->getParserOutputKey(
            $article,
            $popts->optionsHash( $usedOptions, $article->getTitle() )
        );
    }

    public function get( $article, $popts, $useOutdated = false ) {
        global $wgCacheEpoch;
        wfProfileIn( __METHOD__ );

        $canCache = $article->checkTouched();
        if ( !$canCache ) {
            // It's a redirect now
            wfProfileOut( __METHOD__ );
            return false;
        }

        $touched = $article->getTouched();

        $parserOutputKey = $this->getKey( $article, $popts, $useOutdated );
        if ( $parserOutputKey === false ) {
            wfIncrStats( 'pcache_miss_absent' );
            wfProfileOut( __METHOD__ );
            return false;
        }

        $value = $this->mMemc->get( $parserOutputKey );
        if ( !$value ) {
            wfDebug( "ParserOutput cache miss.\n" );
            wfIncrStats( "pcache_miss_absent" );
            wfProfileOut( __METHOD__ );
            return false;
        }

        wfDebug( "ParserOutput cache found.\n" );

        // The edit section preference may not be the appropiate one in
        // the ParserOutput, as we are not storing it in the parsercache
        // key. Force it here. See bug 31445.
        $value->setEditSectionTokens( $popts->getEditSection() );

        if ( !$useOutdated && $value->expired( $touched ) ) {
            wfIncrStats( "pcache_miss_expired" );
            $cacheTime = $value->getCacheTime();
            wfDebug( "ParserOutput key expired, touched $touched, "
                . "epoch $wgCacheEpoch, cached $cacheTime\n" );
            $value = false;
        } elseif ( $value->isDifferentRevision( $article->getLatest() ) ) {
            wfIncrStats( "pcache_miss_revid" );
            $revId = $article->getLatest();
            $cachedRevId = $value->getCacheRevisionId();
            wfDebug( "ParserOutput key is for an old revision, latest $revId, cached $cachedRevId\n" );
            $value = false;
        } else {
            wfIncrStats( "pcache_hit" );
        }

        wfProfileOut( __METHOD__ );
        return $value;
    }

    public function save( $parserOutput, $page, $popts, $cacheTime = null, $revId = null ) {
        $expire = $parserOutput->getCacheExpiry();
        if ( $expire > 0 ) {
            $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 );

            $optionsKey->setContainsOldMagic( $parserOutput->containsOldMagic() );

            $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 );
        } else {
            wfDebug( "Parser output was marked as uncacheable and has not been saved.\n" );
        }
    }
}