MessageBlobStore.php

Go to the documentation of this file.

<?php
namespace MediaWiki\ResourceLoader;
 
use MediaWiki\Json\FormatJson;
use MediaWiki\MediaWikiServices;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Rdbms\Database;
 
class MessageBlobStore implements LoggerAwareInterface {
    private $resourceloader;
 
    protected $logger;
 
    protected $wanCache;
 
    public function __construct(
        ResourceLoader $rl,
        ?LoggerInterface $logger,
        ?WANObjectCache $wanObjectCache
    ) {
        $this->resourceloader = $rl;
        $this->logger = $logger ?: new NullLogger();
 
        // NOTE: when changing this assignment, make sure the code in the instantiator for
        // LocalisationCache which calls MessageBlobStore::clearGlobalCacheEntry() uses the
        // same cache object.
        $this->wanCache = $wanObjectCache ?: MediaWikiServices::getInstance()
            ->getMainWANObjectCache();
    }
 
    public function setLogger( LoggerInterface $logger ): void {
        $this->logger = $logger;
    }
 
    public function getBlob( Module $module, $lang ) {
        $blobs = $this->getBlobs( [ $module->getName() => $module ], $lang );
        return $blobs[$module->getName()];
    }
 
    public function getBlobs( array $modules, $lang ) {
        // Each cache key for a message blob by module name and language code also has a generic
        // check key without language code. This is used to invalidate any and all language subkeys
        // that exist for a module from the updateMessage() method.
        $checkKeys = [
            self::makeGlobalPurgeKey( $this->wanCache )
        ];
        $cacheKeys = [];
        foreach ( $modules as $name => $module ) {
            $cacheKey = $this->makeBlobCacheKey( $name, $lang, $module );
            $cacheKeys[$name] = $cacheKey;
            $checkKeys[$cacheKey][] = $this->makeModulePurgeKey( $name );
        }
        $curTTLs = [];
        $result = $this->wanCache->getMulti( array_values( $cacheKeys ), $curTTLs, $checkKeys );
 
        $blobs = [];
        foreach ( $modules as $name => $module ) {
            $key = $cacheKeys[$name];
            if ( !isset( $result[$key] ) || $curTTLs[$key] === null || $curTTLs[$key] < 0 ) {
                $blobs[$name] = $this->recacheMessageBlob( $key, $module, $lang );
            } else {
                // Use unexpired cache
                $blobs[$name] = $result[$key];
            }
        }
        return $blobs;
    }
 
    private static function makeGlobalPurgeKey( WANObjectCache $cache ) {
        return $cache->makeGlobalKey( 'resourceloader-messageblob' );
    }
 
    private function makeModulePurgeKey( $name ) {
        return $this->wanCache->makeKey( 'resourceloader-messageblob', $name );
    }
 
    private function makeBlobCacheKey( $name, $lang, Module $module ) {
        $messages = array_values( array_unique( $module->getMessages() ) );
        sort( $messages );
        return $this->wanCache->makeKey( 'resourceloader-messageblob',
            $name,
            $lang,
            md5( json_encode( $messages ) )
        );
    }
 
    protected function recacheMessageBlob( $cacheKey, Module $module, $lang ) {
        $blob = $this->generateMessageBlob( $module, $lang );
        $cache = $this->wanCache;
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
        $cache->set( $cacheKey, $blob,
            // Add part of a day to TTL to avoid all modules expiring at once
            $cache::TTL_WEEK + mt_rand( 0, $cache::TTL_DAY ),
            Database::getCacheSetOptions( $dbr )
        );
        return $blob;
    }
 
    public function updateMessage( $key ): void {
        $moduleNames = $this->resourceloader->getModulesByMessage( $key );
        foreach ( $moduleNames as $moduleName ) {
            // Use the default holdoff TTL to account for database replica DB lag
            // which can affect MessageCache.
            $this->wanCache->touchCheckKey( $this->makeModulePurgeKey( $moduleName ) );
        }
    }
 
    public static function clearGlobalCacheEntry( WANObjectCache $cache ) {
        // Disable holdoff TTL because:
        // - LocalisationCache is populated by messages on-disk and don't have DB lag,
        //   thus there is no need for hold off. We only clear it after new localisation
        //   updates are known to be deployed to all servers.
        // - This global check key invalidates message blobs for all modules for all wikis
        //   in cache contexts (e.g. languages, skins). Setting a hold-off on this key could
        //   cause a cache stampede since no values would be stored for several seconds.
        $cache->touchCheckKey( self::makeGlobalPurgeKey( $cache ), $cache::HOLDOFF_TTL_NONE );
    }
 
    protected function fetchMessage( $key, $lang ) {
        $message = wfMessage( $key )->inLanguage( $lang );
        if ( !$message->exists() ) {
            $this->logger->warning( 'Failed to find {messageKey} ({lang})', [
                'messageKey' => $key,
                'lang' => $lang,
            ] );
            $value = null;
        } else {
            $value = $message->plain();
        }
        return $value;
    }
 
    private function generateMessageBlob( Module $module, $lang ) {
        $messages = [];
        foreach ( $module->getMessages() as $key ) {
            $value = $this->fetchMessage( $key, $lang );
            // If the message does not exist, omit it from the blob so that
            // client-side mw.message may do its own existence handling.
            if ( $value !== null ) {
                $messages[$key] = $value;
            }
        }
 
        $json = FormatJson::encode( (object)$messages, false, FormatJson::UTF8_OK );
        // @codeCoverageIgnoreStart
        if ( $json === false ) {
            $this->logger->warning( 'Failed to encode message blob for {module} ({lang})', [
                'module' => $module->getName(),
                'lang' => $lang,
            ] );
            $json = '{}';
        }
        // codeCoverageIgnoreEnd
        return $json;
    }
}