RevisionOutputCache.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use CacheTime;
use IBufferingStatsdDataFactory;
use InvalidArgumentException;
use MediaWiki\Json\JsonCodec;
use MediaWiki\Revision\RevisionRecord;
use MWTimestamp;
use ParserOptions;
use ParserOutput;
use Psr\Log\LoggerInterface;
use WANObjectCache;
 
class RevisionOutputCache {
 
    private $name;
 
    private $cache;
 
    private $cacheEpoch;
 
    private $cacheExpiry;
 
    private $jsonCodec;
 
    private $stats;
 
    private $logger;
 
    public function __construct(
        string $name,
        WANObjectCache $cache,
        int $cacheExpiry,
        string $cacheEpoch,
        JsonCodec $jsonCodec,
        IBufferingStatsdDataFactory $stats,
        LoggerInterface $logger
    ) {
        $this->name = $name;
        $this->cache = $cache;
        $this->cacheExpiry = $cacheExpiry;
        $this->cacheEpoch = $cacheEpoch;
        $this->jsonCodec = $jsonCodec;
        $this->stats = $stats;
        $this->logger = $logger;
    }
 
    private function incrementStats( RevisionRecord $revision, string $metricSuffix ) {
        $metricSuffix = str_replace( '.', '_', $metricSuffix );
        $this->stats->increment( "RevisionOutputCache.{$this->name}.{$metricSuffix}" );
    }
 
    public function makeParserOutputKey(
        RevisionRecord $revision,
        ParserOptions $options,
        array $usedOptions = null
    ): string {
        $usedOptions = ParserOptions::allCacheVaryingOptions();
 
        $revId = $revision->getId();
        if ( !$revId ) {
            // If RevId is null, this would probably be unsafe to use as a cache key.
            throw new InvalidArgumentException( "Revision must have an id number" );
        }
        $hash = $options->optionsHash( $usedOptions );
        return $this->cache->makeKey( $this->name, $revId, $hash );
    }
 
    public function makeParserOutputKeyOptionalRevId(
        RevisionRecord $revision,
        ParserOptions $options,
        array $usedOptions = null
    ): string {
        $usedOptions = ParserOptions::allCacheVaryingOptions();
 
        // revId may be null.
        $revId = (string)$revision->getId();
        $hash = $options->optionsHash( $usedOptions );
        return $this->cache->makeKey( $this->name, $revId, $hash );
    }
 
    public function get( RevisionRecord $revision, ParserOptions $parserOptions ) {
        if ( $this->cacheExpiry <= 0 ) {
            // disabled
            return false;
        }
 
        if ( !$parserOptions->isSafeToCache() ) {
            $this->incrementStats( $revision, 'miss.unsafe' );
            return false;
        }
 
        $cacheKey = $this->makeParserOutputKey( $revision, $parserOptions );
        $json = $this->cache->get( $cacheKey );
 
        if ( $json === false ) {
            $this->incrementStats( $revision, 'miss.absent' );
            return false;
        }
 
        $output = $this->restoreFromJson( $json, $cacheKey, ParserOutput::class );
        if ( $output === null ) {
            $this->incrementStats( $revision, 'miss.unserialize' );
            return false;
        }
 
        $cacheTime = (int)MWTimestamp::convert( TS_UNIX, $output->getCacheTime() );
        $expiryTime = (int)MWTimestamp::convert( TS_UNIX, $this->cacheEpoch );
        $expiryTime = max( $expiryTime, (int)MWTimestamp::now( TS_UNIX ) - $this->cacheExpiry );
 
        if ( $cacheTime < $expiryTime ) {
            $this->incrementStats( $revision, 'miss.expired' );
            return false;
        }
 
        $this->logger->debug( 'old-revision cache hit' );
        $this->incrementStats( $revision, 'hit' );
        return $output;
    }
 
    public function save(
        ParserOutput $output,
        RevisionRecord $revision,
        ParserOptions $parserOptions,
        string $cacheTime = null
    ) {
        if ( !$output->hasText() ) {
            throw new InvalidArgumentException( 'Attempt to cache a ParserOutput with no text set!' );
        }
 
        if ( $this->cacheExpiry <= 0 ) {
            // disabled
            return;
        }
 
        $cacheKey = $this->makeParserOutputKey( $revision, $parserOptions );
 
        $output->setCacheTime( $cacheTime ?: wfTimestampNow() );
        $output->setCacheRevisionId( $revision->getId() );
 
        // Save the timestamp so that we don't have to load the revision row on view
        $output->setTimestamp( $revision->getTimestamp() );
 
        $msg = "Saved in RevisionOutputCache with key $cacheKey" .
            " and timestamp $cacheTime" .
            " and revision id {$revision->getId()}.";
 
        $output->addCacheMessage( $msg );
 
        // The ParserOutput might be dynamic and have been marked uncacheable by the parser.
        $output->updateCacheExpiry( $this->cacheExpiry );
 
        $expiry = $output->getCacheExpiry();
        if ( $expiry <= 0 ) {
            $this->incrementStats( $revision, 'save.uncacheable' );
            return;
        }
 
        if ( !$parserOptions->isSafeToCache() ) {
            $this->incrementStats( $revision, 'save.unsafe' );
            return;
        }
 
        $json = $this->encodeAsJson( $output, $cacheKey );
        if ( $json === null ) {
            $this->incrementStats( $revision, 'save.nonserializable' );
            return;
        }
 
        $this->cache->set( $cacheKey, $json, $expiry );
        $this->incrementStats( $revision, 'save.success' );
    }
 
    private function restoreFromJson( string $jsonData, string $key, string $expectedClass ) {
        try {
            $obj = $this->jsonCodec->unserialize( $jsonData, $expectedClass );
            return $obj;
        } catch ( InvalidArgumentException $e ) {
            $this->logger->error( 'Unable to unserialize JSON', [
                'name' => $this->name,
                'cache_key' => $key,
                'message' => $e->getMessage()
            ] );
            return null;
        }
    }
 
    private function encodeAsJson( CacheTime $obj, string $key ) {
        try {
            return $this->jsonCodec->serialize( $obj );
        } catch ( InvalidArgumentException $e ) {
            $this->logger->error( 'Unable to serialize JSON', [
                'name' => $this->name,
                'cache_key' => $key,
                'message' => $e->getMessage(),
            ] );
            return null;
        }
    }
}