X-Git-Url: https://scripts.mit.edu/gitweb/autoinstallsdev/mediawiki.git/blobdiff_plain/19e297c21b10b1b8a3acad5e73fc71dcb35db44a..6932310fd58ebef145fa01eb76edf7150284d8ea:/includes/cache/MessageCache.php diff --git a/includes/cache/MessageCache.php b/includes/cache/MessageCache.php new file mode 100644 index 00000000..768f980b --- /dev/null +++ b/includes/cache/MessageCache.php @@ -0,0 +1,1331 @@ + boolean) + */ + protected $mCacheVolatile = []; + + /** + * Should mean that database cannot be used, but check + * @var bool $mDisable + */ + protected $mDisable; + + /** + * Lifetime for cache, used by object caching. + * Set on construction, see __construct(). + */ + protected $mExpiry; + + /** + * Message cache has its own parser which it uses to transform messages + * @var ParserOptions + */ + protected $mParserOptions; + /** @var Parser */ + protected $mParser; + + /** + * Variable for tracking which variables are already loaded + * @var array $mLoadedLanguages + */ + protected $mLoadedLanguages = []; + + /** + * @var bool $mInParser + */ + protected $mInParser = false; + + /** @var WANObjectCache */ + protected $wanCache; + /** @var BagOStuff */ + protected $clusterCache; + /** @var BagOStuff */ + protected $srvCache; + + /** + * Singleton instance + * + * @var MessageCache $instance + */ + private static $instance; + + /** + * Get the signleton instance of this class + * + * @since 1.18 + * @return MessageCache + */ + public static function singleton() { + if ( self::$instance === null ) { + global $wgUseDatabaseMessages, $wgMsgCacheExpiry, $wgUseLocalMessageCache; + self::$instance = new self( + MediaWikiServices::getInstance()->getMainWANObjectCache(), + wfGetMessageCacheStorage(), + $wgUseLocalMessageCache + ? MediaWikiServices::getInstance()->getLocalServerObjectCache() + : new EmptyBagOStuff(), + $wgUseDatabaseMessages, + $wgMsgCacheExpiry + ); + } + + return self::$instance; + } + + /** + * Destroy the singleton instance + * + * @since 1.18 + */ + public static function destroyInstance() { + self::$instance = null; + } + + /** + * Normalize message key input + * + * @param string $key Input message key to be normalized + * @return string Normalized message key + */ + public static function normalizeKey( $key ) { + global $wgContLang; + + $lckey = strtr( $key, ' ', '_' ); + if ( ord( $lckey ) < 128 ) { + $lckey[0] = strtolower( $lckey[0] ); + } else { + $lckey = $wgContLang->lcfirst( $lckey ); + } + + return $lckey; + } + + /** + * @param WANObjectCache $wanCache WAN cache instance + * @param BagOStuff $clusterCache Cluster cache instance + * @param BagOStuff $srvCache Server cache instance + * @param bool $useDB Whether to look for message overrides (e.g. MediaWiki: pages) + * @param int $expiry Lifetime for cache. @see $mExpiry. + */ + public function __construct( + WANObjectCache $wanCache, + BagOStuff $clusterCache, + BagOStuff $srvCache, + $useDB, + $expiry + ) { + $this->wanCache = $wanCache; + $this->clusterCache = $clusterCache; + $this->srvCache = $srvCache; + + $this->mDisable = !$useDB; + $this->mExpiry = $expiry; + } + + /** + * ParserOptions is lazy initialised. + * + * @return ParserOptions + */ + function getParserOptions() { + global $wgUser; + + if ( !$this->mParserOptions ) { + if ( !$wgUser->isSafeToLoad() ) { + // $wgUser isn't unstubbable yet, so don't try to get a + // ParserOptions for it. And don't cache this ParserOptions + // either. + $po = ParserOptions::newFromAnon(); + $po->setEditSection( false ); + $po->setAllowUnsafeRawHtml( false ); + $po->setWrapOutputClass( false ); + return $po; + } + + $this->mParserOptions = new ParserOptions; + $this->mParserOptions->setEditSection( false ); + // Messages may take parameters that could come + // from malicious sources. As a precaution, disable + // the parser tag when parsing messages. + $this->mParserOptions->setAllowUnsafeRawHtml( false ); + // Wrapping messages in an extra
suffix
+ return;
+ }
+
+ // (a) Update the process cache with the new message text
+ if ( $text === false ) {
+ // Page deleted
+ $this->mCache[$code][$title] = '!NONEXISTENT';
+ } else {
+ // Ignore $wgMaxMsgCacheEntrySize so the process cache is up to date
+ $this->mCache[$code][$title] = ' ' . $text;
+ }
+
+ // (b) Update the shared caches in a deferred update with a fresh DB snapshot
+ DeferredUpdates::addCallableUpdate(
+ function () use ( $title, $msg, $code ) {
+ global $wgContLang, $wgMaxMsgCacheEntrySize;
+ // Allow one caller at a time to avoid race conditions
+ $scopedLock = $this->getReentrantScopedLock(
+ $this->clusterCache->makeKey( 'messages', $code )
+ );
+ if ( !$scopedLock ) {
+ LoggerFactory::getInstance( 'MessageCache' )->error(
+ __METHOD__ . ': could not acquire lock to update {title} ({code})',
+ [ 'title' => $title, 'code' => $code ] );
+ return;
+ }
+ // Load the messages from the master DB to avoid race conditions
+ $cache = $this->loadFromDB( $code, self::FOR_UPDATE );
+ $this->mCache[$code] = $cache;
+ // Load the process cache values and set the per-title cache keys
+ $page = WikiPage::factory( Title::makeTitle( NS_MEDIAWIKI, $title ) );
+ $page->loadPageData( $page::READ_LATEST );
+ $text = $this->getMessageTextFromContent( $page->getContent() );
+ // Check if an individual cache key should exist and update cache accordingly
+ if ( is_string( $text ) && strlen( $text ) > $wgMaxMsgCacheEntrySize ) {
+ $titleKey = $this->bigMessageCacheKey( $this->mCache[$code]['HASH'], $title );
+ $this->wanCache->set( $titleKey, ' ' . $text, $this->mExpiry );
+ }
+ // Mark this cache as definitely being "latest" (non-volatile) so
+ // load() calls do try to refresh the cache with replica DB data
+ $this->mCache[$code]['LATEST'] = time();
+ // Pre-emptively update the local datacenter cache so things like edit filter and
+ // blacklist changes are reflect immediately, as these often use MediaWiki: pages.
+ // The datacenter handling replace() calls should be the same one handling edits
+ // as they require HTTP POST.
+ $this->saveToCaches( $this->mCache[$code], 'all', $code );
+ // Release the lock now that the cache is saved
+ ScopedCallback::consume( $scopedLock );
+
+ // Relay the purge. Touching this check key expires cache contents
+ // and local cache (APC) validation hash across all datacenters.
+ $this->wanCache->touchCheckKey( $this->wanCache->makeKey( 'messages', $code ) );
+ // Also delete cached sidebar... just in case it is affected
+ // @TODO: shouldn't this be $code === $wgLanguageCode?
+ if ( $code === 'en' ) {
+ // Purge all language sidebars, e.g. on ?action=purge to the sidebar messages
+ $codes = array_keys( Language::fetchLanguageNames() );
+ } else {
+ // Purge only the sidebar for this language
+ $codes = [ $code ];
+ }
+ foreach ( $codes as $code ) {
+ $this->wanCache->delete( $this->wanCache->makeKey( 'sidebar', $code ) );
+ }
+
+ // Purge the message in the message blob store
+ $resourceloader = RequestContext::getMain()->getOutput()->getResourceLoader();
+ $blobStore = $resourceloader->getMessageBlobStore();
+ $blobStore->updateMessage( $wgContLang->lcfirst( $msg ) );
+
+ Hooks::run( 'MessageCacheReplace', [ $title, $text ] );
+ },
+ DeferredUpdates::PRESEND
+ );
+ }
+
+ /**
+ * Is the given cache array expired due to time passing or a version change?
+ *
+ * @param array $cache
+ * @return bool
+ */
+ protected function isCacheExpired( $cache ) {
+ if ( !isset( $cache['VERSION'] ) || !isset( $cache['EXPIRY'] ) ) {
+ return true;
+ }
+ if ( $cache['VERSION'] != MSG_CACHE_VERSION ) {
+ return true;
+ }
+ if ( wfTimestampNow() >= $cache['EXPIRY'] ) {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Shortcut to update caches.
+ *
+ * @param array $cache Cached messages with a version.
+ * @param string $dest Either "local-only" to save to local caches only
+ * or "all" to save to all caches.
+ * @param string|bool $code Language code (default: false)
+ * @return bool
+ */
+ protected function saveToCaches( array $cache, $dest, $code = false ) {
+ if ( $dest === 'all' ) {
+ $cacheKey = $this->clusterCache->makeKey( 'messages', $code );
+ $success = $this->clusterCache->set( $cacheKey, $cache );
+ $this->setValidationHash( $code, $cache );
+ } else {
+ $success = true;
+ }
+
+ $this->saveToLocalCache( $code, $cache );
+
+ return $success;
+ }
+
+ /**
+ * Get the md5 used to validate the local APC cache
+ *
+ * @param string $code
+ * @return array (hash or false, bool expiry/volatility status)
+ */
+ protected function getValidationHash( $code ) {
+ $curTTL = null;
+ $value = $this->wanCache->get(
+ $this->wanCache->makeKey( 'messages', $code, 'hash', 'v1' ),
+ $curTTL,
+ [ $this->wanCache->makeKey( 'messages', $code ) ]
+ );
+
+ if ( $value ) {
+ $hash = $value['hash'];
+ if ( ( time() - $value['latest'] ) < WANObjectCache::TTL_MINUTE ) {
+ // Cache was recently updated via replace() and should be up-to-date.
+ // That method is only called in the primary datacenter and uses FOR_UPDATE.
+ // Also, it is unlikely that the current datacenter is *now* secondary one.
+ $expired = false;
+ } else {
+ // See if the "check" key was bumped after the hash was generated
+ $expired = ( $curTTL < 0 );
+ }
+ } else {
+ // No hash found at all; cache must regenerate to be safe
+ $hash = false;
+ $expired = true;
+ }
+
+ return [ $hash, $expired ];
+ }
+
+ /**
+ * Set the md5 used to validate the local disk cache
+ *
+ * If $cache has a 'LATEST' UNIX timestamp key, then the hash will not
+ * be treated as "volatile" by getValidationHash() for the next few seconds.
+ * This is triggered when $cache is generated using FOR_UPDATE mode.
+ *
+ * @param string $code
+ * @param array $cache Cached messages with a version
+ */
+ protected function setValidationHash( $code, array $cache ) {
+ $this->wanCache->set(
+ $this->wanCache->makeKey( 'messages', $code, 'hash', 'v1' ),
+ [
+ 'hash' => $cache['HASH'],
+ 'latest' => isset( $cache['LATEST'] ) ? $cache['LATEST'] : 0
+ ],
+ WANObjectCache::TTL_INDEFINITE
+ );
+ }
+
+ /**
+ * @param string $key A language message cache key that stores blobs
+ * @param int $timeout Wait timeout in seconds
+ * @return null|ScopedCallback
+ */
+ protected function getReentrantScopedLock( $key, $timeout = self::WAIT_SEC ) {
+ return $this->clusterCache->getScopedLock( $key, $timeout, self::LOCK_TTL, __METHOD__ );
+ }
+
+ /**
+ * Get a message from either the content language or the user language.
+ *
+ * First, assemble a list of languages to attempt getting the message from. This
+ * chain begins with the requested language and its fallbacks and then continues with
+ * the content language and its fallbacks. For each language in the chain, the following
+ * process will occur (in this order):
+ * 1. If a language-specific override, i.e., [[MW:msg/lang]], is available, use that.
+ * Note: for the content language, there is no /lang subpage.
+ * 2. Fetch from the static CDB cache.
+ * 3. If available, check the database for fallback language overrides.
+ *
+ * This process provides a number of guarantees. When changing this code, make sure all
+ * of these guarantees are preserved.
+ * * If the requested language is *not* the content language, then the CDB cache for that
+ * specific language will take precedence over the root database page ([[MW:msg]]).
+ * * Fallbacks will be just that: fallbacks. A fallback language will never be reached if
+ * the message is available *anywhere* in the language for which it is a fallback.
+ *
+ * @param string $key The message key
+ * @param bool $useDB If true, look for the message in the DB, false
+ * to use only the compiled l10n cache.
+ * @param bool|string|object $langcode Code of the language to get the message for.
+ * - If string and a valid code, will create a standard language object
+ * - If string but not a valid code, will create a basic language object
+ * - If boolean and false, create object from the current users language
+ * - If boolean and true, create object from the wikis content language
+ * - If language object, use it as given
+ * @param bool $isFullKey Specifies whether $key is a two part key "msg/lang".
+ *
+ * @throws MWException When given an invalid key
+ * @return string|bool False if the message doesn't exist, otherwise the
+ * message (which can be empty)
+ */
+ function get( $key, $useDB = true, $langcode = true, $isFullKey = false ) {
+ if ( is_int( $key ) ) {
+ // Fix numerical strings that somehow become ints
+ // on their way here
+ $key = (string)$key;
+ } elseif ( !is_string( $key ) ) {
+ throw new MWException( 'Non-string key given' );
+ } elseif ( $key === '' ) {
+ // Shortcut: the empty key is always missing
+ return false;
+ }
+
+ // For full keys, get the language code from the key
+ $pos = strrpos( $key, '/' );
+ if ( $isFullKey && $pos !== false ) {
+ $langcode = substr( $key, $pos + 1 );
+ $key = substr( $key, 0, $pos );
+ }
+
+ // Normalise title-case input (with some inlining)
+ $lckey = self::normalizeKey( $key );
+
+ Hooks::run( 'MessageCache::get', [ &$lckey ] );
+
+ // Loop through each language in the fallback list until we find something useful
+ $lang = wfGetLangObj( $langcode );
+ $message = $this->getMessageFromFallbackChain(
+ $lang,
+ $lckey,
+ !$this->mDisable && $useDB
+ );
+
+ // If we still have no message, maybe the key was in fact a full key so try that
+ if ( $message === false ) {
+ $parts = explode( '/', $lckey );
+ // We may get calls for things that are http-urls from sidebar
+ // Let's not load nonexistent languages for those
+ // They usually have more than one slash.
+ if ( count( $parts ) == 2 && $parts[1] !== '' ) {
+ $message = Language::getMessageFor( $parts[0], $parts[1] );
+ if ( $message === null ) {
+ $message = false;
+ }
+ }
+ }
+
+ // Post-processing if the message exists
+ if ( $message !== false ) {
+ // Fix whitespace
+ $message = str_replace(
+ [
+ # Fix for trailing whitespace, removed by textarea
+ ' ',
+ # Fix for NBSP, converted to space by firefox
+ ' ',
+ ' ',
+ ''
+ ],
+ [
+ ' ',
+ "\xc2\xa0",
+ "\xc2\xa0",
+ "\xc2\xad"
+ ],
+ $message
+ );
+ }
+
+ return $message;
+ }
+
+ /**
+ * Given a language, try and fetch messages from that language.
+ *
+ * Will also consider fallbacks of that language, the site language, and fallbacks for
+ * the site language.
+ *
+ * @see MessageCache::get
+ * @param Language|StubObject $lang Preferred language
+ * @param string $lckey Lowercase key for the message (as for localisation cache)
+ * @param bool $useDB Whether to include messages from the wiki database
+ * @return string|bool The message, or false if not found
+ */
+ protected function getMessageFromFallbackChain( $lang, $lckey, $useDB ) {
+ global $wgContLang;
+
+ $alreadyTried = [];
+
+ // First try the requested language.
+ $message = $this->getMessageForLang( $lang, $lckey, $useDB, $alreadyTried );
+ if ( $message !== false ) {
+ return $message;
+ }
+
+ // Now try checking the site language.
+ $message = $this->getMessageForLang( $wgContLang, $lckey, $useDB, $alreadyTried );
+ return $message;
+ }
+
+ /**
+ * Given a language, try and fetch messages from that language and its fallbacks.
+ *
+ * @see MessageCache::get
+ * @param Language|StubObject $lang Preferred language
+ * @param string $lckey Lowercase key for the message (as for localisation cache)
+ * @param bool $useDB Whether to include messages from the wiki database
+ * @param bool[] $alreadyTried Contains true for each language that has been tried already
+ * @return string|bool The message, or false if not found
+ */
+ private function getMessageForLang( $lang, $lckey, $useDB, &$alreadyTried ) {
+ global $wgContLang;
+
+ $langcode = $lang->getCode();
+
+ // Try checking the database for the requested language
+ if ( $useDB ) {
+ $uckey = $wgContLang->ucfirst( $lckey );
+
+ if ( !isset( $alreadyTried[ $langcode ] ) ) {
+ $message = $this->getMsgFromNamespace(
+ $this->getMessagePageName( $langcode, $uckey ),
+ $langcode
+ );
+
+ if ( $message !== false ) {
+ return $message;
+ }
+ $alreadyTried[ $langcode ] = true;
+ }
+ } else {
+ $uckey = null;
+ }
+
+ // Check the CDB cache
+ $message = $lang->getMessage( $lckey );
+ if ( $message !== null ) {
+ return $message;
+ }
+
+ // Try checking the database for all of the fallback languages
+ if ( $useDB ) {
+ $fallbackChain = Language::getFallbacksFor( $langcode );
+
+ foreach ( $fallbackChain as $code ) {
+ if ( isset( $alreadyTried[ $code ] ) ) {
+ continue;
+ }
+
+ $message = $this->getMsgFromNamespace(
+ $this->getMessagePageName( $code, $uckey ), $code );
+
+ if ( $message !== false ) {
+ return $message;
+ }
+ $alreadyTried[ $code ] = true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Get the message page name for a given language
+ *
+ * @param string $langcode
+ * @param string $uckey Uppercase key for the message
+ * @return string The page name
+ */
+ private function getMessagePageName( $langcode, $uckey ) {
+ global $wgLanguageCode;
+
+ if ( $langcode === $wgLanguageCode ) {
+ // Messages created in the content language will not have the /lang extension
+ return $uckey;
+ } else {
+ return "$uckey/$langcode";
+ }
+ }
+
+ /**
+ * Get a message from the MediaWiki namespace, with caching. The key must
+ * first be converted to two-part lang/msg form if necessary.
+ *
+ * Unlike self::get(), this function doesn't resolve fallback chains, and
+ * some callers require this behavior. LanguageConverter::parseCachedTable()
+ * and self::get() are some examples in core.
+ *
+ * @param string $title Message cache key with initial uppercase letter
+ * @param string $code Code denoting the language to try
+ * @return string|bool The message, or false if it does not exist or on error
+ */
+ public function getMsgFromNamespace( $title, $code ) {
+ $this->load( $code );
+
+ if ( isset( $this->mCache[$code][$title] ) ) {
+ $entry = $this->mCache[$code][$title];
+ if ( substr( $entry, 0, 1 ) === ' ' ) {
+ // The message exists, so make sure a string is returned.
+ return (string)substr( $entry, 1 );
+ } elseif ( $entry === '!NONEXISTENT' ) {
+ return false;
+ } elseif ( $entry === '!TOO BIG' ) {
+ // Fall through and try invididual message cache below
+ }
+ } else {
+ // XXX: This is not cached in process cache, should it?
+ $message = false;
+ Hooks::run( 'MessagesPreLoad', [ $title, &$message, $code ] );
+ if ( $message !== false ) {
+ return $message;
+ }
+
+ return false;
+ }
+
+ // Individual message cache key
+ $titleKey = $this->bigMessageCacheKey( $this->mCache[$code]['HASH'], $title );
+
+ if ( $this->mCacheVolatile[$code] ) {
+ $entry = false;
+ // Make sure that individual keys respect the WAN cache holdoff period too
+ LoggerFactory::getInstance( 'MessageCache' )->debug(
+ __METHOD__ . ': loading volatile key \'{titleKey}\'',
+ [ 'titleKey' => $titleKey, 'code' => $code ] );
+ } else {
+ // Try the individual message cache
+ $entry = $this->wanCache->get( $titleKey );
+ }
+
+ if ( $entry !== false ) {
+ if ( substr( $entry, 0, 1 ) === ' ' ) {
+ $this->mCache[$code][$title] = $entry;
+ // The message exists, so make sure a string is returned
+ return (string)substr( $entry, 1 );
+ } elseif ( $entry === '!NONEXISTENT' ) {
+ $this->mCache[$code][$title] = '!NONEXISTENT';
+
+ return false;
+ } else {
+ // Corrupt/obsolete entry, delete it
+ $this->wanCache->delete( $titleKey );
+ }
+ }
+
+ // Try loading the message from the database
+ $dbr = wfGetDB( DB_REPLICA );
+ $cacheOpts = Database::getCacheSetOptions( $dbr );
+ // Use newKnownCurrent() to avoid querying revision/user tables
+ $titleObj = Title::makeTitle( NS_MEDIAWIKI, $title );
+ if ( $titleObj->getLatestRevID() ) {
+ $revision = Revision::newKnownCurrent(
+ $dbr,
+ $titleObj->getArticleID(),
+ $titleObj->getLatestRevID()
+ );
+ } else {
+ $revision = false;
+ }
+
+ if ( $revision ) {
+ $content = $revision->getContent();
+ if ( $content ) {
+ $message = $this->getMessageTextFromContent( $content );
+ if ( is_string( $message ) ) {
+ $this->mCache[$code][$title] = ' ' . $message;
+ $this->wanCache->set( $titleKey, ' ' . $message, $this->mExpiry, $cacheOpts );
+ }
+ } else {
+ // A possibly temporary loading failure
+ LoggerFactory::getInstance( 'MessageCache' )->warning(
+ __METHOD__ . ': failed to load message page text for \'{titleKey}\'',
+ [ 'titleKey' => $titleKey, 'code' => $code ] );
+ $message = null; // no negative caching
+ }
+ } else {
+ $message = false; // negative caching
+ }
+
+ if ( $message === false ) {
+ // Negative caching in case a "too big" message is no longer available (deleted)
+ $this->mCache[$code][$title] = '!NONEXISTENT';
+ $this->wanCache->set( $titleKey, '!NONEXISTENT', $this->mExpiry, $cacheOpts );
+ }
+
+ return $message;
+ }
+
+ /**
+ * @param string $message
+ * @param bool $interface
+ * @param string $language Language code
+ * @param Title $title
+ * @return string
+ */
+ function transform( $message, $interface = false, $language = null, $title = null ) {
+ // Avoid creating parser if nothing to transform
+ if ( strpos( $message, '{{' ) === false ) {
+ return $message;
+ }
+
+ if ( $this->mInParser ) {
+ return $message;
+ }
+
+ $parser = $this->getParser();
+ if ( $parser ) {
+ $popts = $this->getParserOptions();
+ $popts->setInterfaceMessage( $interface );
+ $popts->setTargetLanguage( $language );
+
+ $userlang = $popts->setUserLang( $language );
+ $this->mInParser = true;
+ $message = $parser->transformMsg( $message, $popts, $title );
+ $this->mInParser = false;
+ $popts->setUserLang( $userlang );
+ }
+
+ return $message;
+ }
+
+ /**
+ * @return Parser
+ */
+ function getParser() {
+ global $wgParser, $wgParserConf;
+
+ if ( !$this->mParser && isset( $wgParser ) ) {
+ # Do some initialisation so that we don't have to do it twice
+ $wgParser->firstCallInit();
+ # Clone it and store it
+ $class = $wgParserConf['class'];
+ if ( $class == 'ParserDiffTest' ) {
+ # Uncloneable
+ $this->mParser = new $class( $wgParserConf );
+ } else {
+ $this->mParser = clone $wgParser;
+ }
+ }
+
+ return $this->mParser;
+ }
+
+ /**
+ * @param string $text
+ * @param Title $title
+ * @param bool $linestart Whether or not this is at the start of a line
+ * @param bool $interface Whether this is an interface message
+ * @param Language|string $language Language code
+ * @return ParserOutput|string
+ */
+ public function parse( $text, $title = null, $linestart = true,
+ $interface = false, $language = null
+ ) {
+ global $wgTitle;
+
+ if ( $this->mInParser ) {
+ return htmlspecialchars( $text );
+ }
+
+ $parser = $this->getParser();
+ $popts = $this->getParserOptions();
+ $popts->setInterfaceMessage( $interface );
+
+ if ( is_string( $language ) ) {
+ $language = Language::factory( $language );
+ }
+ $popts->setTargetLanguage( $language );
+
+ if ( !$title || !$title instanceof Title ) {
+ wfDebugLog( 'GlobalTitleFail', __METHOD__ . ' called by ' .
+ wfGetAllCallers( 6 ) . ' with no title set.' );
+ $title = $wgTitle;
+ }
+ // Sometimes $wgTitle isn't set either...
+ if ( !$title ) {
+ # It's not uncommon having a null $wgTitle in scripts. See r80898
+ # Create a ghost title in such case
+ $title = Title::makeTitle( NS_SPECIAL, 'Badtitle/title not set in ' . __METHOD__ );
+ }
+
+ $this->mInParser = true;
+ $res = $parser->parse( $text, $title, $popts, $linestart );
+ $this->mInParser = false;
+
+ return $res;
+ }
+
+ function disable() {
+ $this->mDisable = true;
+ }
+
+ function enable() {
+ $this->mDisable = false;
+ }
+
+ /**
+ * Whether DB/cache usage is disabled for determining messages
+ *
+ * If so, this typically indicates either:
+ * - a) load() failed to find a cached copy nor query the DB
+ * - b) we are in a special context or error mode that cannot use the DB
+ * If the DB is ignored, any derived HTML output or cached objects may be wrong.
+ * To avoid long-term cache pollution, TTLs can be adjusted accordingly.
+ *
+ * @return bool
+ * @since 1.27
+ */
+ public function isDisabled() {
+ return $this->mDisable;
+ }
+
+ /**
+ * Clear all stored messages. Mainly used after a mass rebuild.
+ */
+ function clear() {
+ $langs = Language::fetchLanguageNames( null, 'mw' );
+ foreach ( array_keys( $langs ) as $code ) {
+ # Global and local caches
+ $this->wanCache->touchCheckKey( $this->wanCache->makeKey( 'messages', $code ) );
+ }
+
+ $this->mLoadedLanguages = [];
+ }
+
+ /**
+ * @param string $key
+ * @return array
+ */
+ public function figureMessage( $key ) {
+ global $wgLanguageCode;
+
+ $pieces = explode( '/', $key );
+ if ( count( $pieces ) < 2 ) {
+ return [ $key, $wgLanguageCode ];
+ }
+
+ $lang = array_pop( $pieces );
+ if ( !Language::fetchLanguageName( $lang, null, 'mw' ) ) {
+ return [ $key, $wgLanguageCode ];
+ }
+
+ $message = implode( '/', $pieces );
+
+ return [ $message, $lang ];
+ }
+
+ /**
+ * Get all message keys stored in the message cache for a given language.
+ * If $code is the content language code, this will return all message keys
+ * for which MediaWiki:msgkey exists. If $code is another language code, this
+ * will ONLY return message keys for which MediaWiki:msgkey/$code exists.
+ * @param string $code Language code
+ * @return array Array of message keys (strings)
+ */
+ public function getAllMessageKeys( $code ) {
+ global $wgContLang;
+
+ $this->load( $code );
+ if ( !isset( $this->mCache[$code] ) ) {
+ // Apparently load() failed
+ return null;
+ }
+ // Remove administrative keys
+ $cache = $this->mCache[$code];
+ unset( $cache['VERSION'] );
+ unset( $cache['EXPIRY'] );
+ unset( $cache['EXCESSIVE'] );
+ // Remove any !NONEXISTENT keys
+ $cache = array_diff( $cache, [ '!NONEXISTENT' ] );
+
+ // Keys may appear with a capital first letter. lcfirst them.
+ return array_map( [ $wgContLang, 'lcfirst' ], array_keys( $cache ) );
+ }
+
+ /**
+ * Purge message caches when a MediaWiki: page is created, updated, or deleted
+ *
+ * @param Title $title Message page title
+ * @param Content|null $content New content for edit/create, null on deletion
+ * @since 1.29
+ */
+ public function updateMessageOverride( Title $title, Content $content = null ) {
+ global $wgContLang;
+
+ $msgText = $this->getMessageTextFromContent( $content );
+ if ( $msgText === null ) {
+ $msgText = false; // treat as not existing
+ }
+
+ $this->replace( $title->getDBkey(), $msgText );
+
+ if ( $wgContLang->hasVariants() ) {
+ $wgContLang->updateConversionTable( $title );
+ }
+ }
+
+ /**
+ * @param Content|null $content Content or null if the message page does not exist
+ * @return string|bool|null Returns false if $content is null and null on error
+ */
+ private function getMessageTextFromContent( Content $content = null ) {
+ // @TODO: could skip pseudo-messages like js/css here, based on content model
+ if ( $content ) {
+ // Message page exists...
+ // XXX: Is this the right way to turn a Content object into a message?
+ // NOTE: $content is typically either WikitextContent, JavaScriptContent or
+ // CssContent. MessageContent is *not* used for storing messages, it's
+ // only used for wrapping them when needed.
+ $msgText = $content->getWikitextForTransclusion();
+ if ( $msgText === false || $msgText === null ) {
+ // This might be due to some kind of misconfiguration...
+ $msgText = null;
+ LoggerFactory::getInstance( 'MessageCache' )->warning(
+ __METHOD__ . ": message content doesn't provide wikitext "
+ . "(content model: " . $content->getModel() . ")" );
+ }
+ } else {
+ // Message page does not exist...
+ $msgText = false;
+ }
+
+ return $msgText;
+ }
+
+ /**
+ * @param string $hash Hash for this version of the entire key/value overrides map
+ * @param string $title Message cache key with initial uppercase letter
+ * @return string
+ */
+ private function bigMessageCacheKey( $hash, $title ) {
+ return $this->wanCache->makeKey( 'messages-big', $hash, $title );
+ }
+}