includes/filerepo/file/OldLocalFile.php

   1 <?php
   2 /**
   3  * Old file in the oldimage table.
   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  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup FileAbstraction
  22  */
  23
  24 use MediaWiki\MediaWikiServices;
  25
  26 /**
  27  * Class to represent a file in the oldimage table
  28  *
  29  * @ingroup FileAbstraction
  30  */
  31 class OldLocalFile extends LocalFile {
  32         /** @var string|int Timestamp */
  33         protected $requestedTime;
  34
  35         /** @var string Archive name */
  36         protected $archive_name;
  37
  38         const CACHE_VERSION = 1;
  39         const MAX_CACHE_ROWS = 20;
  40
  41         /**
  42          * @param Title $title
  43          * @param FileRepo $repo
  44          * @param string|int|null $time
  45          * @return self
  46          * @throws MWException
  47          */
  48         static function newFromTitle( $title, $repo, $time = null ) {
  49                 # The null default value is only here to avoid an E_STRICT
  50                 if ( $time === null ) {
  51                         throw new MWException( __METHOD__ . ' got null for $time parameter' );
  52                 }
  53
  54                 return new self( $title, $repo, $time, null );
  55         }
  56
  57         /**
  58          * @param Title $title
  59          * @param FileRepo $repo
  60          * @param string $archiveName
  61          * @return self
  62          */
  63         static function newFromArchiveName( $title, $repo, $archiveName ) {
  64                 return new self( $title, $repo, null, $archiveName );
  65         }
  66
  67         /**
  68          * @param stdClass $row
  69          * @param FileRepo $repo
  70          * @return self
  71          */
  72         static function newFromRow( $row, $repo ) {
  73                 $title = Title::makeTitle( NS_FILE, $row->oi_name );
  74                 $file = new self( $title, $repo, null, $row->oi_archive_name );
  75                 $file->loadFromRow( $row, 'oi_' );
  76
  77                 return $file;
  78         }
  79
  80         /**
  81          * Create a OldLocalFile from a SHA-1 key
  82          * Do not call this except from inside a repo class.
  83          *
  84          * @param string $sha1 Base-36 SHA-1
  85          * @param LocalRepo $repo
  86          * @param string|bool $timestamp MW_timestamp (optional)
  87          *
  88          * @return bool|OldLocalFile
  89          */
  90         static function newFromKey( $sha1, $repo, $timestamp = false ) {
  91                 $dbr = $repo->getReplicaDB();
  92
  93                 $conds = [ 'oi_sha1' => $sha1 ];
  94                 if ( $timestamp ) {
  95                         $conds['oi_timestamp'] = $dbr->timestamp( $timestamp );
  96                 }
  97
  98                 $fileQuery = self::getQueryInfo();
  99                 $row = $dbr->selectRow(
 100                         $fileQuery['tables'], $fileQuery['fields'], $conds, __METHOD__, [], $fileQuery['joins']
 101                 );
 102                 if ( $row ) {
 103                         return self::newFromRow( $row, $repo );
 104                 } else {
 105                         return false;
 106                 }
 107         }
 108
 109         /**
 110          * Fields in the oldimage table
 111          * @deprecated since 1.31, use self::getQueryInfo() instead.
 112          * @return string[]
 113          */
 114         static function selectFields() {
 115                 global $wgActorTableSchemaMigrationStage;
 116
 117                 wfDeprecated( __METHOD__, '1.31' );
 118                 if ( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_READ_NEW ) {
 119                         // If code is using this instead of self::getQueryInfo(), there's a
 120                         // decent chance it's going to try to directly access
 121                         // $row->oi_user or $row->oi_user_text and we can't give it
 122                         // useful values here once those aren't being used anymore.
 123                         throw new BadMethodCallException(
 124                                 'Cannot use ' . __METHOD__
 125                                         . ' when $wgActorTableSchemaMigrationStage has SCHEMA_COMPAT_READ_NEW'
 126                         );
 127                 }
 128
 129                 return [
 130                         'oi_name',
 131                         'oi_archive_name',
 132                         'oi_size',
 133                         'oi_width',
 134                         'oi_height',
 135                         'oi_metadata',
 136                         'oi_bits',
 137                         'oi_media_type',
 138                         'oi_major_mime',
 139                         'oi_minor_mime',
 140                         'oi_user',
 141                         'oi_user_text',
 142                         'oi_actor' => 'NULL',
 143                         'oi_timestamp',
 144                         'oi_deleted',
 145                         'oi_sha1',
 146                 ] + MediaWikiServices::getInstance()->getCommentStore()->getFields( 'oi_description' );
 147         }
 148
 149         /**
 150          * Return the tables, fields, and join conditions to be selected to create
 151          * a new oldlocalfile object.
 152          * @since 1.31
 153          * @param string[] $options
 154          *   - omit-lazy: Omit fields that are lazily cached.
 155          * @return array[] With three keys:
 156          *   - tables: (string[]) to include in the `$table` to `IDatabase->select()`
 157          *   - fields: (string[]) to include in the `$vars` to `IDatabase->select()`
 158          *   - joins: (array) to include in the `$join_conds` to `IDatabase->select()`
 159          */
 160         public static function getQueryInfo( array $options = [] ) {
 161                 $commentQuery = MediaWikiServices::getInstance()->getCommentStore()->getJoin( 'oi_description' );
 162                 $actorQuery = ActorMigration::newMigration()->getJoin( 'oi_user' );
 163                 $ret = [
 164                         'tables' => [ 'oldimage' ] + $commentQuery['tables'] + $actorQuery['tables'],
 165                         'fields' => [
 166                                 'oi_name',
 167                                 'oi_archive_name',
 168                                 'oi_size',
 169                                 'oi_width',
 170                                 'oi_height',
 171                                 'oi_bits',
 172                                 'oi_media_type',
 173                                 'oi_major_mime',
 174                                 'oi_minor_mime',
 175                                 'oi_timestamp',
 176                                 'oi_deleted',
 177                                 'oi_sha1',
 178                         ] + $commentQuery['fields'] + $actorQuery['fields'],
 179                         'joins' => $commentQuery['joins'] + $actorQuery['joins'],
 180                 ];
 181
 182                 if ( in_array( 'omit-nonlazy', $options, true ) ) {
 183                         // Internal use only for getting only the lazy fields
 184                         $ret['fields'] = [];
 185                 }
 186                 if ( !in_array( 'omit-lazy', $options, true ) ) {
 187                         // Note: Keep this in sync with self::getLazyCacheFields()
 188                         $ret['fields'][] = 'oi_metadata';
 189                 }
 190
 191                 return $ret;
 192         }
 193
 194         /**
 195          * @param Title $title
 196          * @param FileRepo $repo
 197          * @param string|int|null $time Timestamp or null to load by archive name
 198          * @param string|null $archiveName Archive name or null to load by timestamp
 199          * @throws MWException
 200          */
 201         function __construct( $title, $repo, $time, $archiveName ) {
 202                 parent::__construct( $title, $repo );
 203                 $this->requestedTime = $time;
 204                 $this->archive_name = $archiveName;
 205                 if ( is_null( $time ) && is_null( $archiveName ) ) {
 206                         throw new MWException( __METHOD__ . ': must specify at least one of $time or $archiveName' );
 207                 }
 208         }
 209
 210         /**
 211          * @return bool
 212          */
 213         function getCacheKey() {
 214                 return false;
 215         }
 216
 217         /**
 218          * @return string
 219          */
 220         function getArchiveName() {
 221                 if ( !isset( $this->archive_name ) ) {
 222                         $this->load();
 223                 }
 224
 225                 return $this->archive_name;
 226         }
 227
 228         /**
 229          * @return bool
 230          */
 231         function isOld() {
 232                 return true;
 233         }
 234
 235         /**
 236          * @return bool
 237          */
 238         function isVisible() {
 239                 return $this->exists() && !$this->isDeleted( File::DELETED_FILE );
 240         }
 241
 242         function loadFromDB( $flags = 0 ) {
 243                 $this->dataLoaded = true;
 244
 245                 $dbr = ( $flags & self::READ_LATEST )
 246                         ? $this->repo->getMasterDB()
 247                         : $this->repo->getReplicaDB();
 248
 249                 $conds = [ 'oi_name' => $this->getName() ];
 250                 if ( is_null( $this->requestedTime ) ) {
 251                         $conds['oi_archive_name'] = $this->archive_name;
 252                 } else {
 253                         $conds['oi_timestamp'] = $dbr->timestamp( $this->requestedTime );
 254                 }
 255                 $fileQuery = static::getQueryInfo();
 256                 $row = $dbr->selectRow(
 257                         $fileQuery['tables'],
 258                         $fileQuery['fields'],
 259                         $conds,
 260                         __METHOD__,
 261                         [ 'ORDER BY' => 'oi_timestamp DESC' ],
 262                         $fileQuery['joins']
 263                 );
 264                 if ( $row ) {
 265                         $this->loadFromRow( $row, 'oi_' );
 266                 } else {
 267                         $this->fileExists = false;
 268                 }
 269         }
 270
 271         /**
 272          * Load lazy file metadata from the DB
 273          */
 274         protected function loadExtraFromDB() {
 275                 $this->extraDataLoaded = true;
 276                 $dbr = $this->repo->getReplicaDB();
 277                 $conds = [ 'oi_name' => $this->getName() ];
 278                 if ( is_null( $this->requestedTime ) ) {
 279                         $conds['oi_archive_name'] = $this->archive_name;
 280                 } else {
 281                         $conds['oi_timestamp'] = $dbr->timestamp( $this->requestedTime );
 282                 }
 283                 $fileQuery = static::getQueryInfo( [ 'omit-nonlazy' ] );
 284                 // In theory the file could have just been renamed/deleted...oh well
 285                 $row = $dbr->selectRow(
 286                         $fileQuery['tables'],
 287                         $fileQuery['fields'],
 288                         $conds,
 289                         __METHOD__,
 290                         [ 'ORDER BY' => 'oi_timestamp DESC' ],
 291                         $fileQuery['joins']
 292                 );
 293
 294                 if ( !$row ) { // fallback to master
 295                         $dbr = $this->repo->getMasterDB();
 296                         $row = $dbr->selectRow(
 297                                 $fileQuery['tables'],
 298                                 $fileQuery['fields'],
 299                                 $conds,
 300                                 __METHOD__,
 301                                 [ 'ORDER BY' => 'oi_timestamp DESC' ],
 302                                 $fileQuery['joins']
 303                         );
 304                 }
 305
 306                 if ( $row ) {
 307                         foreach ( $this->unprefixRow( $row, 'oi_' ) as $name => $value ) {
 308                                 $this->$name = $value;
 309                         }
 310                 } else {
 311                         throw new MWException( "Could not find data for image '{$this->archive_name}'." );
 312                 }
 313         }
 314
 315         /** @inheritDoc */
 316         protected function getCacheFields( $prefix = 'img_' ) {
 317                 $fields = parent::getCacheFields( $prefix );
 318                 $fields[] = $prefix . 'archive_name';
 319                 $fields[] = $prefix . 'deleted';
 320
 321                 return $fields;
 322         }
 323
 324         /**
 325          * @return string
 326          */
 327         function getRel() {
 328                 return $this->getArchiveRel( $this->getArchiveName() );
 329         }
 330
 331         /**
 332          * @return string
 333          */
 334         function getUrlRel() {
 335                 return $this->getArchiveRel( rawurlencode( $this->getArchiveName() ) );
 336         }
 337
 338         function upgradeRow() {
 339                 $this->loadFromFile();
 340
 341                 # Don't destroy file info of missing files
 342                 if ( !$this->fileExists ) {
 343                         wfDebug( __METHOD__ . ": file does not exist, aborting\n" );
 344
 345                         return;
 346                 }
 347
 348                 $dbw = $this->repo->getMasterDB();
 349                 list( $major, $minor ) = self::splitMime( $this->mime );
 350
 351                 wfDebug( __METHOD__ . ': upgrading ' . $this->archive_name . " to the current schema\n" );
 352                 $dbw->update( 'oldimage',
 353                         [
 354                                 'oi_size' => $this->size, // sanity
 355                                 'oi_width' => $this->width,
 356                                 'oi_height' => $this->height,
 357                                 'oi_bits' => $this->bits,
 358                                 'oi_media_type' => $this->media_type,
 359                                 'oi_major_mime' => $major,
 360                                 'oi_minor_mime' => $minor,
 361                                 'oi_metadata' => $this->metadata,
 362                                 'oi_sha1' => $this->sha1,
 363                         ], [
 364                                 'oi_name' => $this->getName(),
 365                                 'oi_archive_name' => $this->archive_name ],
 366                         __METHOD__
 367                 );
 368         }
 369
 370         /**
 371          * @param int $field One of DELETED_* bitfield constants for file or
 372          *   revision rows
 373          * @return bool
 374          */
 375         function isDeleted( $field ) {
 376                 $this->load();
 377
 378                 return ( $this->deleted & $field ) == $field;
 379         }
 380
 381         /**
 382          * Returns bitfield value
 383          * @return int
 384          */
 385         function getVisibility() {
 386                 $this->load();
 387
 388                 return (int)$this->deleted;
 389         }
 390
 391         /**
 392          * Determine if the current user is allowed to view a particular
 393          * field of this image file, if it's marked as deleted.
 394          *
 395          * @param int $field
 396          * @param User|null $user User object to check, or null to use $wgUser
 397          * @return bool
 398          */
 399         function userCan( $field, User $user = null ) {
 400                 $this->load();
 401
 402                 return Revision::userCanBitfield( $this->deleted, $field, $user );
 403         }
 404
 405         /**
 406          * Upload a file directly into archive. Generally for Special:Import.
 407          *
 408          * @param string $srcPath File system path of the source file
 409          * @param string $timestamp
 410          * @param string $comment
 411          * @param User $user
 412          * @return Status
 413          */
 414         public function uploadOld( $srcPath, $timestamp, $comment, $user ) {
 415                 $this->lock();
 416
 417                 $archiveName = $this->getArchiveName();
 418                 $dstRel = $this->getArchiveRel( $archiveName );
 419                 $status = $this->publishTo( $srcPath, $dstRel );
 420
 421                 if ( $status->isGood() &&
 422                         !$this->recordOldUpload( $srcPath, $archiveName, $timestamp, $comment, $user )
 423                 ) {
 424                         $status->fatal( 'filenotfound', $srcPath );
 425                 }
 426
 427                 $this->unlock();
 428
 429                 return $status;
 430         }
 431
 432         /**
 433          * Record a file upload in the oldimage table, without adding log entries.
 434          *
 435          * @param string $srcPath File system path to the source file
 436          * @param string $archiveName The archive name of the file
 437          * @param string $timestamp
 438          * @param string $comment Upload comment
 439          * @param User $user User who did this upload
 440          * @return bool
 441          */
 442         protected function recordOldUpload( $srcPath, $archiveName, $timestamp, $comment, $user ) {
 443                 $dbw = $this->repo->getMasterDB();
 444
 445                 $dstPath = $this->repo->getZonePath( 'public' ) . '/' . $this->getRel();
 446                 $props = $this->repo->getFileProps( $dstPath );
 447                 if ( !$props['fileExists'] ) {
 448                         return false;
 449                 }
 450
 451                 $commentFields = MediaWikiServices::getInstance()->getCommentStore()
 452                         ->insert( $dbw, 'oi_description', $comment );
 453                 $actorFields = ActorMigration::newMigration()->getInsertValues( $dbw, 'oi_user', $user );
 454                 $dbw->insert( 'oldimage',
 455                         [
 456                                 'oi_name' => $this->getName(),
 457                                 'oi_archive_name' => $archiveName,
 458                                 'oi_size' => $props['size'],
 459                                 'oi_width' => intval( $props['width'] ),
 460                                 'oi_height' => intval( $props['height'] ),
 461                                 'oi_bits' => $props['bits'],
 462                                 'oi_timestamp' => $dbw->timestamp( $timestamp ),
 463                                 'oi_metadata' => $props['metadata'],
 464                                 'oi_media_type' => $props['media_type'],
 465                                 'oi_major_mime' => $props['major_mime'],
 466                                 'oi_minor_mime' => $props['minor_mime'],
 467                                 'oi_sha1' => $props['sha1'],
 468                         ] + $commentFields + $actorFields, __METHOD__
 469                 );
 470
 471                 return true;
 472         }
 473
 474         /**
 475          * If archive name is an empty string, then file does not "exist"
 476          *
 477          * This is the case for a couple files on Wikimedia servers where
 478          * the old version is "lost".
 479          * @return bool
 480          */
 481         public function exists() {
 482                 $archiveName = $this->getArchiveName();
 483                 if ( $archiveName === '' || !is_string( $archiveName ) ) {
 484                         return false;
 485                 }
 486                 return parent::exists();
 487         }
 488 }