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 $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 > MIGRATION_WRITE_BOTH ) {
 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 written anymore.
 123                         throw new BadMethodCallException(
 124                                 'Cannot use ' . __METHOD__ . ' when $wgActorTableSchemaMigrationStage > MIGRATION_WRITE_BOTH'
 125                         );
 126                 }
 127
 128                 return [
 129                         'oi_name',
 130                         'oi_archive_name',
 131                         'oi_size',
 132                         'oi_width',
 133                         'oi_height',
 134                         'oi_metadata',
 135                         'oi_bits',
 136                         'oi_media_type',
 137                         'oi_major_mime',
 138                         'oi_minor_mime',
 139                         'oi_user',
 140                         'oi_user_text',
 141                         'oi_actor' => $wgActorTableSchemaMigrationStage > MIGRATION_OLD ? 'oi_actor' : null,
 142                         'oi_timestamp',
 143                         'oi_deleted',
 144                         'oi_sha1',
 145                 ] + MediaWikiServices::getInstance()->getCommentStore()->getFields( 'oi_description' );
 146         }
 147
 148         /**
 149          * Return the tables, fields, and join conditions to be selected to create
 150          * a new oldlocalfile object.
 151          * @since 1.31
 152          * @param string[] $options
 153          *   - omit-lazy: Omit fields that are lazily cached.
 154          * @return array[] With three keys:
 155          *   - tables: (string[]) to include in the `$table` to `IDatabase->select()`
 156          *   - fields: (string[]) to include in the `$vars` to `IDatabase->select()`
 157          *   - joins: (array) to include in the `$join_conds` to `IDatabase->select()`
 158          */
 159         public static function getQueryInfo( array $options = [] ) {
 160                 $commentQuery = MediaWikiServices::getInstance()->getCommentStore()->getJoin( 'oi_description' );
 161                 $actorQuery = ActorMigration::newMigration()->getJoin( 'oi_user' );
 162                 $ret = [
 163                         'tables' => [ 'oldimage' ] + $commentQuery['tables'] + $actorQuery['tables'],
 164                         'fields' => [
 165                                 'oi_name',
 166                                 'oi_archive_name',
 167                                 'oi_size',
 168                                 'oi_width',
 169                                 'oi_height',
 170                                 'oi_bits',
 171                                 'oi_media_type',
 172                                 'oi_major_mime',
 173                                 'oi_minor_mime',
 174                                 'oi_timestamp',
 175                                 'oi_deleted',
 176                                 'oi_sha1',
 177                         ] + $commentQuery['fields'] + $actorQuery['fields'],
 178                         'joins' => $commentQuery['joins'] + $actorQuery['joins'],
 179                 ];
 180
 181                 if ( in_array( 'omit-nonlazy', $options, true ) ) {
 182                         // Internal use only for getting only the lazy fields
 183                         $ret['fields'] = [];
 184                 }
 185                 if ( !in_array( 'omit-lazy', $options, true ) ) {
 186                         // Note: Keep this in sync with self::getLazyCacheFields()
 187                         $ret['fields'][] = 'oi_metadata';
 188                 }
 189
 190                 return $ret;
 191         }
 192
 193         /**
 194          * @param Title $title
 195          * @param FileRepo $repo
 196          * @param string|int|null $time Timestamp or null to load by archive name
 197          * @param string|null $archiveName Archive name or null to load by timestamp
 198          * @throws MWException
 199          */
 200         function __construct( $title, $repo, $time, $archiveName ) {
 201                 parent::__construct( $title, $repo );
 202                 $this->requestedTime = $time;
 203                 $this->archive_name = $archiveName;
 204                 if ( is_null( $time ) && is_null( $archiveName ) ) {
 205                         throw new MWException( __METHOD__ . ': must specify at least one of $time or $archiveName' );
 206                 }
 207         }
 208
 209         /**
 210          * @return bool
 211          */
 212         function getCacheKey() {
 213                 return false;
 214         }
 215
 216         /**
 217          * @return string
 218          */
 219         function getArchiveName() {
 220                 if ( !isset( $this->archive_name ) ) {
 221                         $this->load();
 222                 }
 223
 224                 return $this->archive_name;
 225         }
 226
 227         /**
 228          * @return bool
 229          */
 230         function isOld() {
 231                 return true;
 232         }
 233
 234         /**
 235          * @return bool
 236          */
 237         function isVisible() {
 238                 return $this->exists() && !$this->isDeleted( File::DELETED_FILE );
 239         }
 240
 241         function loadFromDB( $flags = 0 ) {
 242                 $this->dataLoaded = true;
 243
 244                 $dbr = ( $flags & self::READ_LATEST )
 245                         ? $this->repo->getMasterDB()
 246                         : $this->repo->getReplicaDB();
 247
 248                 $conds = [ 'oi_name' => $this->getName() ];
 249                 if ( is_null( $this->requestedTime ) ) {
 250                         $conds['oi_archive_name'] = $this->archive_name;
 251                 } else {
 252                         $conds['oi_timestamp'] = $dbr->timestamp( $this->requestedTime );
 253                 }
 254                 $fileQuery = static::getQueryInfo();
 255                 $row = $dbr->selectRow(
 256                         $fileQuery['tables'],
 257                         $fileQuery['fields'],
 258                         $conds,
 259                         __METHOD__,
 260                         [ 'ORDER BY' => 'oi_timestamp DESC' ],
 261                         $fileQuery['joins']
 262                 );
 263                 if ( $row ) {
 264                         $this->loadFromRow( $row, 'oi_' );
 265                 } else {
 266                         $this->fileExists = false;
 267                 }
 268         }
 269
 270         /**
 271          * Load lazy file metadata from the DB
 272          */
 273         protected function loadExtraFromDB() {
 274                 $this->extraDataLoaded = true;
 275                 $dbr = $this->repo->getReplicaDB();
 276                 $conds = [ 'oi_name' => $this->getName() ];
 277                 if ( is_null( $this->requestedTime ) ) {
 278                         $conds['oi_archive_name'] = $this->archive_name;
 279                 } else {
 280                         $conds['oi_timestamp'] = $dbr->timestamp( $this->requestedTime );
 281                 }
 282                 $fileQuery = static::getQueryInfo( [ 'omit-nonlazy' ] );
 283                 // In theory the file could have just been renamed/deleted...oh well
 284                 $row = $dbr->selectRow(
 285                         $fileQuery['tables'],
 286                         $fileQuery['fields'],
 287                         $conds,
 288                         __METHOD__,
 289                         [ 'ORDER BY' => 'oi_timestamp DESC' ],
 290                         $fileQuery['joins']
 291                 );
 292
 293                 if ( !$row ) { // fallback to master
 294                         $dbr = $this->repo->getMasterDB();
 295                         $row = $dbr->selectRow(
 296                                 $fileQuery['tables'],
 297                                 $fileQuery['fields'],
 298                                 $conds,
 299                                 __METHOD__,
 300                                 [ 'ORDER BY' => 'oi_timestamp DESC' ],
 301                                 $fileQuery['joins']
 302                         );
 303                 }
 304
 305                 if ( $row ) {
 306                         foreach ( $this->unprefixRow( $row, 'oi_' ) as $name => $value ) {
 307                                 $this->$name = $value;
 308                         }
 309                 } else {
 310                         throw new MWException( "Could not find data for image '{$this->archive_name}'." );
 311                 }
 312         }
 313
 314         /** @inheritDoc */
 315         protected function getCacheFields( $prefix = 'img_' ) {
 316                 $fields = parent::getCacheFields( $prefix );
 317                 $fields[] = $prefix . 'archive_name';
 318                 $fields[] = $prefix . 'deleted';
 319
 320                 return $fields;
 321         }
 322
 323         /**
 324          * @return string
 325          */
 326         function getRel() {
 327                 return 'archive/' . $this->getHashPath() . $this->getArchiveName();
 328         }
 329
 330         /**
 331          * @return string
 332          */
 333         function getUrlRel() {
 334                 return 'archive/' . $this->getHashPath() . rawurlencode( $this->getArchiveName() );
 335         }
 336
 337         function upgradeRow() {
 338                 $this->loadFromFile();
 339
 340                 # Don't destroy file info of missing files
 341                 if ( !$this->fileExists ) {
 342                         wfDebug( __METHOD__ . ": file does not exist, aborting\n" );
 343
 344                         return;
 345                 }
 346
 347                 $dbw = $this->repo->getMasterDB();
 348                 list( $major, $minor ) = self::splitMime( $this->mime );
 349
 350                 wfDebug( __METHOD__ . ': upgrading ' . $this->archive_name . " to the current schema\n" );
 351                 $dbw->update( 'oldimage',
 352                         [
 353                                 'oi_size' => $this->size, // sanity
 354                                 'oi_width' => $this->width,
 355                                 'oi_height' => $this->height,
 356                                 'oi_bits' => $this->bits,
 357                                 'oi_media_type' => $this->media_type,
 358                                 'oi_major_mime' => $major,
 359                                 'oi_minor_mime' => $minor,
 360                                 'oi_metadata' => $this->metadata,
 361                                 'oi_sha1' => $this->sha1,
 362                         ], [
 363                                 'oi_name' => $this->getName(),
 364                                 'oi_archive_name' => $this->archive_name ],
 365                         __METHOD__
 366                 );
 367         }
 368
 369         /**
 370          * @param int $field One of DELETED_* bitfield constants for file or
 371          *   revision rows
 372          * @return bool
 373          */
 374         function isDeleted( $field ) {
 375                 $this->load();
 376
 377                 return ( $this->deleted & $field ) == $field;
 378         }
 379
 380         /**
 381          * Returns bitfield value
 382          * @return int
 383          */
 384         function getVisibility() {
 385                 $this->load();
 386
 387                 return (int)$this->deleted;
 388         }
 389
 390         /**
 391          * Determine if the current user is allowed to view a particular
 392          * field of this image file, if it's marked as deleted.
 393          *
 394          * @param int $field
 395          * @param User|null $user User object to check, or null to use $wgUser
 396          * @return bool
 397          */
 398         function userCan( $field, User $user = null ) {
 399                 $this->load();
 400
 401                 return Revision::userCanBitfield( $this->deleted, $field, $user );
 402         }
 403
 404         /**
 405          * Upload a file directly into archive. Generally for Special:Import.
 406          *
 407          * @param string $srcPath File system path of the source file
 408          * @param string $archiveName Full archive name of the file, in the form
 409          *   $timestamp!$filename, where $filename must match $this->getName()
 410          * @param string $timestamp
 411          * @param string $comment
 412          * @param User $user
 413          * @return Status
 414          */
 415         function uploadOld( $srcPath, $archiveName, $timestamp, $comment, $user ) {
 416                 $this->lock();
 417
 418                 $dstRel = 'archive/' . $this->getHashPath() . $archiveName;
 419                 $status = $this->publishTo( $srcPath, $dstRel );
 420
 421                 if ( $status->isGood() ) {
 422                         if ( !$this->recordOldUpload( $srcPath, $archiveName, $timestamp, $comment, $user ) ) {
 423                                 $status->fatal( 'filenotfound', $srcPath );
 424                         }
 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 }