MessageIndex.php

Go to the documentation of this file.

<?php
abstract class MessageIndex {
    protected static $instance;

    public static function singleton() {
        if ( self::$instance === null ) {
            global $wgTranslateMessageIndex;
            $params = $wgTranslateMessageIndex;
            $class = array_shift( $params );
            self::$instance = new $class( $params );
        }

        return self::$instance;
    }

    public static function getGroupIds( MessageHandle $handle ) {
        $namespace = $handle->getTitle()->getNamespace();
        $key = $handle->getKey();
        $normkey = TranslateUtils::normaliseKey( $namespace, $key );

        $value = self::singleton()->get( $normkey );
        if ( $value !== null ) {
            return (array)$value;
        } else {
            return array();
        }
    }

    public static function getPrimaryGroupId( MessageHandle $handle ) {
        $groups = self::getGroupIds( $handle );

        return count( $groups ) ? array_shift( $groups ) : null;
    }

    protected function get( $key ) {
        // Default implementation
        $mi = $this->retrieve();
        if ( isset( $mi[$key] ) ) {
            return $mi[$key];
        } else {
            return null;
        }
    }

    abstract public function retrieve();

    abstract protected function store( array $array );

    public function rebuild() {
        static $recursion = 0;

        if ( $recursion > 0 ) {
            $msg = __METHOD__ . ': trying to recurse - building the index first time?';
            wfWarn( $msg );

            return array();
        }
        $recursion++;

        $groups = MessageGroups::singleton()->getGroups();

        $new = $old = array();
        $old = $this->retrieve();
        $postponed = array();

        foreach ( $groups as $g ) {
            if ( !$g->exists() ) {
                continue;
            }

            # Skip meta thingies
            if ( $g->isMeta() ) {
                $postponed[] = $g;
                continue;
            }

            $this->checkAndAdd( $new, $g );
        }

        foreach ( $postponed as $g ) {
            $this->checkAndAdd( $new, $g, true );
        }

        $this->store( $new );
        $this->clearMessageGroupStats( $old, $new );
        $recursion--;

        return $new;
    }

    protected function clearMessageGroupStats( array $old, array $new ) {
        $changes = array();

        foreach ( $new as $key => $groups ) {
            // Using != here on purpose to ignore order of items
            if ( !isset( $old[$key] ) ) {
                $changes[$key] = array( array(), (array)$groups );
            } elseif ( $groups != $old[$key] ) {
                $changes[$key] = array( (array)$old[$key], (array)$groups );
            }
        }

        foreach ( $old as $key => $groups ) {
            if ( !isset( $new[$key] ) ) {
                $changes[$key] = array( (array)$groups, array() );
            }
            // We already checked for diffs above
        }

        $changedGroups = array();
        foreach ( $changes as $data ) {
            foreach ( $data[0] as $group ) {
                $changedGroups[$group] = true;
            }
            foreach ( $data[1] as $group ) {
                $changedGroups[$group] = true;
            }
        }

        MessageGroupStats::clearGroup( array_keys( $changedGroups ) );

        foreach ( $changes as $key => $data ) {
            list( $ns, $pagename ) = explode( ':', $key, 2 );
            $title = Title::makeTitle( $ns, $pagename );
            $handle = new MessageHandle( $title );
            list ( $oldGroups, $newGroups ) = $data;
            wfRunHooks( 'TranslateEventMessageMembershipChange',
                array( $handle, $oldGroups, $newGroups ) );
        }
    }

    protected function checkAndAdd( &$hugearray, MessageGroup $g, $ignore = false ) {
        if ( method_exists( $g, 'getKeys' ) ) {
            $keys = $g->getKeys();
        } else {
            $messages = $g->getDefinitions();

            if ( !is_array( $messages ) ) {
                return;
            }

            $keys = array_keys( $messages );
        }

        $id = $g->getId();

        $namespace = $g->getNamespace();

        foreach ( $keys as $key ) {
            # Force all keys to lower case, because the case doesn't matter and it is
            # easier to do comparing when the case of first letter is unknown, because
            # mediawiki forces it to upper case
            $key = TranslateUtils::normaliseKey( $namespace, $key );
            if ( isset( $hugearray[$key] ) ) {
                if ( !$ignore ) {
                    $to = implode( ', ', (array)$hugearray[$key] );
                    wfWarn( "Key $key already belongs to $to, conflict with $id" );
                }

                if ( is_array( $hugearray[$key] ) ) {
                    // Hard work is already done, just add a new reference
                    $hugearray[$key][] = & $id;
                } else {
                    // Store the actual reference, then remove it from array, to not
                    // replace the references value, but to store an array of new
                    // references instead. References are hard!
                    $value = & $hugearray[$key];
                    unset( $hugearray[$key] );
                    $hugearray[$key] = array( &$value, &$id );
                }
            } else {
                $hugearray[$key] = & $id;
            }
        }
        unset( $id ); // Disconnect the previous references to this $id
    }

    /* These are probably slower than serialize and unserialize,
     * but they are more space efficient because we only need
     * strings and arrays. */
    protected function serialize( $data ) {
        if ( is_array( $data ) ) {
            return implode( '|', $data );
        } else {
            return $data;
        }
    }

    protected function unserialize( $data ) {
        if ( strpos( $data, '|' ) !== false ) {
            return explode( '|', $data );
        }

        return $data;
    }
}

class SerializedMessageIndex extends MessageIndex {
    protected $index;

    protected $filename = 'translate_messageindex.ser';

    public function retrieve() {
        if ( $this->index !== null ) {
            return $this->index;
        }

        wfProfileIn( __METHOD__ );
        $file = TranslateUtils::cacheFile( $this->filename );
        if ( file_exists( $file ) ) {
            $this->index = unserialize( file_get_contents( $file ) );
        } else {
            $this->index = $this->rebuild();
        }
        wfProfileOut( __METHOD__ );

        return $this->index;
    }

    protected function store( array $array ) {
        wfProfileIn( __METHOD__ );
        $file = TranslateUtils::cacheFile( $this->filename );
        file_put_contents( $file, serialize( $array ) );
        $this->index = $array;
        wfProfileOut( __METHOD__ );
    }
}

class FileCachedMessageIndex extends SerializedMessageIndex {
}

class DatabaseMessageIndex extends MessageIndex {
    protected $index;

    public function retrieve() {
        if ( $this->index !== null ) {
            return $this->index;
        }

        wfProfileIn( __METHOD__ );
        $dbr = wfGetDB( DB_SLAVE );
        $res = $dbr->select( 'translate_messageindex', '*', array(), __METHOD__ );
        $this->index = array();
        foreach ( $res as $row ) {
            $this->index[$row->tmi_key] = $this->unserialize( $row->tmi_value );
        }
        wfProfileOut( __METHOD__ );

        return $this->index;
    }

    protected function get( $key ) {
        wfProfileIn( __METHOD__ );
        $dbr = wfGetDB( DB_SLAVE );
        $value = $dbr->selectField(
            'translate_messageindex',
            'tmi_value',
            array( 'tmi_key' => $key ),
            __METHOD__
        );

        if ( is_string( $value ) ) {
            $value = $this->unserialize( $value );
        } else {
            $value = null;
        }

        wfProfileOut( __METHOD__ );

        return $value;
    }

    protected function store( array $array ) {
        wfProfileIn( __METHOD__ );
        $dbw = wfGetDB( DB_MASTER );
        $rows = array();

        foreach ( $array as $key => $value ) {
            $value = $this->serialize( $value );
            $rows[] = array( 'tmi_key' => $key, 'tmi_value' => $value );
        }

        $dbw->delete( 'translate_messageindex', '*', __METHOD__ );
        $dbw->replace( 'translate_messageindex', array( array( 'tmi_key' ) ), $rows, __METHOD__ );

        $this->index = $array;
        wfProfileOut( __METHOD__ );
    }
}

class CachedMessageIndex extends MessageIndex {
    protected $key = 'translate-messageindex';
    protected $cache;

    protected $index;

    protected function __construct( array $params ) {
        $this->cache = wfGetCache( CACHE_ANYTHING );
    }

    public function retrieve() {
        if ( $this->index !== null ) {
            return $this->index;
        }

        wfProfileIn( __METHOD__ );
        $key = wfMemckey( $this->key );
        $data = $this->cache->get( $key );
        if ( is_array( $data ) ) {
            $this->index = $data;
        } else {
            $this->index = $this->rebuild();
        }
        wfProfileOut( __METHOD__ );

        return $this->index;
    }

    protected function store( array $array ) {
        wfProfileIn( __METHOD__ );
        $key = wfMemckey( $this->key );
        $this->cache->set( $key, $array );

        $this->index = $array;
        wfProfileOut( __METHOD__ );
    }
}

class CDBMessageIndex extends MessageIndex {
    protected $index;

    protected $reader;

    protected $filename = 'translate_messageindex.cdb';

    public function retrieve() {
        $reader = $this->getReader();
        // This must be below the line above, which may fill the index
        if ( $this->index !== null ) {
            return $this->index;
        }

        wfProfileIn( __METHOD__ );
        $keys = (array)$this->unserialize( $reader->get( '#keys' ) );
        $this->index = array();
        foreach ( $keys as $key ) {
            $this->index[$key] = $this->unserialize( $reader->get( $key ) );
        }
        wfProfileOut( __METHOD__ );

        return $this->index;
    }

    protected function get( $key ) {
        $reader = $this->getReader();
        // We might have the full cache loaded
        if ( $this->index !== null ) {
            if ( isset( $this->index[$key] ) ) {
                return $this->index[$key];
            } else {
                return null;
            }
        }

        wfProfileIn( __METHOD__ );
        $value = $reader->get( $key );
        if ( !is_string( $value ) ) {
            $value = null;
        } else {
            $value = $this->unserialize( $value );
        }
        wfProfileOut( __METHOD__ );

        return $value;
    }

    protected function store( array $array ) {
        wfProfileIn( __METHOD__ );
        $this->reader = null;

        $file = TranslateUtils::cacheFile( $this->filename );
        $cache = CdbWriter::open( $file );
        $keys = array_keys( $array );
        $cache->set( '#keys', $this->serialize( $keys ) );

        foreach ( $array as $key => $value ) {
            $value = $this->serialize( $value );
            $cache->set( $key, $value );
        }

        $cache->close();

        $this->index = $array;
        wfProfileOut( __METHOD__ );
    }

    protected function getReader() {
        if ( $this->reader ) {
            return $this->reader;
        }

        $file = TranslateUtils::cacheFile( $this->filename );
        if ( !file_exists( $file ) ) {
            /* The rebuild() will call retrieve(), which we prevent from
             * recursing by setting the index to empty array now.
             */
            $this->index = array();
            $this->index = $this->rebuild();
        }

        return $this->reader = CdbReader::open( $file );
    }
}