includes/SpecialExport.php

   1 <?php
   2 # Copyright (C) 2003 Brion Vibber <brion@pobox.com>
   3 # http://www.mediawiki.org/
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License along
  16 # with this program; if not, write to the Free Software Foundation, Inc.,
  17 # 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 # http://www.gnu.org/copyleft/gpl.html
  19 /**
  20  *
  21  * @package MediaWiki
  22  * @subpackage SpecialPage
  23  */
  24
  25 /** */
  26 require_once( 'Revision.php' );
  27
  28 /**
  29  *
  30  */
  31 function wfSpecialExport( $page = '' ) {
  32         global $wgOut, $wgLang, $wgRequest;
  33
  34         if( $wgRequest->getVal( 'action' ) == 'submit') {
  35                 $page = $wgRequest->getText( 'pages' );
  36                 $curonly = $wgRequest->getCheck( 'curonly' );
  37         } else {
  38                 # Pre-check the 'current version only' box in the UI
  39                 $curonly = true;
  40         }
  41
  42         if( $page != '' ) {
  43                 $wgOut->disable();
  44                 header( "Content-type: application/xml; charset=utf-8" );
  45                 $pages = explode( "\n", $page );
  46
  47                 $db =& wfGetDB( DB_SLAVE );
  48                 $history = $curonly ? MW_EXPORT_CURRENT : MW_EXPORT_FULL;
  49                 $exporter = new WikiExporter( $db, $history );
  50                 $exporter->openStream();
  51                 $exporter->pagesByName( $pages );
  52                 $exporter->closeStream();
  53                 return;
  54         }
  55
  56         $wgOut->addWikiText( wfMsg( "exporttext" ) );
  57         $titleObj = Title::makeTitle( NS_SPECIAL, "Export" );
  58         $action = $titleObj->escapeLocalURL( 'action=submit' );
  59         $wgOut->addHTML( "
  60 <form method='post' action=\"$action\">
  61 <input type='hidden' name='action' value='submit' />
  62 <textarea name='pages' cols='40' rows='10'></textarea><br />
  63 <label><input type='checkbox' name='curonly' value='true' checked='checked' />
  64 " . wfMsgHtml( 'exportcuronly' ) . "</label><br />
  65 <input type='submit' />
  66 </form>
  67 " );
  68 }
  69
  70 define( 'MW_EXPORT_FULL',     0 );
  71 define( 'MW_EXPORT_CURRENT',  1 );
  72
  73 define( 'MW_EXPORT_BUFFER',   0 );
  74 define( 'MW_EXPORT_STREAM',   1 );
  75
  76 /**
  77  * @package MediaWiki
  78  * @subpackage SpecialPage
  79  */
  80 class WikiExporter {
  81         var $pageCallback = null;
  82         var $revCallback = null;
  83
  84         /**
  85          * If using MW_EXPORT_STREAM to stream a large amount of data,
  86          * provide a database connection which is not managed by
  87          * LoadBalancer to read from: some history blob types will
  88          * make additional queries to pull source data while the
  89          * main query is still running.
  90          *
  91          * @param Database $db
  92          * @param int $history one of MW_EXPORT_FULL or MW_EXPORT_CURRENT
  93          * @param int $buffer one of MW_EXPORT_BUFFER or MW_EXPORT_STREAM
  94          */
  95         function WikiExporter( &$db, $history = MW_EXPORT_CURRENT,
  96                         $buffer = MW_EXPORT_BUFFER ) {
  97                 $this->db =& $db;
  98                 $this->history = $history;
  99                 $this->buffer  = $buffer;
 100         }
 101
 102         /**
 103          * Set a callback to be called after each page in the output
 104          * stream is closed. The callback will be passed a database row
 105          * object with the last revision output.
 106          *
 107          * A set callback can be removed by passing null here.
 108          *
 109          * @param mixed $callback
 110          */
 111         function setPageCallback( $callback ) {
 112                 $this->pageCallback = $callback;
 113         }
 114
 115         /**
 116          * Set a callback to be called after each revision in the output
 117          * stream is closed. The callback will be passed a database row
 118          * object with the revision data.
 119          *
 120          * A set callback can be removed by passing null here.
 121          *
 122          * @param mixed $callback
 123          */
 124         function setRevisionCallback( $callback ) {
 125                 $this->revCallback = $callback;
 126         }
 127
 128         /**
 129          * Returns the export schema version.
 130          * @return string
 131          */
 132         function schemaVersion() {
 133                 return "0.3";
 134         }
 135
 136         /**
 137          * Opens the XML output stream's root <mediawiki> element.
 138          * This does not include an xml directive, so is safe to include
 139          * as a subelement in a larger XML stream. Namespace and XML Schema
 140          * references are included.
 141          *
 142          * To capture the stream to a string, use PHP's output buffering
 143          * functions. Output will be encoded in UTF-8.
 144          */
 145         function openStream() {
 146                 global $wgContLanguageCode;
 147                 $ver = $this->schemaVersion();
 148                 print wfElement( 'mediawiki', array(
 149                         'xmlns'              => "http://www.mediawiki.org/xml/export-$ver/",
 150                         'xmlns:xsi'          => "http://www.w3.org/2001/XMLSchema-instance",
 151                         'xsi:schemaLocation' => "http://www.mediawiki.org/xml/export-$ver/ " .
 152                                                 "http://www.mediawiki.org/xml/export-$ver.xsd",
 153                         'version'            => $ver,
 154                         'xml:lang'           => $wgContLanguageCode ),
 155                         null ) . "\n";
 156                 $this->siteInfo();
 157         }
 158
 159         function siteInfo() {
 160                 $info = array(
 161                         $this->sitename(),
 162                         $this->homelink(),
 163                         $this->generator(),
 164                         $this->caseSetting(),
 165                         $this->namespaces() );
 166                 print "<siteinfo>\n";
 167                 foreach( $info as $item ) {
 168                         print "  $item\n";
 169                 }
 170                 print "</siteinfo>\n";
 171         }
 172
 173         function sitename() {
 174                 global $wgSitename;
 175                 return wfElement( 'sitename', array(), $wgSitename );
 176         }
 177
 178         function generator() {
 179                 global $wgVersion;
 180                 return wfElement( 'generator', array(), "MediaWiki $wgVersion" );
 181         }
 182
 183         function homelink() {
 184                 $page = Title::newFromText( wfMsgForContent( 'mainpage' ) );
 185                 return wfElement( 'base', array(), $page->getFullUrl() );
 186         }
 187
 188         function caseSetting() {
 189                 global $wgCapitalLinks;
 190                 // "case-insensitive" option is reserved for future
 191                 $sensitivity = $wgCapitalLinks ? 'first-letter' : 'case-sensitive';
 192                 return wfElement( 'case', array(), $sensitivity );
 193         }
 194
 195         function namespaces() {
 196                 global $wgContLang;
 197                 $spaces = "<namespaces>\n";
 198                 foreach( $wgContLang->getFormattedNamespaces() as $ns => $title ) {
 199                         $spaces .= '    ' . wfElement( 'namespace', array( 'key' => $ns ), $title ) . "\n";
 200                 }
 201                 $spaces .= "  </namespaces>";
 202                 return $spaces;
 203         }
 204
 205         /**
 206          * Closes the output stream with the closing root element.
 207          * Call when finished dumping things.
 208          */
 209         function closeStream() {
 210                 print "</mediawiki>\n";
 211         }
 212
 213         /**
 214          * Dumps a series of page and revision records for all pages
 215          * in the database, either including complete history or only
 216          * the most recent version.
 217          */
 218         function allPages() {
 219                 return $this->dumpFrom( '' );
 220         }
 221
 222         /**
 223          * Dumps a series of page and revision records for those pages
 224          * in the database falling within the page_id range given.
 225          * @param int $start Inclusive lower limit (this id is included)
 226          * @param int $end   Exclusive upper limit (this id is not included)
 227          *                   If 0, no upper limit.
 228          */
 229         function pagesByRange( $start, $end ) {
 230                 $condition = 'page_id >= ' . intval( $start );
 231                 if( $end ) {
 232                         $condition .= ' AND page_id < ' . intval( $end );
 233                 }
 234                 return $this->dumpFrom( $condition );
 235         }
 236
 237         /**
 238          * @param Title $title
 239          */
 240         function pageByTitle( $title ) {
 241                 return $this->dumpFrom(
 242                         'page_namespace=' . $title->getNamespace() .
 243                         ' AND page_title=' . $this->db->addQuotes( $title->getDbKey() ) );
 244         }
 245
 246         function pageByName( $name ) {
 247                 $title = Title::newFromText( $name );
 248                 if( is_null( $title ) ) {
 249                         return new WikiError( "Can't export invalid title" );
 250                 } else {
 251                         return $this->pageByTitle( $title );
 252                 }
 253         }
 254
 255         function pagesByName( $names ) {
 256                 foreach( $names as $name ) {
 257                         $this->pageByName( $name );
 258                 }
 259         }
 260
 261
 262         // -------------------- private implementation below --------------------
 263
 264         function dumpFrom( $cond = '' ) {
 265                 $fname = 'WikiExporter::dumpFrom';
 266                 wfProfileIn( $fname );
 267
 268                 $page     = $this->db->tableName( 'page' );
 269                 $revision = $this->db->tableName( 'revision' );
 270                 $text     = $this->db->tableName( 'text' );
 271
 272                 if( $this->history == MW_EXPORT_FULL ) {
 273                         $join = 'page_id=rev_page';
 274                 } elseif( $this->history == MW_EXPORT_CURRENT ) {
 275                         $join = 'page_id=rev_page AND page_latest=rev_id';
 276                 } else {
 277                         wfProfileOut( $fname );
 278                         return new WikiError( "$fname given invalid history dump type." );
 279                 }
 280                 $where = ( $cond == '' ) ? '' : "$cond AND";
 281
 282                 if( $this->buffer == MW_EXPORT_STREAM ) {
 283                         $prev = $this->db->bufferResults( false );
 284                 }
 285                 if( $cond == '' ) {
 286                         // Optimization hack for full-database dump
 287                         $pageindex = 'FORCE INDEX (PRIMARY)';
 288                         $revindex = 'FORCE INDEX(page_timestamp)';
 289                 } else {
 290                         $pageindex = '';
 291                         $revindex = '';
 292                 }
 293                 $result = $this->db->query(
 294                         "SELECT * FROM
 295                                 $page $pageindex,
 296                                 $revision $revindex,
 297                                 $text
 298                                 WHERE $where $join AND rev_text_id=old_id
 299                                 ORDER BY page_id", $fname );
 300                 $wrapper = $this->db->resultObject( $result );
 301                 $this->outputStream( $wrapper );
 302
 303                 if( $this->buffer == MW_EXPORT_STREAM ) {
 304                         $this->db->bufferResults( $prev );
 305                 }
 306
 307                 wfProfileOut( $fname );
 308         }
 309
 310         /**
 311          * Runs through a query result set dumping page and revision records.
 312          * The result set should be sorted/grouped by page to avoid duplicate
 313          * page records in the output.
 314          *
 315          * The result set will be freed once complete. Should be safe for
 316          * streaming (non-buffered) queries, as long as it was made on a
 317          * separate database connection not managed by LoadBalancer; some
 318          * blob storage types will make queries to pull source data.
 319          *
 320          * @param ResultWrapper $resultset
 321          * @access private
 322          */
 323         function outputStream( $resultset ) {
 324                 $last = null;
 325                 while( $row = $resultset->fetchObject() ) {
 326                         if( is_null( $last ) ||
 327                                 $last->page_namespace != $row->page_namespace ||
 328                                 $last->page_title     != $row->page_title ) {
 329                                 if( isset( $last ) ) {
 330                                         $this->closePage( $last );
 331                                 }
 332                                 $this->openPage( $row );
 333                                 $last = $row;
 334                         }
 335                         $this->dumpRev( $row );
 336                 }
 337                 if( isset( $last ) ) {
 338                         $this->closePage( $last );
 339                 }
 340                 $resultset->free();
 341         }
 342
 343         /**
 344          * Opens a <page> section on the output stream, with data
 345          * from the given database row.
 346          *
 347          * @param object $row
 348          * @access private
 349          */
 350         function openPage( $row ) {
 351                 print "<page>\n";
 352                 $title = Title::makeTitle( $row->page_namespace, $row->page_title );
 353                 print '  ' . wfElementClean( 'title', array(), $title->getPrefixedText() ) . "\n";
 354                 print '  ' . wfElement( 'id', array(), strval( $row->page_id ) ) . "\n";
 355                 if( '' != $row->page_restrictions ) {
 356                         print '  ' . wfElement( 'restrictions', array(),
 357                                 strval( $row->page_restrictions ) ) . "\n";
 358                 }
 359         }
 360
 361         /**
 362          * Closes a <page> section on the output stream.
 363          * If a per-page callback has been set, it will be called
 364          * and passed the last database row used for this page.
 365          *
 366          * @param object $row
 367          * @access private
 368          */
 369         function closePage( $row ) {
 370                 print "</page>\n";
 371                 if( isset( $this->pageCallback ) ) {
 372                         call_user_func( $this->pageCallback, $row );
 373                 }
 374         }
 375
 376         /**
 377          * Dumps a <revision> section on the output stream, with
 378          * data filled in from the given database row.
 379          *
 380          * @param object $row
 381          * @access private
 382          */
 383         function dumpRev( $row ) {
 384                 $fname = 'WikiExporter::dumpRev';
 385                 wfProfileIn( $fname );
 386
 387                 print "  <revision>\n";
 388                 print "    " . wfElement( 'id', null, strval( $row->rev_id ) ) . "\n";
 389
 390                 $ts = wfTimestamp2ISO8601( strval( $row->rev_timestamp ) );
 391                 print "    " . wfElement( 'timestamp', null, $ts ) . "\n";
 392
 393                 print "    <contributor>\n";
 394                 if( $row->rev_user ) {
 395                         print "      " . wfElementClean( 'username', null, strval( $row->rev_user_text ) ) . "\n";
 396                         print "      " . wfElement( 'id', null, strval( $row->rev_user ) ) . "\n";
 397                 } else {
 398                         print "      " . wfElementClean( 'ip', null, strval( $row->rev_user_text ) ) . "\n";
 399                 }
 400                 print "    </contributor>\n";
 401
 402                 if( $row->rev_minor_edit ) {
 403                         print  "    <minor/>\n";
 404                 }
 405                 if( $row->rev_comment != '' ) {
 406                         print "    " . wfElementClean( 'comment', null, strval( $row->rev_comment ) ) . "\n";
 407                 }
 408
 409                 $text = strval( Revision::getRevisionText( $row ) );
 410                 print "    " . wfElementClean( 'text', array( 'xml:space' => 'preserve' ), $text ) . "\n";
 411
 412                 print "  </revision>\n";
 413
 414                 wfProfileOut( $fname );
 415
 416                 if( isset( $this->revCallback ) ) {
 417                         call_user_func( $this->revCallback, $row );
 418                 }
 419         }
 420
 421 }
 422
 423 function wfTimestamp2ISO8601( $ts ) {
 424         #2003-08-05T18:30:02Z
 425         return preg_replace( '/^(....)(..)(..)(..)(..)(..)$/', '$1-$2-$3T$4:$5:$6Z', wfTimestamp( TS_MW, $ts ) );
 426 }
 427
 428 function xmlsafe( $string ) {
 429         $fname = 'xmlsafe';
 430         wfProfileIn( $fname );
 431
 432         /**
 433          * The page may contain old data which has not been properly normalized.
 434          * Invalid UTF-8 sequences or forbidden control characters will make our
 435          * XML output invalid, so be sure to strip them out.
 436          */
 437         $string = UtfNormal::cleanUp( $string );
 438
 439         $string = htmlspecialchars( $string );
 440         wfProfileOut( $fname );
 441         return $string;
 442 }
 443
 444 ?>