LocalisationCache.php

Go to the documentation of this file.

<?php
class LocalisationCache {
    const VERSION = 2;

    private $conf;

    private $manualRecache = false;

    private $forceRecache = false;

    protected $data = array();

    private $store;

    private $loadedItems = array();

    private $loadedSubitems = array();

    private $initialisedLangs = array();

    private $shallowFallbacks = array();

    private $recachedLangs = array();

    static public $allKeys = array(
        'fallback', 'namespaceNames', 'bookstoreList',
        'magicWords', 'messages', 'rtl', 'capitalizeAllNouns', 'digitTransformTable',
        'separatorTransformTable', 'fallback8bitEncoding', 'linkPrefixExtension',
        'linkTrail', 'linkPrefixCharset', 'namespaceAliases',
        'dateFormats', 'datePreferences', 'datePreferenceMigrationMap',
        'defaultDateFormat', 'extraUserToggles', 'specialPageAliases',
        'imageFiles', 'preloadedMessages', 'namespaceGenderAliases',
        'digitGroupingPattern', 'pluralRules', 'pluralRuleTypes', 'compiledPluralRules',
    );

    static public $mergeableMapKeys = array( 'messages', 'namespaceNames',
        'dateFormats', 'imageFiles', 'preloadedMessages'
    );

    static public $mergeableListKeys = array( 'extraUserToggles' );

    static public $mergeableAliasListKeys = array( 'specialPageAliases' );

    static public $optionalMergeKeys = array( 'bookstoreList' );

    static public $magicWordKeys = array( 'magicWords' );

    static public $splitKeys = array( 'messages' );

    static public $preloadedKeys = array( 'dateFormats', 'namespaceNames' );

    private $pluralRules = null;

    private $pluralRuleTypes = null;

    private $mergeableKeys = null;

    function __construct( $conf ) {
        global $wgCacheDirectory;

        $this->conf = $conf;
        $storeConf = array();
        if ( !empty( $conf['storeClass'] ) ) {
            $storeClass = $conf['storeClass'];
        } else {
            switch ( $conf['store'] ) {
                case 'files':
                case 'file':
                    $storeClass = 'LCStoreCDB';
                    break;
                case 'db':
                    $storeClass = 'LCStoreDB';
                    break;
                case 'detect':
                    $storeClass = $wgCacheDirectory ? 'LCStoreCDB' : 'LCStoreDB';
                    break;
                default:
                    throw new MWException(
                        'Please set $wgLocalisationCacheConf[\'store\'] to something sensible.' );
            }
        }

        wfDebugLog( 'caches', get_class( $this ) . ": using store $storeClass" );
        if ( !empty( $conf['storeDirectory'] ) ) {
            $storeConf['directory'] = $conf['storeDirectory'];
        }

        $this->store = new $storeClass( $storeConf );
        foreach ( array( 'manualRecache', 'forceRecache' ) as $var ) {
            if ( isset( $conf[$var] ) ) {
                $this->$var = $conf[$var];
            }
        }
    }

    public function isMergeableKey( $key ) {
        if ( $this->mergeableKeys === null ) {
            $this->mergeableKeys = array_flip( array_merge(
                self::$mergeableMapKeys,
                self::$mergeableListKeys,
                self::$mergeableAliasListKeys,
                self::$optionalMergeKeys,
                self::$magicWordKeys
            ) );
        }

        return isset( $this->mergeableKeys[$key] );
    }

    public function getItem( $code, $key ) {
        if ( !isset( $this->loadedItems[$code][$key] ) ) {
            wfProfileIn( __METHOD__ . '-load' );
            $this->loadItem( $code, $key );
            wfProfileOut( __METHOD__ . '-load' );
        }

        if ( $key === 'fallback' && isset( $this->shallowFallbacks[$code] ) ) {
            return $this->shallowFallbacks[$code];
        }

        return $this->data[$code][$key];
    }

    public function getSubitem( $code, $key, $subkey ) {
        if ( !isset( $this->loadedSubitems[$code][$key][$subkey] ) &&
            !isset( $this->loadedItems[$code][$key] )
        ) {
            wfProfileIn( __METHOD__ . '-load' );
            $this->loadSubitem( $code, $key, $subkey );
            wfProfileOut( __METHOD__ . '-load' );
        }

        if ( isset( $this->data[$code][$key][$subkey] ) ) {
            return $this->data[$code][$key][$subkey];
        } else {
            return null;
        }
    }

    public function getSubitemList( $code, $key ) {
        if ( in_array( $key, self::$splitKeys ) ) {
            return $this->getSubitem( $code, 'list', $key );
        } else {
            $item = $this->getItem( $code, $key );
            if ( is_array( $item ) ) {
                return array_keys( $item );
            } else {
                return false;
            }
        }
    }

    protected function loadItem( $code, $key ) {
        if ( !isset( $this->initialisedLangs[$code] ) ) {
            $this->initLanguage( $code );
        }

        // Check to see if initLanguage() loaded it for us
        if ( isset( $this->loadedItems[$code][$key] ) ) {
            return;
        }

        if ( isset( $this->shallowFallbacks[$code] ) ) {
            $this->loadItem( $this->shallowFallbacks[$code], $key );

            return;
        }

        if ( in_array( $key, self::$splitKeys ) ) {
            $subkeyList = $this->getSubitem( $code, 'list', $key );
            foreach ( $subkeyList as $subkey ) {
                if ( isset( $this->data[$code][$key][$subkey] ) ) {
                    continue;
                }
                $this->data[$code][$key][$subkey] = $this->getSubitem( $code, $key, $subkey );
            }
        } else {
            $this->data[$code][$key] = $this->store->get( $code, $key );
        }

        $this->loadedItems[$code][$key] = true;
    }

    protected function loadSubitem( $code, $key, $subkey ) {
        if ( !in_array( $key, self::$splitKeys ) ) {
            $this->loadItem( $code, $key );

            return;
        }

        if ( !isset( $this->initialisedLangs[$code] ) ) {
            $this->initLanguage( $code );
        }

        // Check to see if initLanguage() loaded it for us
        if ( isset( $this->loadedItems[$code][$key] ) ||
            isset( $this->loadedSubitems[$code][$key][$subkey] )
        ) {
            return;
        }

        if ( isset( $this->shallowFallbacks[$code] ) ) {
            $this->loadSubitem( $this->shallowFallbacks[$code], $key, $subkey );

            return;
        }

        $value = $this->store->get( $code, "$key:$subkey" );
        $this->data[$code][$key][$subkey] = $value;
        $this->loadedSubitems[$code][$key][$subkey] = true;
    }

    public function isExpired( $code ) {
        if ( $this->forceRecache && !isset( $this->recachedLangs[$code] ) ) {
            wfDebug( __METHOD__ . "($code): forced reload\n" );

            return true;
        }

        $deps = $this->store->get( $code, 'deps' );
        $keys = $this->store->get( $code, 'list' );
        $preload = $this->store->get( $code, 'preload' );
        // Different keys may expire separately for some stores
        if ( $deps === null || $keys === null || $preload === null ) {
            wfDebug( __METHOD__ . "($code): cache missing, need to make one\n" );

            return true;
        }

        foreach ( $deps as $dep ) {
            // Because we're unserializing stuff from cache, we
            // could receive objects of classes that don't exist
            // anymore (e.g. uninstalled extensions)
            // When this happens, always expire the cache
            if ( !$dep instanceof CacheDependency || $dep->isExpired() ) {
                wfDebug( __METHOD__ . "($code): cache for $code expired due to " .
                    get_class( $dep ) . "\n" );

                return true;
            }
        }

        return false;
    }

    protected function initLanguage( $code ) {
        if ( isset( $this->initialisedLangs[$code] ) ) {
            return;
        }

        $this->initialisedLangs[$code] = true;

        # If the code is of the wrong form for a Messages*.php file, do a shallow fallback
        if ( !Language::isValidBuiltInCode( $code ) ) {
            $this->initShallowFallback( $code, 'en' );

            return;
        }

        # Recache the data if necessary
        if ( !$this->manualRecache && $this->isExpired( $code ) ) {
            if ( Language::isSupportedLanguage( $code ) ) {
                $this->recache( $code );
            } elseif ( $code === 'en' ) {
                throw new MWException( 'MessagesEn.php is missing.' );
            } else {
                $this->initShallowFallback( $code, 'en' );
            }

            return;
        }

        # Preload some stuff
        $preload = $this->getItem( $code, 'preload' );
        if ( $preload === null ) {
            if ( $this->manualRecache ) {
                // No Messages*.php file. Do shallow fallback to en.
                if ( $code === 'en' ) {
                    throw new MWException( 'No localisation cache found for English. ' .
                        'Please run maintenance/rebuildLocalisationCache.php.' );
                }
                $this->initShallowFallback( $code, 'en' );

                return;
            } else {
                throw new MWException( 'Invalid or missing localisation cache.' );
            }
        }
        $this->data[$code] = $preload;
        foreach ( $preload as $key => $item ) {
            if ( in_array( $key, self::$splitKeys ) ) {
                foreach ( $item as $subkey => $subitem ) {
                    $this->loadedSubitems[$code][$key][$subkey] = true;
                }
            } else {
                $this->loadedItems[$code][$key] = true;
            }
        }
    }

    public function initShallowFallback( $primaryCode, $fallbackCode ) {
        $this->data[$primaryCode] =& $this->data[$fallbackCode];
        $this->loadedItems[$primaryCode] =& $this->loadedItems[$fallbackCode];
        $this->loadedSubitems[$primaryCode] =& $this->loadedSubitems[$fallbackCode];
        $this->shallowFallbacks[$primaryCode] = $fallbackCode;
    }

    protected function readPHPFile( $_fileName, $_fileType ) {
        wfProfileIn( __METHOD__ );
        // Disable APC caching
        wfSuppressWarnings();
        $_apcEnabled = ini_set( 'apc.cache_by_default', '0' );
        wfRestoreWarnings();

        include $_fileName;

        wfSuppressWarnings();
        ini_set( 'apc.cache_by_default', $_apcEnabled );
        wfRestoreWarnings();

        if ( $_fileType == 'core' || $_fileType == 'extension' ) {
            $data = compact( self::$allKeys );
        } elseif ( $_fileType == 'aliases' ) {
            $data = compact( 'aliases' );
        } else {
            wfProfileOut( __METHOD__ );
            throw new MWException( __METHOD__ . ": Invalid file type: $_fileType" );
        }
        wfProfileOut( __METHOD__ );

        return $data;
    }

    public function readJSONFile( $fileName ) {
        wfProfileIn( __METHOD__ );

        if ( !is_readable( $fileName ) ) {
            wfProfileOut( __METHOD__ );

            return array();
        }

        $json = file_get_contents( $fileName );
        if ( $json === false ) {
            wfProfileOut( __METHOD__ );

            return array();
        }

        $data = FormatJson::decode( $json, true );
        if ( $data === null ) {
            wfProfileOut( __METHOD__ );

            throw new MWException( __METHOD__ . ": Invalid JSON file: $fileName" );
        }

        // Remove keys starting with '@', they're reserved for metadata and non-message data
        foreach ( $data as $key => $unused ) {
            if ( $key === '' || $key[0] === '@' ) {
                unset( $data[$key] );
            }
        }

        wfProfileOut( __METHOD__ );

        // The JSON format only supports messages, none of the other variables, so wrap the data
        return array( 'messages' => $data );
    }

    public function getCompiledPluralRules( $code ) {
        $rules = $this->getPluralRules( $code );
        if ( $rules === null ) {
            return null;
        }
        try {
            $compiledRules = CLDRPluralRuleEvaluator::compile( $rules );
        } catch ( CLDRPluralRuleError $e ) {
            wfDebugLog( 'l10n', $e->getMessage() );

            return array();
        }

        return $compiledRules;
    }

    public function getPluralRules( $code ) {
        if ( $this->pluralRules === null ) {
            $this->loadPluralFiles();
        }
        if ( !isset( $this->pluralRules[$code] ) ) {
            return null;
        } else {
            return $this->pluralRules[$code];
        }
    }

    public function getPluralRuleTypes( $code ) {
        if ( $this->pluralRuleTypes === null ) {
            $this->loadPluralFiles();
        }
        if ( !isset( $this->pluralRuleTypes[$code] ) ) {
            return null;
        } else {
            return $this->pluralRuleTypes[$code];
        }
    }

    protected function loadPluralFiles() {
        global $IP;
        $cldrPlural = "$IP/languages/data/plurals.xml";
        $mwPlural = "$IP/languages/data/plurals-mediawiki.xml";
        // Load CLDR plural rules
        $this->loadPluralFile( $cldrPlural );
        if ( file_exists( $mwPlural ) ) {
            // Override or extend
            $this->loadPluralFile( $mwPlural );
        }
    }

    protected function loadPluralFile( $fileName ) {
        $doc = new DOMDocument;
        $doc->load( $fileName );
        $rulesets = $doc->getElementsByTagName( "pluralRules" );
        foreach ( $rulesets as $ruleset ) {
            $codes = $ruleset->getAttribute( 'locales' );
            $rules = array();
            $ruleTypes = array();
            $ruleElements = $ruleset->getElementsByTagName( "pluralRule" );
            foreach ( $ruleElements as $elt ) {
                $ruleType = $elt->getAttribute( 'count' );
                if ( $ruleType === 'other' ) {
                    // Don't record "other" rules, which have an empty condition
                    continue;
                }
                $rules[] = $elt->nodeValue;
                $ruleTypes[] = $ruleType;
            }
            foreach ( explode( ' ', $codes ) as $code ) {
                $this->pluralRules[$code] = $rules;
                $this->pluralRuleTypes[$code] = $ruleTypes;
            }
        }
    }

    protected function readSourceFilesAndRegisterDeps( $code, &$deps ) {
        global $IP;
        wfProfileIn( __METHOD__ );

        // This reads in the PHP i18n file with non-messages l10n data
        $fileName = Language::getMessagesFileName( $code );
        if ( !file_exists( $fileName ) ) {
            $data = array();
        } else {
            $deps[] = new FileDependency( $fileName );
            $data = $this->readPHPFile( $fileName, 'core' );
        }

        # Load CLDR plural rules for JavaScript
        $data['pluralRules'] = $this->getPluralRules( $code );
        # And for PHP
        $data['compiledPluralRules'] = $this->getCompiledPluralRules( $code );
        # Load plural rule types
        $data['pluralRuleTypes'] = $this->getPluralRuleTypes( $code );

        $deps['plurals'] = new FileDependency( "$IP/languages/data/plurals.xml" );
        $deps['plurals-mw'] = new FileDependency( "$IP/languages/data/plurals-mediawiki.xml" );

        wfProfileOut( __METHOD__ );

        return $data;
    }

    protected function mergeItem( $key, &$value, $fallbackValue ) {
        if ( !is_null( $value ) ) {
            if ( !is_null( $fallbackValue ) ) {
                if ( in_array( $key, self::$mergeableMapKeys ) ) {
                    $value = $value + $fallbackValue;
                } elseif ( in_array( $key, self::$mergeableListKeys ) ) {
                    $value = array_unique( array_merge( $fallbackValue, $value ) );
                } elseif ( in_array( $key, self::$mergeableAliasListKeys ) ) {
                    $value = array_merge_recursive( $value, $fallbackValue );
                } elseif ( in_array( $key, self::$optionalMergeKeys ) ) {
                    if ( !empty( $value['inherit'] ) ) {
                        $value = array_merge( $fallbackValue, $value );
                    }

                    if ( isset( $value['inherit'] ) ) {
                        unset( $value['inherit'] );
                    }
                } elseif ( in_array( $key, self::$magicWordKeys ) ) {
                    $this->mergeMagicWords( $value, $fallbackValue );
                }
            }
        } else {
            $value = $fallbackValue;
        }
    }

    protected function mergeMagicWords( &$value, $fallbackValue ) {
        foreach ( $fallbackValue as $magicName => $fallbackInfo ) {
            if ( !isset( $value[$magicName] ) ) {
                $value[$magicName] = $fallbackInfo;
            } else {
                $oldSynonyms = array_slice( $fallbackInfo, 1 );
                $newSynonyms = array_slice( $value[$magicName], 1 );
                $synonyms = array_values( array_unique( array_merge(
                    $newSynonyms, $oldSynonyms ) ) );
                $value[$magicName] = array_merge( array( $fallbackInfo[0] ), $synonyms );
            }
        }
    }

    protected function mergeExtensionItem( $codeSequence, $key, &$value, $fallbackValue ) {
        $used = false;
        foreach ( $codeSequence as $code ) {
            if ( isset( $fallbackValue[$code] ) ) {
                $this->mergeItem( $key, $value, $fallbackValue[$code] );
                $used = true;
            }
        }

        return $used;
    }

    public function recache( $code ) {
        global $wgExtensionMessagesFiles, $wgMessagesDirs;
        wfProfileIn( __METHOD__ );

        if ( !$code ) {
            wfProfileOut( __METHOD__ );
            throw new MWException( "Invalid language code requested" );
        }
        $this->recachedLangs[$code] = true;

        # Initial values
        $initialData = array_combine(
            self::$allKeys,
            array_fill( 0, count( self::$allKeys ), null ) );
        $coreData = $initialData;
        $deps = array();

        # Load the primary localisation from the source file
        $data = $this->readSourceFilesAndRegisterDeps( $code, $deps );
        if ( $data === false ) {
            wfDebug( __METHOD__ . ": no localisation file for $code, using fallback to en\n" );
            $coreData['fallback'] = 'en';
        } else {
            wfDebug( __METHOD__ . ": got localisation for $code from source\n" );

            # Merge primary localisation
            foreach ( $data as $key => $value ) {
                $this->mergeItem( $key, $coreData[$key], $value );
            }
        }

        # Fill in the fallback if it's not there already
        if ( is_null( $coreData['fallback'] ) ) {
            $coreData['fallback'] = $code === 'en' ? false : 'en';
        }
        if ( $coreData['fallback'] === false ) {
            $coreData['fallbackSequence'] = array();
        } else {
            $coreData['fallbackSequence'] = array_map( 'trim', explode( ',', $coreData['fallback'] ) );
            $len = count( $coreData['fallbackSequence'] );

            # Ensure that the sequence ends at en
            if ( $coreData['fallbackSequence'][$len - 1] !== 'en' ) {
                $coreData['fallbackSequence'][] = 'en';
            }
        }

        $codeSequence = array_merge( array( $code ), $coreData['fallbackSequence'] );

        wfProfileIn( __METHOD__ . '-fallbacks' );

        # Load non-JSON localisation data for extensions
        $extensionData = array_combine(
            $codeSequence,
            array_fill( 0, count( $codeSequence ), $initialData ) );
        foreach ( $wgExtensionMessagesFiles as $extension => $fileName ) {
            if ( isset( $wgMessagesDirs[$extension] ) ) {
                # This extension has JSON message data; skip the PHP shim
                continue;
            }

            $data = $this->readPHPFile( $fileName, 'extension' );
            $used = false;

            foreach ( $data as $key => $item ) {
                foreach ( $codeSequence as $csCode ) {
                    if ( isset( $item[$csCode] ) ) {
                        $this->mergeItem( $key, $extensionData[$csCode][$key], $item[$csCode] );
                        $used = true;
                    }
                }
            }

            if ( $used ) {
                $deps[] = new FileDependency( $fileName );
            }
        }

        # Load the localisation data for each fallback, then merge it into the full array
        $allData = $initialData;
        foreach ( $codeSequence as $csCode ) {
            $csData = $initialData;

            # Load core messages and the extension localisations.
            foreach ( $wgMessagesDirs as $dirs ) {
                foreach ( (array)$dirs as $dir ) {
                    $fileName = "$dir/$csCode.json";
                    $data = $this->readJSONFile( $fileName );

                    foreach ( $data as $key => $item ) {
                        $this->mergeItem( $key, $csData[$key], $item );
                    }

                    $deps[] = new FileDependency( $fileName );
                }
            }

            # Merge non-JSON extension data
            if ( isset( $extensionData[$csCode] ) ) {
                foreach ( $extensionData[$csCode] as $key => $item ) {
                    $this->mergeItem( $key, $csData[$key], $item );
                }
            }

            if ( $csCode === $code ) {
                # Merge core data into extension data
                foreach ( $coreData as $key => $item ) {
                    $this->mergeItem( $key, $csData[$key], $item );
                }
            } else {
                # Load the secondary localisation from the source file to
                # avoid infinite cycles on cyclic fallbacks
                $fbData = $this->readSourceFilesAndRegisterDeps( $csCode, $deps );
                if ( $fbData !== false ) {
                    # Only merge the keys that make sense to merge
                    foreach ( self::$allKeys as $key ) {
                        if ( !isset( $fbData[$key] ) ) {
                            continue;
                        }

                        if ( is_null( $coreData[$key] ) || $this->isMergeableKey( $key ) ) {
                            $this->mergeItem( $key, $csData[$key], $fbData[$key] );
                        }
                    }
                }
            }

            # Allow extensions an opportunity to adjust the data for this
            # fallback
            wfRunHooks( 'LocalisationCacheRecacheFallback', array( $this, $csCode, &$csData ) );

            # Merge the data for this fallback into the final array
            if ( $csCode === $code ) {
                $allData = $csData;
            } else {
                foreach ( self::$allKeys as $key ) {
                    if ( !isset( $csData[$key] ) ) {
                        continue;
                    }

                    if ( is_null( $allData[$key] ) || $this->isMergeableKey( $key ) ) {
                        $this->mergeItem( $key, $allData[$key], $csData[$key] );
                    }
                }
            }
        }

        wfProfileOut( __METHOD__ . '-fallbacks' );

        # Add cache dependencies for any referenced globals
        $deps['wgExtensionMessagesFiles'] = new GlobalDependency( 'wgExtensionMessagesFiles' );
        $deps['wgMessagesDirs'] = new GlobalDependency( 'wgMessagesDirs' );
        $deps['version'] = new ConstantDependency( 'LocalisationCache::VERSION' );

        # Add dependencies to the cache entry
        $allData['deps'] = $deps;

        # Replace spaces with underscores in namespace names
        $allData['namespaceNames'] = str_replace( ' ', '_', $allData['namespaceNames'] );

        # And do the same for special page aliases. $page is an array.
        foreach ( $allData['specialPageAliases'] as &$page ) {
            $page = str_replace( ' ', '_', $page );
        }
        # Decouple the reference to prevent accidental damage
        unset( $page );

        # If there were no plural rules, return an empty array
        if ( $allData['pluralRules'] === null ) {
            $allData['pluralRules'] = array();
        }
        if ( $allData['compiledPluralRules'] === null ) {
            $allData['compiledPluralRules'] = array();
        }
        # If there were no plural rule types, return an empty array
        if ( $allData['pluralRuleTypes'] === null ) {
            $allData['pluralRuleTypes'] = array();
        }

        # Set the list keys
        $allData['list'] = array();
        foreach ( self::$splitKeys as $key ) {
            $allData['list'][$key] = array_keys( $allData[$key] );
        }
        # Run hooks
        $purgeBlobs = true;
        wfRunHooks( 'LocalisationCacheRecache', array( $this, $code, &$allData, &$purgeBlobs ) );

        if ( is_null( $allData['namespaceNames'] ) ) {
            wfProfileOut( __METHOD__ );
            throw new MWException( __METHOD__ . ': Localisation data failed sanity check! ' .
                'Check that your languages/messages/MessagesEn.php file is intact.' );
        }

        # Set the preload key
        $allData['preload'] = $this->buildPreload( $allData );

        # Save to the process cache and register the items loaded
        $this->data[$code] = $allData;
        foreach ( $allData as $key => $item ) {
            $this->loadedItems[$code][$key] = true;
        }

        # Save to the persistent cache
        wfProfileIn( __METHOD__ . '-write' );
        $this->store->startWrite( $code );
        foreach ( $allData as $key => $value ) {
            if ( in_array( $key, self::$splitKeys ) ) {
                foreach ( $value as $subkey => $subvalue ) {
                    $this->store->set( "$key:$subkey", $subvalue );
                }
            } else {
                $this->store->set( $key, $value );
            }
        }
        $this->store->finishWrite();
        wfProfileOut( __METHOD__ . '-write' );

        # Clear out the MessageBlobStore
        # HACK: If using a null (i.e. disabled) storage backend, we
        # can't write to the MessageBlobStore either
        if ( $purgeBlobs && !$this->store instanceof LCStoreNull ) {
            MessageBlobStore::getInstance()->clear();
        }

        wfProfileOut( __METHOD__ );
    }

    protected function buildPreload( $data ) {
        $preload = array( 'messages' => array() );
        foreach ( self::$preloadedKeys as $key ) {
            $preload[$key] = $data[$key];
        }

        foreach ( $data['preloadedMessages'] as $subkey ) {
            if ( isset( $data['messages'][$subkey] ) ) {
                $subitem = $data['messages'][$subkey];
            } else {
                $subitem = null;
            }
            $preload['messages'][$subkey] = $subitem;
        }

        return $preload;
    }

    public function unload( $code ) {
        unset( $this->data[$code] );
        unset( $this->loadedItems[$code] );
        unset( $this->loadedSubitems[$code] );
        unset( $this->initialisedLangs[$code] );
        unset( $this->shallowFallbacks[$code] );

        foreach ( $this->shallowFallbacks as $shallowCode => $fbCode ) {
            if ( $fbCode === $code ) {
                $this->unload( $shallowCode );
            }
        }
    }

    public function unloadAll() {
        foreach ( $this->initialisedLangs as $lang => $unused ) {
            $this->unload( $lang );
        }
    }

    public function disableBackend() {
        $this->store = new LCStoreNull;
        $this->manualRecache = false;
    }
}

interface LCStore {
    function get( $code, $key );

    function startWrite( $code );

    function finishWrite();

    function set( $key, $value );
}

class LCStoreDB implements LCStore {
    private $currentLang;
    private $writesDone = false;

    private $dbw;
    private $batch = array();

    private $readOnly = false;

    public function get( $code, $key ) {
        if ( $this->writesDone ) {
            $db = wfGetDB( DB_MASTER );
        } else {
            $db = wfGetDB( DB_SLAVE );
        }
        $row = $db->selectRow( 'l10n_cache', array( 'lc_value' ),
            array( 'lc_lang' => $code, 'lc_key' => $key ), __METHOD__ );
        if ( $row ) {
            return unserialize( $db->decodeBlob( $row->lc_value ) );
        } else {
            return null;
        }
    }

    public function startWrite( $code ) {
        if ( $this->readOnly ) {
            return;
        } elseif ( !$code ) {
            throw new MWException( __METHOD__ . ": Invalid language \"$code\"" );
        }

        $this->dbw = wfGetDB( DB_MASTER );

        $this->currentLang = $code;
        $this->batch = array();
    }

    public function finishWrite() {
        if ( $this->readOnly ) {
            return;
        } elseif ( is_null( $this->currentLang ) ) {
            throw new MWException( __CLASS__ . ': must call startWrite() before finishWrite()' );
        }

        $this->dbw->begin( __METHOD__ );
        try {
            $this->dbw->delete( 'l10n_cache',
                array( 'lc_lang' => $this->currentLang ), __METHOD__ );
            foreach ( array_chunk( $this->batch, 500 ) as $rows ) {
                $this->dbw->insert( 'l10n_cache', $rows, __METHOD__ );
            }
            $this->writesDone = true;
        } catch ( DBQueryError $e ) {
            if ( $this->dbw->wasReadOnlyError() ) {
                $this->readOnly = true; // just avoid site down time
            } else {
                throw $e;
            }
        }
        $this->dbw->commit( __METHOD__ );

        $this->currentLang = null;
        $this->batch = array();
    }

    public function set( $key, $value ) {
        if ( $this->readOnly ) {
            return;
        } elseif ( is_null( $this->currentLang ) ) {
            throw new MWException( __CLASS__ . ': must call startWrite() before set()' );
        }

        $this->batch[] = array(
            'lc_lang' => $this->currentLang,
            'lc_key' => $key,
            'lc_value' => $this->dbw->encodeBlob( serialize( $value ) ) );
    }
}

class LCStoreCDB implements LCStore {
    private $readers;

    private $writer;

    private $currentLang;

    private $directory;

    function __construct( $conf = array() ) {
        global $wgCacheDirectory;

        if ( isset( $conf['directory'] ) ) {
            $this->directory = $conf['directory'];
        } else {
            $this->directory = $wgCacheDirectory;
        }
    }

    public function get( $code, $key ) {
        if ( !isset( $this->readers[$code] ) ) {
            $fileName = $this->getFileName( $code );

            $this->readers[$code] = false;
            if ( file_exists( $fileName ) ) {
                try {
                    $this->readers[$code] = CdbReader::open( $fileName );
                } catch ( CdbException $e ) {
                    wfDebug( __METHOD__ . ": unable to open cdb file for reading\n" );
                }
            }
        }

        if ( !$this->readers[$code] ) {
            return null;
        } else {
            $value = false;
            try {
                $value = $this->readers[$code]->get( $key );
            } catch ( CdbException $e ) {
                wfDebug( __METHOD__ . ": CdbException caught, error message was "
                    . $e->getMessage() . "\n" );
            }
            if ( $value === false ) {
                return null;
            }

            return unserialize( $value );
        }
    }

    public function startWrite( $code ) {
        if ( !file_exists( $this->directory ) ) {
            if ( !wfMkdirParents( $this->directory, null, __METHOD__ ) ) {
                throw new MWException( "Unable to create the localisation store " .
                    "directory \"{$this->directory}\"" );
            }
        }

        // Close reader to stop permission errors on write
        if ( !empty( $this->readers[$code] ) ) {
            $this->readers[$code]->close();
        }

        try {
            $this->writer = CdbWriter::open( $this->getFileName( $code ) );
        } catch ( CdbException $e ) {
            throw new MWException( $e->getMessage() );
        }
        $this->currentLang = $code;
    }

    public function finishWrite() {
        // Close the writer
        try {
            $this->writer->close();
        } catch ( CdbException $e ) {
            throw new MWException( $e->getMessage() );
        }
        $this->writer = null;
        unset( $this->readers[$this->currentLang] );
        $this->currentLang = null;
    }

    public function set( $key, $value ) {
        if ( is_null( $this->writer ) ) {
            throw new MWException( __CLASS__ . ': must call startWrite() before calling set()' );
        }
        try {
            $this->writer->set( $key, serialize( $value ) );
        } catch ( CdbException $e ) {
            throw new MWException( $e->getMessage() );
        }
    }

    protected function getFileName( $code ) {
        if ( strval( $code ) === '' || strpos( $code, '/' ) !== false ) {
            throw new MWException( __METHOD__ . ": Invalid language \"$code\"" );
        }

        return "{$this->directory}/l10n_cache-$code.cdb";
    }
}

class LCStoreNull implements LCStore {
    public function get( $code, $key ) {
        return null;
    }

    public function startWrite( $code ) {
    }

    public function finishWrite() {
    }

    public function set( $key, $value ) {
    }
}

class LocalisationCacheBulkLoad extends LocalisationCache {
    private $fileCache = array();

    private $mruLangs = array();

    private $maxLoadedLangs = 10;

    protected function readPHPFile( $fileName, $fileType ) {
        $serialize = $fileType === 'core';
        if ( !isset( $this->fileCache[$fileName][$fileType] ) ) {
            $data = parent::readPHPFile( $fileName, $fileType );

            if ( $serialize ) {
                $encData = serialize( $data );
            } else {
                $encData = $data;
            }

            $this->fileCache[$fileName][$fileType] = $encData;

            return $data;
        } elseif ( $serialize ) {
            return unserialize( $this->fileCache[$fileName][$fileType] );
        } else {
            return $this->fileCache[$fileName][$fileType];
        }
    }

    public function getItem( $code, $key ) {
        unset( $this->mruLangs[$code] );
        $this->mruLangs[$code] = true;

        return parent::getItem( $code, $key );
    }

    public function getSubitem( $code, $key, $subkey ) {
        unset( $this->mruLangs[$code] );
        $this->mruLangs[$code] = true;

        return parent::getSubitem( $code, $key, $subkey );
    }

    public function recache( $code ) {
        parent::recache( $code );
        unset( $this->mruLangs[$code] );
        $this->mruLangs[$code] = true;
        $this->trimCache();
    }

    public function unload( $code ) {
        unset( $this->mruLangs[$code] );
        parent::unload( $code );
    }

    protected function trimCache() {
        while ( count( $this->data ) > $this->maxLoadedLangs && count( $this->mruLangs ) ) {
            reset( $this->mruLangs );
            $code = key( $this->mruLangs );
            wfDebug( __METHOD__ . ": unloading $code\n" );
            $this->unload( $code );
        }
    }
}