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          *
 219          * @param Database $db
 220          */
 221         function allPages() {
 222                 return $this->dumpFrom( '' );
 223         }
 224
 225         /**
 226          * @param Title $title
 227          */
 228         function pageByTitle( $title ) {
 229                 return $this->dumpFrom(
 230                         'page_namespace=' . $title->getNamespace() .
 231                         ' AND page_title=' . $this->db->addQuotes( $title->getDbKey() ) );
 232         }
 233
 234         function pageByName( $name ) {
 235                 $title = Title::newFromText( $name );
 236                 if( is_null( $title ) ) {
 237                         return new WikiError( "Can't export invalid title" );
 238                 } else {
 239                         return $this->pageByTitle( $title );
 240                 }
 241         }
 242
 243         function pagesByName( $names ) {
 244                 foreach( $names as $name ) {
 245                         $this->pageByName( $name );
 246                 }
 247         }
 248
 249
 250         // -------------------- private implementation below --------------------
 251
 252         function dumpFrom( $cond = '' ) {
 253                 $fname = 'WikiExporter::dumpFrom';
 254                 wfProfileIn( $fname );
 255
 256                 $page     = $this->db->tableName( 'page' );
 257                 $revision = $this->db->tableName( 'revision' );
 258                 $text     = $this->db->tableName( 'text' );
 259
 260                 if( $this->history == MW_EXPORT_FULL ) {
 261                         $join = 'page_id=rev_page';
 262                 } elseif( $this->history == MW_EXPORT_CURRENT ) {
 263                         $join = 'page_id=rev_page AND page_latest=rev_id';
 264                 } else {
 265                         wfProfileOut( $fname );
 266                         return new WikiError( "$fname given invalid history dump type." );
 267                 }
 268                 $where = ( $cond == '' ) ? '' : "$cond AND";
 269
 270                 if( $this->buffer == MW_EXPORT_STREAM ) {
 271                         $prev = $this->db->bufferResults( false );
 272                 }
 273                 if( $cond == '' ) {
 274                         // Optimization hack for full-database dump
 275                         $pageindex = 'FORCE INDEX (PRIMARY)';
 276                         $revindex = 'FORCE INDEX(page_timestamp)';
 277                 } else {
 278                         $pageindex = '';
 279                         $revindex = '';
 280                 }
 281                 $result = $this->db->query(
 282                         "SELECT * FROM
 283                                 $page $pageindex,
 284                                 $revision $revindex,
 285                                 $text
 286                                 WHERE $where $join AND rev_text_id=old_id
 287                                 ORDER BY page_id", $fname );
 288                 $wrapper = $this->db->resultObject( $result );
 289                 $this->outputStream( $wrapper );
 290
 291                 if( $this->buffer == MW_EXPORT_STREAM ) {
 292                         $this->db->bufferResults( $prev );
 293                 }
 294
 295                 wfProfileOut( $fname );
 296         }
 297
 298         /**
 299          * Runs through a query result set dumping page and revision records.
 300          * The result set should be sorted/grouped by page to avoid duplicate
 301          * page records in the output.
 302          *
 303          * The result set will be freed once complete. Should be safe for
 304          * streaming (non-buffered) queries, as long as it was made on a
 305          * separate database connection not managed by LoadBalancer; some
 306          * blob storage types will make queries to pull source data.
 307          *
 308          * @param ResultWrapper $resultset
 309          * @access private
 310          */
 311         function outputStream( $resultset ) {
 312                 $last = null;
 313                 while( $row = $resultset->fetchObject() ) {
 314                         if( is_null( $last ) ||
 315                                 $last->page_namespace != $row->page_namespace ||
 316                                 $last->page_title     != $row->page_title ) {
 317                                 if( isset( $last ) ) {
 318                                         $this->closePage( $last );
 319                                 }
 320                                 $this->openPage( $row );
 321                                 $last = $row;
 322                         }
 323                         $this->dumpRev( $row );
 324                 }
 325                 if( isset( $last ) ) {
 326                         $this->closePage( $last );
 327                 }
 328                 $resultset->free();
 329         }
 330
 331         /**
 332          * Opens a <page> section on the output stream, with data
 333          * from the given database row.
 334          *
 335          * @param object $row
 336          * @access private
 337          */
 338         function openPage( $row ) {
 339                 print "<page>\n";
 340                 $title = Title::makeTitle( $row->page_namespace, $row->page_title );
 341                 print '  ' . wfElementClean( 'title', array(), $title->getPrefixedText() ) . "\n";
 342                 print '  ' . wfElement( 'id', array(), strval( $row->page_id ) ) . "\n";
 343                 if( '' != $row->page_restrictions ) {
 344                         print '  ' . wfElement( 'restrictions', array(),
 345                                 strval( $row->page_restrictions ) ) . "\n";
 346                 }
 347         }
 348
 349         /**
 350          * Closes a <page> section on the output stream.
 351          * If a per-page callback has been set, it will be called
 352          * and passed the last database row used for this page.
 353          *
 354          * @param object $row
 355          * @access private
 356          */
 357         function closePage( $row ) {
 358                 print "</page>\n";
 359                 if( isset( $this->pageCallback ) ) {
 360                         call_user_func( $this->pageCallback, $row );
 361                 }
 362         }
 363
 364         /**
 365          * Dumps a <revision> section on the output stream, with
 366          * data filled in from the given database row.
 367          *
 368          * @param object $row
 369          * @access private
 370          */
 371         function dumpRev( $row ) {
 372                 $fname = 'WikiExporter::dumpRev';
 373                 wfProfileIn( $fname );
 374
 375                 print "  <revision>\n";
 376                 print "    " . wfElement( 'id', null, strval( $row->rev_id ) ) . "\n";
 377
 378                 $ts = wfTimestamp2ISO8601( strval( $row->rev_timestamp ) );
 379                 print "    " . wfElement( 'timestamp', null, $ts ) . "\n";
 380
 381                 print "    <contributor>\n";
 382                 if( $row->rev_user ) {
 383                         print "      " . wfElementClean( 'username', null, strval( $row->rev_user_text ) ) . "\n";
 384                         print "      " . wfElement( 'id', null, strval( $row->rev_user ) ) . "\n";
 385                 } else {
 386                         print "      " . wfElementClean( 'ip', null, strval( $row->rev_user_text ) ) . "\n";
 387                 }
 388                 print "    </contributor>\n";
 389
 390                 if( $row->rev_minor_edit ) {
 391                         print  "    <minor/>\n";
 392                 }
 393                 if( $row->rev_comment != '' ) {
 394                         print "    " . wfElementClean( 'comment', null, strval( $row->rev_comment ) ) . "\n";
 395                 }
 396
 397                 $text = strval( Revision::getRevisionText( $row ) );
 398                 print "    " . wfElementClean( 'text', array( 'xml:space' => 'preserve' ), $text ) . "\n";
 399
 400                 print "  </revision>\n";
 401
 402                 wfProfileOut( $fname );
 403
 404                 if( isset( $this->revCallback ) ) {
 405                         call_user_func( $this->revCallback, $row );
 406                 }
 407         }
 408
 409 }
 410
 411 function wfTimestamp2ISO8601( $ts ) {
 412         #2003-08-05T18:30:02Z
 413         return preg_replace( '/^(....)(..)(..)(..)(..)(..)$/', '$1-$2-$3T$4:$5:$6Z', wfTimestamp( TS_MW, $ts ) );
 414 }
 415
 416 function xmlsafe( $string ) {
 417         $fname = 'xmlsafe';
 418         wfProfileIn( $fname );
 419
 420         /**
 421          * The page may contain old data which has not been properly normalized.
 422          * Invalid UTF-8 sequences or forbidden control characters will make our
 423          * XML output invalid, so be sure to strip them out.
 424          */
 425         $string = UtfNormal::cleanUp( $string );
 426
 427         $string = htmlspecialchars( $string );
 428         wfProfileOut( $fname );
 429         return $string;
 430 }
 431
 432 ?>