Export.php

Go to the documentation of this file.

<?php
class WikiExporter {
    public $list_authors = false;

    public $dumpUploads = false;

    public $dumpUploadFileContents = false;

    public $author_list = "";

    const FULL = 1;
    const CURRENT = 2;
    const STABLE = 4; // extension defined
    const LOGS = 8;
    const RANGE = 16;

    const BUFFER = 0;
    const STREAM = 1;

    const TEXT = 0;
    const STUB = 1;

    public $buffer;

    public $text;

    public $sink;

    public static function schemaVersion() {
        return "0.9";
    }

    function __construct( $db, $history = WikiExporter::CURRENT,
            $buffer = WikiExporter::BUFFER, $text = WikiExporter::TEXT ) {
        $this->db = $db;
        $this->history = $history;
        $this->buffer = $buffer;
        $this->writer = new XmlDumpWriter();
        $this->sink = new DumpOutput();
        $this->text = $text;
    }

    public function setOutputSink( &$sink ) {
        $this->sink =& $sink;
    }

    public function openStream() {
        $output = $this->writer->openStream();
        $this->sink->writeOpenStream( $output );
    }

    public function closeStream() {
        $output = $this->writer->closeStream();
        $this->sink->writeCloseStream( $output );
    }

    public function allPages() {
        $this->dumpFrom( '' );
    }

    public function pagesByRange( $start, $end ) {
        $condition = 'page_id >= ' . intval( $start );
        if ( $end ) {
            $condition .= ' AND page_id < ' . intval( $end );
        }
        $this->dumpFrom( $condition );
    }

    public function revsByRange( $start, $end ) {
        $condition = 'rev_id >= ' . intval( $start );
        if ( $end ) {
            $condition .= ' AND rev_id < ' . intval( $end );
        }
        $this->dumpFrom( $condition );
    }

    public function pageByTitle( $title ) {
        $this->dumpFrom(
            'page_namespace=' . $title->getNamespace() .
            ' AND page_title=' . $this->db->addQuotes( $title->getDBkey() ) );
    }

    public function pageByName( $name ) {
        $title = Title::newFromText( $name );
        if ( is_null( $title ) ) {
            throw new MWException( "Can't export invalid title" );
        } else {
            $this->pageByTitle( $title );
        }
    }

    public function pagesByName( $names ) {
        foreach ( $names as $name ) {
            $this->pageByName( $name );
        }
    }

    public function allLogs() {
        $this->dumpFrom( '' );
    }

    public function logsByRange( $start, $end ) {
        $condition = 'log_id >= ' . intval( $start );
        if ( $end ) {
            $condition .= ' AND log_id < ' . intval( $end );
        }
        $this->dumpFrom( $condition );
    }

    protected function do_list_authors( $cond ) {
        wfProfileIn( __METHOD__ );
        $this->author_list = "<contributors>";
        // rev_deleted

        $res = $this->db->select(
            array( 'page', 'revision' ),
            array( 'DISTINCT rev_user_text', 'rev_user' ),
            array(
                $this->db->bitAnd( 'rev_deleted', Revision::DELETED_USER ) . ' = 0',
                $cond,
                'page_id = rev_id',
            ),
            __METHOD__
        );

        foreach ( $res as $row ) {
            $this->author_list .= "<contributor>" .
                "<username>" .
                htmlentities( $row->rev_user_text ) .
                "</username>" .
                "<id>" .
                $row->rev_user .
                "</id>" .
                "</contributor>";
        }
        $this->author_list .= "</contributors>";
        wfProfileOut( __METHOD__ );
    }

    protected function dumpFrom( $cond = '' ) {
        wfProfileIn( __METHOD__ );
        # For logging dumps...
        if ( $this->history & self::LOGS ) {
            $where = array( 'user_id = log_user' );
            # Hide private logs
            $hideLogs = LogEventsList::getExcludeClause( $this->db );
            if ( $hideLogs ) {
                $where[] = $hideLogs;
            }
            # Add on any caller specified conditions
            if ( $cond ) {
                $where[] = $cond;
            }
            # Get logging table name for logging.* clause
            $logging = $this->db->tableName( 'logging' );

            if ( $this->buffer == WikiExporter::STREAM ) {
                $prev = $this->db->bufferResults( false );
            }
            $result = null; // Assuring $result is not undefined, if exception occurs early
            try {
                $result = $this->db->select( array( 'logging', 'user' ),
                    array( "{$logging}.*", 'user_name' ), // grab the user name
                    $where,
                    __METHOD__,
                    array( 'ORDER BY' => 'log_id', 'USE INDEX' => array( 'logging' => 'PRIMARY' ) )
                );
                $this->outputLogStream( $result );
                if ( $this->buffer == WikiExporter::STREAM ) {
                    $this->db->bufferResults( $prev );
                }
            } catch ( Exception $e ) {
                // Throwing the exception does not reliably free the resultset, and
                // would also leave the connection in unbuffered mode.

                // Freeing result
                try {
                    if ( $result ) {
                        $result->free();
                    }
                } catch ( Exception $e2 ) {
                    // Already in panic mode -> ignoring $e2 as $e has
                    // higher priority
                }

                // Putting database back in previous buffer mode
                try {
                    if ( $this->buffer == WikiExporter::STREAM ) {
                        $this->db->bufferResults( $prev );
                    }
                } catch ( Exception $e2 ) {
                    // Already in panic mode -> ignoring $e2 as $e has
                    // higher priority
                }

                // Inform caller about problem
                wfProfileOut( __METHOD__ );
                throw $e;
            }
        # For page dumps...
        } else {
            $tables = array( 'page', 'revision' );
            $opts = array( 'ORDER BY' => 'page_id ASC' );
            $opts['USE INDEX'] = array();
            $join = array();
            if ( is_array( $this->history ) ) {
                # Time offset/limit for all pages/history...
                $revJoin = 'page_id=rev_page';
                # Set time order
                if ( $this->history['dir'] == 'asc' ) {
                    $op = '>';
                    $opts['ORDER BY'] = 'rev_timestamp ASC';
                } else {
                    $op = '<';
                    $opts['ORDER BY'] = 'rev_timestamp DESC';
                }
                # Set offset
                if ( !empty( $this->history['offset'] ) ) {
                    $revJoin .= " AND rev_timestamp $op " .
                        $this->db->addQuotes( $this->db->timestamp( $this->history['offset'] ) );
                }
                $join['revision'] = array( 'INNER JOIN', $revJoin );
                # Set query limit
                if ( !empty( $this->history['limit'] ) ) {
                    $opts['LIMIT'] = intval( $this->history['limit'] );
                }
            } elseif ( $this->history & WikiExporter::FULL ) {
                # Full history dumps...
                $join['revision'] = array( 'INNER JOIN', 'page_id=rev_page' );
            } elseif ( $this->history & WikiExporter::CURRENT ) {
                # Latest revision dumps...
                if ( $this->list_authors && $cond != '' ) { // List authors, if so desired
                    $this->do_list_authors( $cond );
                }
                $join['revision'] = array( 'INNER JOIN', 'page_id=rev_page AND page_latest=rev_id' );
            } elseif ( $this->history & WikiExporter::STABLE ) {
                # "Stable" revision dumps...
                # Default JOIN, to be overridden...
                $join['revision'] = array( 'INNER JOIN', 'page_id=rev_page AND page_latest=rev_id' );
                # One, and only one hook should set this, and return false
                if ( wfRunHooks( 'WikiExporter::dumpStableQuery', array( &$tables, &$opts, &$join ) ) ) {
                    wfProfileOut( __METHOD__ );
                    throw new MWException( __METHOD__ . " given invalid history dump type." );
                }
            } elseif ( $this->history & WikiExporter::RANGE ) {
                # Dump of revisions within a specified range
                $join['revision'] = array( 'INNER JOIN', 'page_id=rev_page' );
                $opts['ORDER BY'] = array( 'rev_page ASC', 'rev_id ASC' );
            } else {
                # Unknown history specification parameter?
                wfProfileOut( __METHOD__ );
                throw new MWException( __METHOD__ . " given invalid history dump type." );
            }
            # Query optimization hacks
            if ( $cond == '' ) {
                $opts[] = 'STRAIGHT_JOIN';
                $opts['USE INDEX']['page'] = 'PRIMARY';
            }
            # Build text join options
            if ( $this->text != WikiExporter::STUB ) { // 1-pass
                $tables[] = 'text';
                $join['text'] = array( 'INNER JOIN', 'rev_text_id=old_id' );
            }

            if ( $this->buffer == WikiExporter::STREAM ) {
                $prev = $this->db->bufferResults( false );
            }

            $result = null; // Assuring $result is not undefined, if exception occurs early
            try {
                wfRunHooks( 'ModifyExportQuery',
                        array( $this->db, &$tables, &$cond, &$opts, &$join ) );

                # Do the query!
                $result = $this->db->select( $tables, '*', $cond, __METHOD__, $opts, $join );
                # Output dump results
                $this->outputPageStream( $result );

                if ( $this->buffer == WikiExporter::STREAM ) {
                    $this->db->bufferResults( $prev );
                }
            } catch ( Exception $e ) {
                // Throwing the exception does not reliably free the resultset, and
                // would also leave the connection in unbuffered mode.

                // Freeing result
                try {
                    if ( $result ) {
                        $result->free();
                    }
                } catch ( Exception $e2 ) {
                    // Already in panic mode -> ignoring $e2 as $e has
                    // higher priority
                }

                // Putting database back in previous buffer mode
                try {
                    if ( $this->buffer == WikiExporter::STREAM ) {
                        $this->db->bufferResults( $prev );
                    }
                } catch ( Exception $e2 ) {
                    // Already in panic mode -> ignoring $e2 as $e has
                    // higher priority
                }

                // Inform caller about problem
                throw $e;
            }
        }
        wfProfileOut( __METHOD__ );
    }

    protected function outputPageStream( $resultset ) {
        $last = null;
        foreach ( $resultset as $row ) {
            if ( $last === null ||
                $last->page_namespace != $row->page_namespace ||
                $last->page_title != $row->page_title ) {
                if ( $last !== null ) {
                    $output = '';
                    if ( $this->dumpUploads ) {
                        $output .= $this->writer->writeUploads( $last, $this->dumpUploadFileContents );
                    }
                    $output .= $this->writer->closePage();
                    $this->sink->writeClosePage( $output );
                }
                $output = $this->writer->openPage( $row );
                $this->sink->writeOpenPage( $row, $output );
                $last = $row;
            }
            $output = $this->writer->writeRevision( $row );
            $this->sink->writeRevision( $row, $output );
        }
        if ( $last !== null ) {
            $output = '';
            if ( $this->dumpUploads ) {
                $output .= $this->writer->writeUploads( $last, $this->dumpUploadFileContents );
            }
            $output .= $this->author_list;
            $output .= $this->writer->closePage();
            $this->sink->writeClosePage( $output );
        }
    }

    protected function outputLogStream( $resultset ) {
        foreach ( $resultset as $row ) {
            $output = $this->writer->writeLogItem( $row );
            $this->sink->writeLogItem( $row, $output );
        }
    }
}

class XmlDumpWriter {
    function schemaVersion() {
        wfDeprecated( __METHOD__, '1.20' );
        return WikiExporter::schemaVersion();
    }

    function openStream() {
        global $wgLanguageCode;
        $ver = WikiExporter::schemaVersion();
        return Xml::element( 'mediawiki', array(
            'xmlns'              => "http://www.mediawiki.org/xml/export-$ver/",
            'xmlns:xsi'          => "http://www.w3.org/2001/XMLSchema-instance",
            /*
             * When a new version of the schema is created, it needs staging on mediawiki.org.
             * This requires a change in the operations/mediawiki-config git repo.
             *
             * Create a changeset like https://gerrit.wikimedia.org/r/#/c/149643/ in which
             * you copy in the new xsd file.
             *
             * After it is reviewed, merged and deployed (sync-docroot), the index.html needs purging.
             * echo "http://www.mediawiki.org/xml/index.html" | mwscript purgeList.php --wiki=aawiki
             */
            'xsi:schemaLocation' => "http://www.mediawiki.org/xml/export-$ver/ " .
                "http://www.mediawiki.org/xml/export-$ver.xsd",
            'version'            => $ver,
            'xml:lang'           => $wgLanguageCode ),
            null ) .
            "\n" .
            $this->siteInfo();
    }

    function siteInfo() {
        $info = array(
            $this->sitename(),
            $this->dbname(),
            $this->homelink(),
            $this->generator(),
            $this->caseSetting(),
            $this->namespaces() );
        return "  <siteinfo>\n    " .
            implode( "\n    ", $info ) .
            "\n  </siteinfo>\n";
    }

    function sitename() {
        global $wgSitename;
        return Xml::element( 'sitename', array(), $wgSitename );
    }

    function dbname() {
        global $wgDBname;
        return Xml::element( 'dbname', array(), $wgDBname );
    }

    function generator() {
        global $wgVersion;
        return Xml::element( 'generator', array(), "MediaWiki $wgVersion" );
    }

    function homelink() {
        return Xml::element( 'base', array(), Title::newMainPage()->getCanonicalURL() );
    }

    function caseSetting() {
        global $wgCapitalLinks;
        // "case-insensitive" option is reserved for future
        $sensitivity = $wgCapitalLinks ? 'first-letter' : 'case-sensitive';
        return Xml::element( 'case', array(), $sensitivity );
    }

    function namespaces() {
        global $wgContLang;
        $spaces = "<namespaces>\n";
        foreach ( $wgContLang->getFormattedNamespaces() as $ns => $title ) {
            $spaces .= '      ' .
                Xml::element( 'namespace',
                    array(
                        'key' => $ns,
                        'case' => MWNamespace::isCapitalized( $ns ) ? 'first-letter' : 'case-sensitive',
                    ), $title ) . "\n";
        }
        $spaces .= "    </namespaces>";
        return $spaces;
    }

    function closeStream() {
        return "</mediawiki>\n";
    }

    public function openPage( $row ) {
        $out = "  <page>\n";
        $title = Title::makeTitle( $row->page_namespace, $row->page_title );
        $out .= '    ' . Xml::elementClean( 'title', array(), self::canonicalTitle( $title ) ) . "\n";
        $out .= '    ' . Xml::element( 'ns', array(), strval( $row->page_namespace ) ) . "\n";
        $out .= '    ' . Xml::element( 'id', array(), strval( $row->page_id ) ) . "\n";
        if ( $row->page_is_redirect ) {
            $page = WikiPage::factory( $title );
            $redirect = $page->getRedirectTarget();
            if ( $redirect instanceof Title && $redirect->isValidRedirectTarget() ) {
                $out .= '    ';
                $out .= Xml::element( 'redirect', array( 'title' => self::canonicalTitle( $redirect ) ) );
                $out .= "\n";
            }
        }

        if ( $row->page_restrictions != '' ) {
            $out .= '    ' . Xml::element( 'restrictions', array(),
                strval( $row->page_restrictions ) ) . "\n";
        }

        wfRunHooks( 'XmlDumpWriterOpenPage', array( $this, &$out, $row, $title ) );

        return $out;
    }

    function closePage() {
        return "  </page>\n";
    }

    function writeRevision( $row ) {
        wfProfileIn( __METHOD__ );

        $out = "    <revision>\n";
        $out .= "      " . Xml::element( 'id', null, strval( $row->rev_id ) ) . "\n";
        if ( isset( $row->rev_parent_id ) && $row->rev_parent_id ) {
            $out .= "      " . Xml::element( 'parentid', null, strval( $row->rev_parent_id ) ) . "\n";
        }

        $out .= $this->writeTimestamp( $row->rev_timestamp );

        if ( isset( $row->rev_deleted ) && ( $row->rev_deleted & Revision::DELETED_USER ) ) {
            $out .= "      " . Xml::element( 'contributor', array( 'deleted' => 'deleted' ) ) . "\n";
        } else {
            $out .= $this->writeContributor( $row->rev_user, $row->rev_user_text );
        }

        if ( isset( $row->rev_minor_edit ) && $row->rev_minor_edit ) {
            $out .= "      <minor/>\n";
        }
        if ( isset( $row->rev_deleted ) && ( $row->rev_deleted & Revision::DELETED_COMMENT ) ) {
            $out .= "      " . Xml::element( 'comment', array( 'deleted' => 'deleted' ) ) . "\n";
        } elseif ( $row->rev_comment != '' ) {
            $out .= "      " . Xml::elementClean( 'comment', array(), strval( $row->rev_comment ) ) . "\n";
        }

        if ( isset( $row->rev_content_model ) && !is_null( $row->rev_content_model ) ) {
            $content_model = strval( $row->rev_content_model );
        } else {
            // probably using $wgContentHandlerUseDB = false;
            $title = Title::makeTitle( $row->page_namespace, $row->page_title );
            $content_model = ContentHandler::getDefaultModelFor( $title );
        }

        $content_handler = ContentHandler::getForModelID( $content_model );

        if ( isset( $row->rev_content_format ) && !is_null( $row->rev_content_format ) ) {
            $content_format = strval( $row->rev_content_format );
        } else {
            // probably using $wgContentHandlerUseDB = false;
            $content_format = $content_handler->getDefaultFormat();
        }

        $text = '';
        if ( isset( $row->rev_deleted ) && ( $row->rev_deleted & Revision::DELETED_TEXT ) ) {
            $out .= "      " . Xml::element( 'text', array( 'deleted' => 'deleted' ) ) . "\n";
        } elseif ( isset( $row->old_text ) ) {
            // Raw text from the database may have invalid chars
            $text = strval( Revision::getRevisionText( $row ) );
            $text = $content_handler->exportTransform( $text, $content_format );
            $out .= "      " . Xml::elementClean( 'text',
                array( 'xml:space' => 'preserve', 'bytes' => intval( $row->rev_len ) ),
                strval( $text ) ) . "\n";
        } else {
            // Stub output
            $out .= "      " . Xml::element( 'text',
                array( 'id' => $row->rev_text_id, 'bytes' => intval( $row->rev_len ) ),
                "" ) . "\n";
        }

        if ( isset( $row->rev_sha1 )
            && $row->rev_sha1
            && !( $row->rev_deleted & Revision::DELETED_TEXT )
        ) {
            $out .= "      " . Xml::element( 'sha1', null, strval( $row->rev_sha1 ) ) . "\n";
        } else {
            $out .= "      <sha1/>\n";
        }

        $out .= "      " . Xml::element( 'model', null, strval( $content_model ) ) . "\n";
        $out .= "      " . Xml::element( 'format', null, strval( $content_format ) ) . "\n";

        wfRunHooks( 'XmlDumpWriterWriteRevision', array( &$this, &$out, $row, $text ) );

        $out .= "    </revision>\n";

        wfProfileOut( __METHOD__ );
        return $out;
    }

    function writeLogItem( $row ) {
        wfProfileIn( __METHOD__ );

        $out = "  <logitem>\n";
        $out .= "    " . Xml::element( 'id', null, strval( $row->log_id ) ) . "\n";

        $out .= $this->writeTimestamp( $row->log_timestamp, "    " );

        if ( $row->log_deleted & LogPage::DELETED_USER ) {
            $out .= "    " . Xml::element( 'contributor', array( 'deleted' => 'deleted' ) ) . "\n";
        } else {
            $out .= $this->writeContributor( $row->log_user, $row->user_name, "    " );
        }

        if ( $row->log_deleted & LogPage::DELETED_COMMENT ) {
            $out .= "    " . Xml::element( 'comment', array( 'deleted' => 'deleted' ) ) . "\n";
        } elseif ( $row->log_comment != '' ) {
            $out .= "    " . Xml::elementClean( 'comment', null, strval( $row->log_comment ) ) . "\n";
        }

        $out .= "    " . Xml::element( 'type', null, strval( $row->log_type ) ) . "\n";
        $out .= "    " . Xml::element( 'action', null, strval( $row->log_action ) ) . "\n";

        if ( $row->log_deleted & LogPage::DELETED_ACTION ) {
            $out .= "    " . Xml::element( 'text', array( 'deleted' => 'deleted' ) ) . "\n";
        } else {
            $title = Title::makeTitle( $row->log_namespace, $row->log_title );
            $out .= "    " . Xml::elementClean( 'logtitle', null, self::canonicalTitle( $title ) ) . "\n";
            $out .= "    " . Xml::elementClean( 'params',
                array( 'xml:space' => 'preserve' ),
                strval( $row->log_params ) ) . "\n";
        }

        $out .= "  </logitem>\n";

        wfProfileOut( __METHOD__ );
        return $out;
    }

    function writeTimestamp( $timestamp, $indent = "      " ) {
        $ts = wfTimestamp( TS_ISO_8601, $timestamp );
        return $indent . Xml::element( 'timestamp', null, $ts ) . "\n";
    }

    function writeContributor( $id, $text, $indent = "      " ) {
        $out = $indent . "<contributor>\n";
        if ( $id || !IP::isValid( $text ) ) {
            $out .= $indent . "  " . Xml::elementClean( 'username', null, strval( $text ) ) . "\n";
            $out .= $indent . "  " . Xml::element( 'id', null, strval( $id ) ) . "\n";
        } else {
            $out .= $indent . "  " . Xml::elementClean( 'ip', null, strval( $text ) ) . "\n";
        }
        $out .= $indent . "</contributor>\n";
        return $out;
    }

    function writeUploads( $row, $dumpContents = false ) {
        if ( $row->page_namespace == NS_FILE ) {
            $img = wfLocalFile( $row->page_title );
            if ( $img && $img->exists() ) {
                $out = '';
                foreach ( array_reverse( $img->getHistory() ) as $ver ) {
                    $out .= $this->writeUpload( $ver, $dumpContents );
                }
                $out .= $this->writeUpload( $img, $dumpContents );
                return $out;
            }
        }
        return '';
    }

    function writeUpload( $file, $dumpContents = false ) {
        if ( $file->isOld() ) {
            $archiveName = "      " .
                Xml::element( 'archivename', null, $file->getArchiveName() ) . "\n";
        } else {
            $archiveName = '';
        }
        if ( $dumpContents ) {
            $be = $file->getRepo()->getBackend();
            # Dump file as base64
            # Uses only XML-safe characters, so does not need escaping
            # @todo Too bad this loads the contents into memory (script might swap)
            $contents = '      <contents encoding="base64">' .
                chunk_split( base64_encode(
                    $be->getFileContents( array( 'src' => $file->getPath() ) ) ) ) .
                "      </contents>\n";
        } else {
            $contents = '';
        }
        if ( $file->isDeleted( File::DELETED_COMMENT ) ) {
            $comment = Xml::element( 'comment', array( 'deleted' => 'deleted' ) );
        } else {
            $comment = Xml::elementClean( 'comment', null, $file->getDescription() );
        }
        return "    <upload>\n" .
            $this->writeTimestamp( $file->getTimestamp() ) .
            $this->writeContributor( $file->getUser( 'id' ), $file->getUser( 'text' ) ) .
            "      " . $comment . "\n" .
            "      " . Xml::element( 'filename', null, $file->getName() ) . "\n" .
            $archiveName .
            "      " . Xml::element( 'src', null, $file->getCanonicalURL() ) . "\n" .
            "      " . Xml::element( 'size', null, $file->getSize() ) . "\n" .
            "      " . Xml::element( 'sha1base36', null, $file->getSha1() ) . "\n" .
            "      " . Xml::element( 'rel', null, $file->getRel() ) . "\n" .
            $contents .
            "    </upload>\n";
    }

    public static function canonicalTitle( Title $title ) {
        if ( $title->isExternal() ) {
            return $title->getPrefixedText();
        }

        global $wgContLang;
        $prefix = str_replace( '_', ' ', $wgContLang->getNsText( $title->getNamespace() ) );

        if ( $prefix !== '' ) {
            $prefix .= ':';
        }

        return $prefix . $title->getText();
    }
}

class DumpOutput {

    function writeOpenStream( $string ) {
        $this->write( $string );
    }

    function writeCloseStream( $string ) {
        $this->write( $string );
    }

    function writeOpenPage( $page, $string ) {
        $this->write( $string );
    }

    function writeClosePage( $string ) {
        $this->write( $string );
    }

    function writeRevision( $rev, $string ) {
        $this->write( $string );
    }

    function writeLogItem( $rev, $string ) {
        $this->write( $string );
    }

    function write( $string ) {
        print $string;
    }

    function closeRenameAndReopen( $newname ) {
    }

    function closeAndRename( $newname, $open = false ) {
    }

    function getFilenames() {
        return null;
    }
}

class DumpFileOutput extends DumpOutput {
    protected $handle = false, $filename;

    function __construct( $file ) {
        $this->handle = fopen( $file, "wt" );
        $this->filename = $file;
    }

    function writeCloseStream( $string ) {
        parent::writeCloseStream( $string );
        if ( $this->handle ) {
            fclose( $this->handle );
            $this->handle = false;
        }
    }

    function write( $string ) {
        fputs( $this->handle, $string );
    }

    function closeRenameAndReopen( $newname ) {
        $this->closeAndRename( $newname, true );
    }

    function renameOrException( $newname ) {
            if ( !rename( $this->filename, $newname ) ) {
                throw new MWException( __METHOD__ . ": rename of file {$this->filename} to $newname failed\n" );
            }
    }

    function checkRenameArgCount( $newname ) {
        if ( is_array( $newname ) ) {
            if ( count( $newname ) > 1 ) {
                throw new MWException( __METHOD__ . ": passed multiple arguments for rename of single file\n" );
            } else {
                $newname = $newname[0];
            }
        }
        return $newname;
    }

    function closeAndRename( $newname, $open = false ) {
        $newname = $this->checkRenameArgCount( $newname );
        if ( $newname ) {
            if ( $this->handle ) {
                fclose( $this->handle );
                $this->handle = false;
            }
            $this->renameOrException( $newname );
            if ( $open ) {
                $this->handle = fopen( $this->filename, "wt" );
            }
        }
    }

    function getFilenames() {
        return $this->filename;
    }
}

class DumpPipeOutput extends DumpFileOutput {
    protected $command, $filename;
    protected $procOpenResource = false;

    function __construct( $command, $file = null ) {
        if ( !is_null( $file ) ) {
            $command .= " > " . wfEscapeShellArg( $file );
        }

        $this->startCommand( $command );
        $this->command = $command;
        $this->filename = $file;
    }

    function writeCloseStream( $string ) {
        parent::writeCloseStream( $string );
        if ( $this->procOpenResource ) {
            proc_close( $this->procOpenResource );
            $this->procOpenResource = false;
        }
    }

    function startCommand( $command ) {
        $spec = array(
            0 => array( "pipe", "r" ),
        );
        $pipes = array();
        $this->procOpenResource = proc_open( $command, $spec, $pipes );
        $this->handle = $pipes[0];
    }

    function closeRenameAndReopen( $newname ) {
        $this->closeAndRename( $newname, true );
    }

    function closeAndRename( $newname, $open = false ) {
        $newname = $this->checkRenameArgCount( $newname );
        if ( $newname ) {
            if ( $this->handle ) {
                fclose( $this->handle );
                $this->handle = false;
            }
            if ( $this->procOpenResource ) {
                proc_close( $this->procOpenResource );
                $this->procOpenResource = false;
            }
            $this->renameOrException( $newname );
            if ( $open ) {
                $command = $this->command;
                $command .= " > " . wfEscapeShellArg( $this->filename );
                $this->startCommand( $command );
            }
        }
    }
}

class DumpGZipOutput extends DumpPipeOutput {
    function __construct( $file ) {
        parent::__construct( "gzip", $file );
    }
}

class DumpBZip2Output extends DumpPipeOutput {
    function __construct( $file ) {
        parent::__construct( "bzip2", $file );
    }
}

class Dump7ZipOutput extends DumpPipeOutput {
    function __construct( $file ) {
        $command = $this->setup7zCommand( $file );
        parent::__construct( $command );
        $this->filename = $file;
    }

    function setup7zCommand( $file ) {
        $command = "7za a -bd -si " . wfEscapeShellArg( $file );
        // Suppress annoying useless crap from p7zip
        // Unfortunately this could suppress real error messages too
        $command .= ' >' . wfGetNull() . ' 2>&1';
        return $command;
    }

    function closeAndRename( $newname, $open = false ) {
        $newname = $this->checkRenameArgCount( $newname );
        if ( $newname ) {
            fclose( $this->handle );
            proc_close( $this->procOpenResource );
            $this->renameOrException( $newname );
            if ( $open ) {
                $command = $this->setup7zCommand( $this->filename );
                $this->startCommand( $command );
            }
        }
    }
}

class DumpFilter {
    public $sink;

    protected $sendingThisPage;

    function __construct( &$sink ) {
        $this->sink =& $sink;
    }

    function writeOpenStream( $string ) {
        $this->sink->writeOpenStream( $string );
    }

    function writeCloseStream( $string ) {
        $this->sink->writeCloseStream( $string );
    }

    function writeOpenPage( $page, $string ) {
        $this->sendingThisPage = $this->pass( $page, $string );
        if ( $this->sendingThisPage ) {
            $this->sink->writeOpenPage( $page, $string );
        }
    }

    function writeClosePage( $string ) {
        if ( $this->sendingThisPage ) {
            $this->sink->writeClosePage( $string );
            $this->sendingThisPage = false;
        }
    }

    function writeRevision( $rev, $string ) {
        if ( $this->sendingThisPage ) {
            $this->sink->writeRevision( $rev, $string );
        }
    }

    function writeLogItem( $rev, $string ) {
        $this->sink->writeRevision( $rev, $string );
    }

    function closeRenameAndReopen( $newname ) {
        $this->sink->closeRenameAndReopen( $newname );
    }

    function closeAndRename( $newname, $open = false ) {
        $this->sink->closeAndRename( $newname, $open );
    }

    function getFilenames() {
        return $this->sink->getFilenames();
    }

    function pass( $page ) {
        return true;
    }
}

class DumpNotalkFilter extends DumpFilter {
    function pass( $page ) {
        return !MWNamespace::isTalk( $page->page_namespace );
    }
}

class DumpNamespaceFilter extends DumpFilter {
    public $invert = false;

    public $namespaces = array();

    function __construct( &$sink, $param ) {
        parent::__construct( $sink );

        $constants = array(
            "NS_MAIN"           => NS_MAIN,
            "NS_TALK"           => NS_TALK,
            "NS_USER"           => NS_USER,
            "NS_USER_TALK"      => NS_USER_TALK,
            "NS_PROJECT"        => NS_PROJECT,
            "NS_PROJECT_TALK"   => NS_PROJECT_TALK,
            "NS_FILE"           => NS_FILE,
            "NS_FILE_TALK"      => NS_FILE_TALK,
            "NS_IMAGE"          => NS_IMAGE, // NS_IMAGE is an alias for NS_FILE
            "NS_IMAGE_TALK"     => NS_IMAGE_TALK,
            "NS_MEDIAWIKI"      => NS_MEDIAWIKI,
            "NS_MEDIAWIKI_TALK" => NS_MEDIAWIKI_TALK,
            "NS_TEMPLATE"       => NS_TEMPLATE,
            "NS_TEMPLATE_TALK"  => NS_TEMPLATE_TALK,
            "NS_HELP"           => NS_HELP,
            "NS_HELP_TALK"      => NS_HELP_TALK,
            "NS_CATEGORY"       => NS_CATEGORY,
            "NS_CATEGORY_TALK"  => NS_CATEGORY_TALK );

        if ( $param { 0 } == '!' ) {
            $this->invert = true;
            $param = substr( $param, 1 );
        }

        foreach ( explode( ',', $param ) as $key ) {
            $key = trim( $key );
            if ( isset( $constants[$key] ) ) {
                $ns = $constants[$key];
                $this->namespaces[$ns] = true;
            } elseif ( is_numeric( $key ) ) {
                $ns = intval( $key );
                $this->namespaces[$ns] = true;
            } else {
                throw new MWException( "Unrecognized namespace key '$key'\n" );
            }
        }
    }

    function pass( $page ) {
        $match = isset( $this->namespaces[$page->page_namespace] );
        return $this->invert xor $match;
    }
}

class DumpLatestFilter extends DumpFilter {
    public $page;

    public $pageString;

    public $rev;

    public $revString;

    function writeOpenPage( $page, $string ) {
        $this->page = $page;
        $this->pageString = $string;
    }

    function writeClosePage( $string ) {
        if ( $this->rev ) {
            $this->sink->writeOpenPage( $this->page, $this->pageString );
            $this->sink->writeRevision( $this->rev, $this->revString );
            $this->sink->writeClosePage( $string );
        }
        $this->rev = null;
        $this->revString = null;
        $this->page = null;
        $this->pageString = null;
    }

    function writeRevision( $rev, $string ) {
        if ( $rev->rev_id == $this->page->page_latest ) {
            $this->rev = $rev;
            $this->revString = $string;
        }
    }
}

class DumpMultiWriter {

    function __construct( $sinks ) {
        $this->sinks = $sinks;
        $this->count = count( $sinks );
    }

    function writeOpenStream( $string ) {
        for ( $i = 0; $i < $this->count; $i++ ) {
            $this->sinks[$i]->writeOpenStream( $string );
        }
    }

    function writeCloseStream( $string ) {
        for ( $i = 0; $i < $this->count; $i++ ) {
            $this->sinks[$i]->writeCloseStream( $string );
        }
    }

    function writeOpenPage( $page, $string ) {
        for ( $i = 0; $i < $this->count; $i++ ) {
            $this->sinks[$i]->writeOpenPage( $page, $string );
        }
    }

    function writeClosePage( $string ) {
        for ( $i = 0; $i < $this->count; $i++ ) {
            $this->sinks[$i]->writeClosePage( $string );
        }
    }

    function writeRevision( $rev, $string ) {
        for ( $i = 0; $i < $this->count; $i++ ) {
            $this->sinks[$i]->writeRevision( $rev, $string );
        }
    }

    function closeRenameAndReopen( $newnames ) {
        $this->closeAndRename( $newnames, true );
    }

    function closeAndRename( $newnames, $open = false ) {
        for ( $i = 0; $i < $this->count; $i++ ) {
            $this->sinks[$i]->closeAndRename( $newnames[$i], $open );
        }
    }

    function getFilenames() {
        $filenames = array();
        for ( $i = 0; $i < $this->count; $i++ ) {
            $filenames[] = $this->sinks[$i]->getFilenames();
        }
        return $filenames;
    }
}