ParserCacheFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\Json\JsonCodec;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Title\TitleFactory;
use ParserCache;
use Psr\Log\LoggerInterface;
use Wikimedia\ObjectCache\BagOStuff;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Stats\StatsFactory;
use Wikimedia\UUID\GlobalIdGenerator;
 
class ParserCacheFactory {
 
    public const DEFAULT_NAME = 'pcache';
 
    public const DEFAULT_RCACHE_NAME = 'rcache';
 
    private $parserCacheBackend;
 
    private $revisionOutputCacheBackend;
 
    private $hookContainer;
 
    private $jsonCodec;
 
    private $stats;
 
    private $logger;
 
    private $titleFactory;
 
    private $wikiPageFactory;
 
    private GlobalIdGenerator $globalIdGenerator;
 
    private $parserCaches = [];
 
    private $revisionOutputCaches = [];
 
    private $options;
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::CacheEpoch,
        MainConfigNames::ParserCacheFilterConfig,
        MainConfigNames::OldRevisionParserCacheExpireTime,
    ];
 
    public function __construct(
        BagOStuff $parserCacheBackend,
        WANObjectCache $revisionOutputCacheBackend,
        HookContainer $hookContainer,
        JsonCodec $jsonCodec,
        StatsFactory $stats,
        LoggerInterface $logger,
        ServiceOptions $options,
        TitleFactory $titleFactory,
        WikiPageFactory $wikiPageFactory,
        GlobalIdGenerator $globalIdGenerator
    ) {
        $this->parserCacheBackend = $parserCacheBackend;
        $this->revisionOutputCacheBackend = $revisionOutputCacheBackend;
        $this->hookContainer = $hookContainer;
        $this->jsonCodec = $jsonCodec;
        $this->stats = $stats;
        $this->logger = $logger;
 
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
        $this->titleFactory = $titleFactory;
        $this->wikiPageFactory = $wikiPageFactory;
        $this->globalIdGenerator = $globalIdGenerator;
    }
 
    public function getParserCache( string $name ): ParserCache {
        if ( !isset( $this->parserCaches[$name] ) ) {
            $this->logger->debug( "Creating ParserCache instance for {$name}" );
            $cache = new ParserCache(
                $name,
                $this->parserCacheBackend,
                $this->options->get( MainConfigNames::CacheEpoch ),
                $this->hookContainer,
                $this->jsonCodec,
                $this->stats,
                $this->logger,
                $this->titleFactory,
                $this->wikiPageFactory,
                $this->globalIdGenerator
            );
 
            $filterConfig = $this->options->get( MainConfigNames::ParserCacheFilterConfig );
 
            if ( isset( $filterConfig[$name] ) ) {
                $filter = new ParserCacheFilter( $filterConfig[$name] );
                $cache->setFilter( $filter );
            }
 
            $this->parserCaches[$name] = $cache;
        }
        return $this->parserCaches[$name];
    }
 
    public function getRevisionOutputCache( string $name ): RevisionOutputCache {
        if ( !isset( $this->revisionOutputCaches[$name] ) ) {
            $this->logger->debug( "Creating RevisionOutputCache instance for {$name}" );
            $cache = new RevisionOutputCache(
                $name,
                $this->revisionOutputCacheBackend,
                $this->options->get( MainConfigNames::OldRevisionParserCacheExpireTime ),
                $this->options->get( MainConfigNames::CacheEpoch ),
                $this->jsonCodec,
                $this->stats,
                $this->logger,
                $this->globalIdGenerator
            );
 
            $this->revisionOutputCaches[$name] = $cache;
        }
        return $this->revisionOutputCaches[$name];
    }
}