MessageBlobStore.php

Go to the documentation of this file.

<?php
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

class MessageBlobStore implements LoggerAwareInterface {

    /* @var ResourceLoader|null */
    private $resourceloader;

    protected $logger;

    protected $wanCache;

    public function __construct( ResourceLoader $rl = null, LoggerInterface $logger = null ) {
        $this->resourceloader = $rl;
        $this->logger = $logger ?: new NullLogger();
        $this->wanCache = ObjectCache::getMainWANInstance();
    }

    public function setLogger( LoggerInterface $logger ) {
        $this->logger = $logger;
    }

    public function getBlob( ResourceLoaderModule $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.
        $cache = $this->wanCache;
        $checkKeys = [
            // Global check key, see clear()
            $cache->makeKey( __CLASS__ )
        ];
        $cacheKeys = [];
        foreach ( $modules as $name => $module ) {
            $cacheKey = $this->makeCacheKey( $module, $lang );
            $cacheKeys[$name] = $cacheKey;
            // Per-module check key, see updateMessage()
            $checkKeys[$cacheKey][] = $cache->makeKey( __CLASS__, $name );
        }
        $curTTLs = [];
        $result = $cache->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 ) {
                $this->logger->info( 'Message blob cache-miss for {module}',
                    [ 'module' => $name, 'cacheKey' => $key ]
                );
                $blobs[$name] = $this->recacheMessageBlob( $key, $module, $lang );
            } else {
                // Use unexpired cache
                $blobs[$name] = $result[$key];
            }
        }
        return $blobs;
    }

    public function get( ResourceLoader $resourceLoader, $modules, $lang ) {
        return $this->getBlobs( $modules, $lang );
    }

    public function insertMessageBlob( $name, ResourceLoaderModule $module, $lang ) {
        return false;
    }

    private function makeCacheKey( ResourceLoaderModule $module, $lang ) {
        $messages = array_values( array_unique( $module->getMessages() ) );
        sort( $messages );
        return $this->wanCache->makeKey( __CLASS__, $module->getName(), $lang,
            md5( json_encode( $messages ) )
        );
    }

    protected function recacheMessageBlob( $cacheKey, ResourceLoaderModule $module, $lang ) {
        $blob = $this->generateMessageBlob( $module, $lang );
        $cache = $this->wanCache;
        $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( wfGetDB( DB_REPLICA ) )
        );
        return $blob;
    }

    public function updateMessage( $key ) {
        $moduleNames = $this->getResourceLoader()->getModulesByMessage( $key );
        foreach ( $moduleNames as $moduleName ) {
            // Uses a holdoff to account for database replica DB lag (for MessageCache)
            $this->wanCache->touchCheckKey( $this->wanCache->makeKey( __CLASS__, $moduleName ) );
        }
    }

    public function clear() {
        $cache = $this->wanCache;
        // Disable holdoff because this invalidates all modules and also not needed since
        // LocalisationCache is stored outside the database and doesn't have lag.
        $cache->touchCheckKey( $cache->makeKey( __CLASS__ ), $cache::HOLDOFF_NONE );
    }

    protected function getResourceLoader() {
        // Back-compat: This class supports instantiation without a ResourceLoader object.
        // Lazy-initialise this property because most callers don't need it.
        if ( $this->resourceloader === null ) {
            $this->logger->warning( __CLASS__ . ' created without a ResourceLoader instance' );
            $this->resourceloader = new ResourceLoader();
        }
        return $this->resourceloader;
    }

    protected function fetchMessage( $key, $lang ) {
        $message = wfMessage( $key )->inLanguage( $lang );
        $value = $message->plain();
        if ( !$message->exists() ) {
            $this->logger->warning( 'Failed to find {messageKey} ({lang})', [
                'messageKey' => $key,
                'lang' => $lang,
            ] );
        }
        return $value;
    }

    private function generateMessageBlob( ResourceLoaderModule $module, $lang ) {
        $messages = [];
        foreach ( $module->getMessages() as $key ) {
            $messages[$key] = $this->fetchMessage( $key, $lang );
        }

        $json = FormatJson::encode( (object)$messages );
        if ( $json === false ) {
            $this->logger->warning( 'Failed to encode message blob for {module} ({lang})', [
                'module' => $module->getName(),
                'lang' => $lang,
            ] );
            $json = '{}';
        }
        return $json;
    }
}