ParserCache.php

Go to the documentation of this file.

<?php
class ParserCache {
        private $mMemc;
        const try116cache = false; /* Only useful $wgParserCacheExpireTime after updating to 1.17 */

        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}" );
        }

        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;
                        }

                        $usedOptions = $optionsKey->mUsedOptions;
                        wfDebug( "Parser cache options found.\n" );
                } else {
                        if ( !$useOutdated && !self::try116cache ) {
                                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 ( self::try116cache && !$value && strpos( $value, '*' ) !== -1 ) {
                        wfDebug( "New format parser cache miss.\n" );
                        $parserOutputKey = $this->getParserOutputKey( $article,
                                $popts->optionsHash( ParserOptions::legacyOptions(), $article->getTitle() ) );
                        $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;
                } else {
                        wfIncrStats( "pcache_hit" );
                }

                wfProfileOut( __METHOD__ );
                return $value;
        }

        public function save( $parserOutput, $article, $popts ) {
                $expire = $parserOutput->getCacheExpiry();

                if( $expire > 0 ) {
                        $now = wfTimestampNow();

                        $optionsKey = new CacheTime;
                        $optionsKey->mUsedOptions = $parserOutput->getUsedOptions();
                        $optionsKey->updateCacheExpiry( $expire );

                        $optionsKey->setCacheTime( $now );
                        $parserOutput->setCacheTime( $now );

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

                        $parserOutputKey = $this->getParserOutputKey( $article,
                                $popts->optionsHash( $optionsKey->mUsedOptions, $article->getTitle() ) );

                        // Save the timestamp so that we don't have to load the revision row on view
                        $parserOutput->setTimestamp( $article->getTimestamp() );

                        $parserOutput->mText .= "\n<!-- Saved in parser cache with key $parserOutputKey and timestamp $now -->\n";
                        wfDebug( "Saved in parser cache with key $parserOutputKey and timestamp $now\n" );

                        // Save the parser output
                        $this->mMemc->set( $parserOutputKey, $parserOutput, $expire );

                        // ...and its pointer
                        $this->mMemc->set( $this->getOptionsKey( $article ), $optionsKey, $expire );
                } else {
                        wfDebug( "Parser output was marked as uncacheable and has not been saved.\n" );
                }
        }
}