MediaWiki  REL1_31
LocalFile.php
Go to the documentation of this file.
1 <?php
28 
46 class LocalFile extends File {
47  const VERSION = 11; // cache version
48 
49  const CACHE_FIELD_MAX_LEN = 1000;
50 
52  protected $fileExists;
53 
55  protected $width;
56 
58  protected $height;
59 
61  protected $bits;
62 
64  protected $media_type;
65 
67  protected $mime;
68 
70  protected $size;
71 
73  protected $metadata;
74 
76  protected $sha1;
77 
79  protected $dataLoaded;
80 
82  protected $extraDataLoaded;
83 
85  protected $deleted;
86 
89 
91  private $historyLine;
92 
94  private $historyRes;
95 
97  private $major_mime;
98 
100  private $minor_mime;
101 
103  private $timestamp;
104 
106  private $user;
107 
109  private $description;
110 
113 
115  private $upgraded;
116 
118  private $upgrading;
119 
121  private $locked;
122 
124  private $lockedOwnTrx;
125 
127  private $missing;
128 
129  // @note: higher than IDBAccessObject constants
130  const LOAD_ALL = 16; // integer; load all the lazy fields too (like metadata)
131 
132  const ATOMIC_SECTION_LOCK = 'LocalFile::lockingTransaction';
133 
146  static function newFromTitle( $title, $repo, $unused = null ) {
147  return new self( $title, $repo );
148  }
149 
159  static function newFromRow( $row, $repo ) {
160  $title = Title::makeTitle( NS_FILE, $row->img_name );
161  $file = new self( $title, $repo );
162  $file->loadFromRow( $row );
163 
164  return $file;
165  }
166 
176  static function newFromKey( $sha1, $repo, $timestamp = false ) {
177  $dbr = $repo->getReplicaDB();
178 
179  $conds = [ 'img_sha1' => $sha1 ];
180  if ( $timestamp ) {
181  $conds['img_timestamp'] = $dbr->timestamp( $timestamp );
182  }
183 
184  $fileQuery = self::getQueryInfo();
185  $row = $dbr->selectRow(
186  $fileQuery['tables'], $fileQuery['fields'], $conds, __METHOD__, [], $fileQuery['joins']
187  );
188  if ( $row ) {
189  return self::newFromRow( $row, $repo );
190  } else {
191  return false;
192  }
193  }
194 
200  static function selectFields() {
202 
203  wfDeprecated( __METHOD__, '1.31' );
205  // If code is using this instead of self::getQueryInfo(), there's a
206  // decent chance it's going to try to directly access
207  // $row->img_user or $row->img_user_text and we can't give it
208  // useful values here once those aren't being written anymore.
209  throw new BadMethodCallException(
210  'Cannot use ' . __METHOD__ . ' when $wgActorTableSchemaMigrationStage > MIGRATION_WRITE_BOTH'
211  );
212  }
213 
214  return [
215  'img_name',
216  'img_size',
217  'img_width',
218  'img_height',
219  'img_metadata',
220  'img_bits',
221  'img_media_type',
222  'img_major_mime',
223  'img_minor_mime',
224  'img_user',
225  'img_user_text',
226  'img_actor' => $wgActorTableSchemaMigrationStage > MIGRATION_OLD ? 'img_actor' : 'NULL',
227  'img_timestamp',
228  'img_sha1',
229  ] + CommentStore::getStore()->getFields( 'img_description' );
230  }
231 
243  public static function getQueryInfo( array $options = [] ) {
244  $commentQuery = CommentStore::getStore()->getJoin( 'img_description' );
245  $actorQuery = ActorMigration::newMigration()->getJoin( 'img_user' );
246  $ret = [
247  'tables' => [ 'image' ] + $commentQuery['tables'] + $actorQuery['tables'],
248  'fields' => [
249  'img_name',
250  'img_size',
251  'img_width',
252  'img_height',
253  'img_metadata',
254  'img_bits',
255  'img_media_type',
256  'img_major_mime',
257  'img_minor_mime',
258  'img_timestamp',
259  'img_sha1',
260  ] + $commentQuery['fields'] + $actorQuery['fields'],
261  'joins' => $commentQuery['joins'] + $actorQuery['joins'],
262  ];
263 
264  if ( in_array( 'omit-nonlazy', $options, true ) ) {
265  // Internal use only for getting only the lazy fields
266  $ret['fields'] = [];
267  }
268  if ( !in_array( 'omit-lazy', $options, true ) ) {
269  // Note: Keep this in sync with self::getLazyCacheFields()
270  $ret['fields'][] = 'img_metadata';
271  }
272 
273  return $ret;
274  }
275 
281  function __construct( $title, $repo ) {
282  parent::__construct( $title, $repo );
283 
284  $this->metadata = '';
285  $this->historyLine = 0;
286  $this->historyRes = null;
287  $this->dataLoaded = false;
288  $this->extraDataLoaded = false;
289 
290  $this->assertRepoDefined();
291  $this->assertTitleDefined();
292  }
293 
299  function getCacheKey() {
300  return $this->repo->getSharedCacheKey( 'file', sha1( $this->getName() ) );
301  }
302 
309  return [ $this->getCacheKey() ];
310  }
311 
315  private function loadFromCache() {
316  $this->dataLoaded = false;
317  $this->extraDataLoaded = false;
318 
319  $key = $this->getCacheKey();
320  if ( !$key ) {
321  $this->loadFromDB( self::READ_NORMAL );
322 
323  return;
324  }
325 
327  $cachedValues = $cache->getWithSetCallback(
328  $key,
329  $cache::TTL_WEEK,
330  function ( $oldValue, &$ttl, array &$setOpts ) use ( $cache ) {
331  $setOpts += Database::getCacheSetOptions( $this->repo->getReplicaDB() );
332 
333  $this->loadFromDB( self::READ_NORMAL );
334 
335  $fields = $this->getCacheFields( '' );
336  $cacheVal['fileExists'] = $this->fileExists;
337  if ( $this->fileExists ) {
338  foreach ( $fields as $field ) {
339  $cacheVal[$field] = $this->$field;
340  }
341  }
342  $cacheVal['user'] = $this->user ? $this->user->getId() : 0;
343  $cacheVal['user_text'] = $this->user ? $this->user->getName() : '';
344  $cacheVal['actor'] = $this->user ? $this->user->getActorId() : null;
345 
346  // Strip off excessive entries from the subset of fields that can become large.
347  // If the cache value gets to large it will not fit in memcached and nothing will
348  // get cached at all, causing master queries for any file access.
349  foreach ( $this->getLazyCacheFields( '' ) as $field ) {
350  if ( isset( $cacheVal[$field] )
351  && strlen( $cacheVal[$field] ) > 100 * 1024
352  ) {
353  unset( $cacheVal[$field] ); // don't let the value get too big
354  }
355  }
356 
357  if ( $this->fileExists ) {
358  $ttl = $cache->adaptiveTTL( wfTimestamp( TS_UNIX, $this->timestamp ), $ttl );
359  } else {
360  $ttl = $cache::TTL_DAY;
361  }
362 
363  return $cacheVal;
364  },
365  [ 'version' => self::VERSION ]
366  );
367 
368  $this->fileExists = $cachedValues['fileExists'];
369  if ( $this->fileExists ) {
370  $this->setProps( $cachedValues );
371  }
372 
373  $this->dataLoaded = true;
374  $this->extraDataLoaded = true;
375  foreach ( $this->getLazyCacheFields( '' ) as $field ) {
376  $this->extraDataLoaded = $this->extraDataLoaded && isset( $cachedValues[$field] );
377  }
378  }
379 
383  public function invalidateCache() {
384  $key = $this->getCacheKey();
385  if ( !$key ) {
386  return;
387  }
388 
389  $this->repo->getMasterDB()->onTransactionPreCommitOrIdle(
390  function () use ( $key ) {
391  ObjectCache::getMainWANInstance()->delete( $key );
392  },
393  __METHOD__
394  );
395  }
396 
400  function loadFromFile() {
401  $props = $this->repo->getFileProps( $this->getVirtualUrl() );
402  $this->setProps( $props );
403  }
404 
411  protected function getCacheFields( $prefix = 'img_' ) {
412  if ( $prefix !== '' ) {
413  throw new InvalidArgumentException(
414  __METHOD__ . ' with a non-empty prefix is no longer supported.'
415  );
416  }
417 
418  // See self::getQueryInfo() for the fetching of the data from the DB,
419  // self::loadFromRow() for the loading of the object from the DB row,
420  // and self::loadFromCache() for the caching, and self::setProps() for
421  // populating the object from an array of data.
422  return [ 'size', 'width', 'height', 'bits', 'media_type',
423  'major_mime', 'minor_mime', 'metadata', 'timestamp', 'sha1', 'description' ];
424  }
425 
433  protected function getLazyCacheFields( $prefix = 'img_' ) {
434  if ( $prefix !== '' ) {
435  throw new InvalidArgumentException(
436  __METHOD__ . ' with a non-empty prefix is no longer supported.'
437  );
438  }
439 
440  // Keep this in sync with the omit-lazy option in self::getQueryInfo().
441  return [ 'metadata' ];
442  }
443 
448  function loadFromDB( $flags = 0 ) {
449  $fname = static::class . '::' . __FUNCTION__;
450 
451  # Unconditionally set loaded=true, we don't want the accessors constantly rechecking
452  $this->dataLoaded = true;
453  $this->extraDataLoaded = true;
454 
455  $dbr = ( $flags & self::READ_LATEST )
456  ? $this->repo->getMasterDB()
457  : $this->repo->getReplicaDB();
458 
459  $fileQuery = static::getQueryInfo();
460  $row = $dbr->selectRow(
461  $fileQuery['tables'],
462  $fileQuery['fields'],
463  [ 'img_name' => $this->getName() ],
464  $fname,
465  [],
466  $fileQuery['joins']
467  );
468 
469  if ( $row ) {
470  $this->loadFromRow( $row );
471  } else {
472  $this->fileExists = false;
473  }
474  }
475 
480  protected function loadExtraFromDB() {
481  $fname = static::class . '::' . __FUNCTION__;
482 
483  # Unconditionally set loaded=true, we don't want the accessors constantly rechecking
484  $this->extraDataLoaded = true;
485 
486  $fieldMap = $this->loadExtraFieldsWithTimestamp( $this->repo->getReplicaDB(), $fname );
487  if ( !$fieldMap ) {
488  $fieldMap = $this->loadExtraFieldsWithTimestamp( $this->repo->getMasterDB(), $fname );
489  }
490 
491  if ( $fieldMap ) {
492  foreach ( $fieldMap as $name => $value ) {
493  $this->$name = $value;
494  }
495  } else {
496  throw new MWException( "Could not find data for image '{$this->getName()}'." );
497  }
498  }
499 
505  private function loadExtraFieldsWithTimestamp( $dbr, $fname ) {
506  $fieldMap = false;
507 
508  $fileQuery = self::getQueryInfo( [ 'omit-nonlazy' ] );
509  $row = $dbr->selectRow(
510  $fileQuery['tables'],
511  $fileQuery['fields'],
512  [
513  'img_name' => $this->getName(),
514  'img_timestamp' => $dbr->timestamp( $this->getTimestamp() ),
515  ],
516  $fname,
517  [],
518  $fileQuery['joins']
519  );
520  if ( $row ) {
521  $fieldMap = $this->unprefixRow( $row, 'img_' );
522  } else {
523  # File may have been uploaded over in the meantime; check the old versions
524  $fileQuery = OldLocalFile::getQueryInfo( [ 'omit-nonlazy' ] );
525  $row = $dbr->selectRow(
526  $fileQuery['tables'],
527  $fileQuery['fields'],
528  [
529  'oi_name' => $this->getName(),
530  'oi_timestamp' => $dbr->timestamp( $this->getTimestamp() ),
531  ],
532  $fname,
533  [],
534  $fileQuery['joins']
535  );
536  if ( $row ) {
537  $fieldMap = $this->unprefixRow( $row, 'oi_' );
538  }
539  }
540 
541  if ( isset( $fieldMap['metadata'] ) ) {
542  $fieldMap['metadata'] = $this->repo->getReplicaDB()->decodeBlob( $fieldMap['metadata'] );
543  }
544 
545  return $fieldMap;
546  }
547 
554  protected function unprefixRow( $row, $prefix = 'img_' ) {
555  $array = (array)$row;
556  $prefixLength = strlen( $prefix );
557 
558  // Sanity check prefix once
559  if ( substr( key( $array ), 0, $prefixLength ) !== $prefix ) {
560  throw new MWException( __METHOD__ . ': incorrect $prefix parameter' );
561  }
562 
563  $decoded = [];
564  foreach ( $array as $name => $value ) {
565  $decoded[substr( $name, $prefixLength )] = $value;
566  }
567 
568  return $decoded;
569  }
570 
579  function decodeRow( $row, $prefix = 'img_' ) {
580  $decoded = $this->unprefixRow( $row, $prefix );
581 
582  $decoded['description'] = CommentStore::getStore()
583  ->getComment( 'description', (object)$decoded )->text;
584 
585  $decoded['user'] = User::newFromAnyId(
586  isset( $decoded['user'] ) ? $decoded['user'] : null,
587  isset( $decoded['user_text'] ) ? $decoded['user_text'] : null,
588  isset( $decoded['actor'] ) ? $decoded['actor'] : null
589  );
590  unset( $decoded['user_text'], $decoded['actor'] );
591 
592  $decoded['timestamp'] = wfTimestamp( TS_MW, $decoded['timestamp'] );
593 
594  $decoded['metadata'] = $this->repo->getReplicaDB()->decodeBlob( $decoded['metadata'] );
595 
596  if ( empty( $decoded['major_mime'] ) ) {
597  $decoded['mime'] = 'unknown/unknown';
598  } else {
599  if ( !$decoded['minor_mime'] ) {
600  $decoded['minor_mime'] = 'unknown';
601  }
602  $decoded['mime'] = $decoded['major_mime'] . '/' . $decoded['minor_mime'];
603  }
604 
605  // Trim zero padding from char/binary field
606  $decoded['sha1'] = rtrim( $decoded['sha1'], "\0" );
607 
608  // Normalize some fields to integer type, per their database definition.
609  // Use unary + so that overflows will be upgraded to double instead of
610  // being trucated as with intval(). This is important to allow >2GB
611  // files on 32-bit systems.
612  foreach ( [ 'size', 'width', 'height', 'bits' ] as $field ) {
613  $decoded[$field] = +$decoded[$field];
614  }
615 
616  return $decoded;
617  }
618 
625  function loadFromRow( $row, $prefix = 'img_' ) {
626  $this->dataLoaded = true;
627  $this->extraDataLoaded = true;
628 
629  $array = $this->decodeRow( $row, $prefix );
630 
631  foreach ( $array as $name => $value ) {
632  $this->$name = $value;
633  }
634 
635  $this->fileExists = true;
636  $this->maybeUpgradeRow();
637  }
638 
643  function load( $flags = 0 ) {
644  if ( !$this->dataLoaded ) {
645  if ( $flags & self::READ_LATEST ) {
646  $this->loadFromDB( $flags );
647  } else {
648  $this->loadFromCache();
649  }
650  }
651 
652  if ( ( $flags & self::LOAD_ALL ) && !$this->extraDataLoaded ) {
653  // @note: loads on name/timestamp to reduce race condition problems
654  $this->loadExtraFromDB();
655  }
656  }
657 
661  function maybeUpgradeRow() {
663 
664  if ( wfReadOnly() || $this->upgrading ) {
665  return;
666  }
667 
668  $upgrade = false;
669  if ( is_null( $this->media_type ) || $this->mime == 'image/svg' ) {
670  $upgrade = true;
671  } else {
672  $handler = $this->getHandler();
673  if ( $handler ) {
674  $validity = $handler->isMetadataValid( $this, $this->getMetadata() );
675  if ( $validity === MediaHandler::METADATA_BAD ) {
676  $upgrade = true;
677  } elseif ( $validity === MediaHandler::METADATA_COMPATIBLE ) {
678  $upgrade = $wgUpdateCompatibleMetadata;
679  }
680  }
681  }
682 
683  if ( $upgrade ) {
684  $this->upgrading = true;
685  // Defer updates unless in auto-commit CLI mode
687  $this->upgrading = false; // avoid duplicate updates
688  try {
689  $this->upgradeRow();
690  } catch ( LocalFileLockError $e ) {
691  // let the other process handle it (or do it next time)
692  }
693  } );
694  }
695  }
696 
700  function getUpgraded() {
701  return $this->upgraded;
702  }
703 
707  function upgradeRow() {
708  $this->lock(); // begin
709 
710  $this->loadFromFile();
711 
712  # Don't destroy file info of missing files
713  if ( !$this->fileExists ) {
714  $this->unlock();
715  wfDebug( __METHOD__ . ": file does not exist, aborting\n" );
716 
717  return;
718  }
719 
720  $dbw = $this->repo->getMasterDB();
721  list( $major, $minor ) = self::splitMime( $this->mime );
722 
723  if ( wfReadOnly() ) {
724  $this->unlock();
725 
726  return;
727  }
728  wfDebug( __METHOD__ . ': upgrading ' . $this->getName() . " to the current schema\n" );
729 
730  $dbw->update( 'image',
731  [
732  'img_size' => $this->size, // sanity
733  'img_width' => $this->width,
734  'img_height' => $this->height,
735  'img_bits' => $this->bits,
736  'img_media_type' => $this->media_type,
737  'img_major_mime' => $major,
738  'img_minor_mime' => $minor,
739  'img_metadata' => $dbw->encodeBlob( $this->metadata ),
740  'img_sha1' => $this->sha1,
741  ],
742  [ 'img_name' => $this->getName() ],
743  __METHOD__
744  );
745 
746  $this->invalidateCache();
747 
748  $this->unlock(); // done
749  $this->upgraded = true; // avoid rework/retries
750  }
751 
762  function setProps( $info ) {
763  $this->dataLoaded = true;
764  $fields = $this->getCacheFields( '' );
765  $fields[] = 'fileExists';
766 
767  foreach ( $fields as $field ) {
768  if ( isset( $info[$field] ) ) {
769  $this->$field = $info[$field];
770  }
771  }
772 
773  if ( isset( $info['user'] ) || isset( $info['user_text'] ) || isset( $info['actor'] ) ) {
774  $this->user = User::newFromAnyId(
775  isset( $info['user'] ) ? $info['user'] : null,
776  isset( $info['user_text'] ) ? $info['user_text'] : null,
777  isset( $info['actor'] ) ? $info['actor'] : null
778  );
779  }
780 
781  // Fix up mime fields
782  if ( isset( $info['major_mime'] ) ) {
783  $this->mime = "{$info['major_mime']}/{$info['minor_mime']}";
784  } elseif ( isset( $info['mime'] ) ) {
785  $this->mime = $info['mime'];
786  list( $this->major_mime, $this->minor_mime ) = self::splitMime( $this->mime );
787  }
788  }
789 
801  function isMissing() {
802  if ( $this->missing === null ) {
803  list( $fileExists ) = $this->repo->fileExists( $this->getVirtualUrl() );
804  $this->missing = !$fileExists;
805  }
806 
807  return $this->missing;
808  }
809 
816  public function getWidth( $page = 1 ) {
817  $page = (int)$page;
818  if ( $page < 1 ) {
819  $page = 1;
820  }
821 
822  $this->load();
823 
824  if ( $this->isMultipage() ) {
825  $handler = $this->getHandler();
826  if ( !$handler ) {
827  return 0;
828  }
829  $dim = $handler->getPageDimensions( $this, $page );
830  if ( $dim ) {
831  return $dim['width'];
832  } else {
833  // For non-paged media, the false goes through an
834  // intval, turning failure into 0, so do same here.
835  return 0;
836  }
837  } else {
838  return $this->width;
839  }
840  }
841 
848  public function getHeight( $page = 1 ) {
849  $page = (int)$page;
850  if ( $page < 1 ) {
851  $page = 1;
852  }
853 
854  $this->load();
855 
856  if ( $this->isMultipage() ) {
857  $handler = $this->getHandler();
858  if ( !$handler ) {
859  return 0;
860  }
861  $dim = $handler->getPageDimensions( $this, $page );
862  if ( $dim ) {
863  return $dim['height'];
864  } else {
865  // For non-paged media, the false goes through an
866  // intval, turning failure into 0, so do same here.
867  return 0;
868  }
869  } else {
870  return $this->height;
871  }
872  }
873 
881  function getUser( $type = 'text' ) {
882  $this->load();
883 
884  if ( $type === 'object' ) {
885  return $this->user;
886  } elseif ( $type === 'text' ) {
887  return $this->user->getName();
888  } elseif ( $type === 'id' ) {
889  return $this->user->getId();
890  }
891 
892  throw new MWException( "Unknown type '$type'." );
893  }
894 
902  public function getDescriptionShortUrl() {
903  $pageId = $this->title->getArticleID();
904 
905  if ( $pageId !== null ) {
906  $url = $this->repo->makeUrl( [ 'curid' => $pageId ] );
907  if ( $url !== false ) {
908  return $url;
909  }
910  }
911  return null;
912  }
913 
918  function getMetadata() {
919  $this->load( self::LOAD_ALL ); // large metadata is loaded in another step
920  return $this->metadata;
921  }
922 
926  function getBitDepth() {
927  $this->load();
928 
929  return (int)$this->bits;
930  }
931 
936  public function getSize() {
937  $this->load();
938 
939  return $this->size;
940  }
941 
946  function getMimeType() {
947  $this->load();
948 
949  return $this->mime;
950  }
951 
957  function getMediaType() {
958  $this->load();
959 
960  return $this->media_type;
961  }
962 
973  public function exists() {
974  $this->load();
975 
976  return $this->fileExists;
977  }
978 
994  function getThumbnails( $archiveName = false ) {
995  if ( $archiveName ) {
996  $dir = $this->getArchiveThumbPath( $archiveName );
997  } else {
998  $dir = $this->getThumbPath();
999  }
1000 
1001  $backend = $this->repo->getBackend();
1002  $files = [ $dir ];
1003  try {
1004  $iterator = $backend->getFileList( [ 'dir' => $dir ] );
1005  foreach ( $iterator as $file ) {
1006  $files[] = $file;
1007  }
1008  } catch ( FileBackendError $e ) {
1009  } // suppress (T56674)
1010 
1011  return $files;
1012  }
1013 
1017  function purgeMetadataCache() {
1018  $this->invalidateCache();
1019  }
1020 
1028  function purgeCache( $options = [] ) {
1029  // Refresh metadata cache
1030  $this->purgeMetadataCache();
1031 
1032  // Delete thumbnails
1033  $this->purgeThumbnails( $options );
1034 
1035  // Purge CDN cache for this file
1037  new CdnCacheUpdate( [ $this->getUrl() ] ),
1039  );
1040  }
1041 
1046  function purgeOldThumbnails( $archiveName ) {
1047  // Get a list of old thumbnails and URLs
1048  $files = $this->getThumbnails( $archiveName );
1049 
1050  // Purge any custom thumbnail caches
1051  Hooks::run( 'LocalFilePurgeThumbnails', [ $this, $archiveName ] );
1052 
1053  // Delete thumbnails
1054  $dir = array_shift( $files );
1055  $this->purgeThumbList( $dir, $files );
1056 
1057  // Purge the CDN
1058  $urls = [];
1059  foreach ( $files as $file ) {
1060  $urls[] = $this->getArchiveThumbUrl( $archiveName, $file );
1061  }
1063  }
1064 
1069  public function purgeThumbnails( $options = [] ) {
1070  $files = $this->getThumbnails();
1071  // Always purge all files from CDN regardless of handler filters
1072  $urls = [];
1073  foreach ( $files as $file ) {
1074  $urls[] = $this->getThumbUrl( $file );
1075  }
1076  array_shift( $urls ); // don't purge directory
1077 
1078  // Give media handler a chance to filter the file purge list
1079  if ( !empty( $options['forThumbRefresh'] ) ) {
1080  $handler = $this->getHandler();
1081  if ( $handler ) {
1083  }
1084  }
1085 
1086  // Purge any custom thumbnail caches
1087  Hooks::run( 'LocalFilePurgeThumbnails', [ $this, false ] );
1088 
1089  // Delete thumbnails
1090  $dir = array_shift( $files );
1091  $this->purgeThumbList( $dir, $files );
1092 
1093  // Purge the CDN
1095  }
1096 
1102  public function prerenderThumbnails() {
1104 
1105  $jobs = [];
1106 
1107  $sizes = $wgUploadThumbnailRenderMap;
1108  rsort( $sizes );
1109 
1110  foreach ( $sizes as $size ) {
1111  if ( $this->isVectorized() || $this->getWidth() > $size ) {
1112  $jobs[] = new ThumbnailRenderJob(
1113  $this->getTitle(),
1114  [ 'transformParams' => [ 'width' => $size ] ]
1115  );
1116  }
1117  }
1118 
1119  if ( $jobs ) {
1120  JobQueueGroup::singleton()->lazyPush( $jobs );
1121  }
1122  }
1123 
1129  protected function purgeThumbList( $dir, $files ) {
1130  $fileListDebug = strtr(
1131  var_export( $files, true ),
1132  [ "\n" => '' ]
1133  );
1134  wfDebug( __METHOD__ . ": $fileListDebug\n" );
1135 
1136  $purgeList = [];
1137  foreach ( $files as $file ) {
1138  if ( $this->repo->supportsSha1URLs() ) {
1139  $reference = $this->getSha1();
1140  } else {
1141  $reference = $this->getName();
1142  }
1143 
1144  # Check that the reference (filename or sha1) is part of the thumb name
1145  # This is a basic sanity check to avoid erasing unrelated directories
1146  if ( strpos( $file, $reference ) !== false
1147  || strpos( $file, "-thumbnail" ) !== false // "short" thumb name
1148  ) {
1149  $purgeList[] = "{$dir}/{$file}";
1150  }
1151  }
1152 
1153  # Delete the thumbnails
1154  $this->repo->quickPurgeBatch( $purgeList );
1155  # Clear out the thumbnail directory if empty
1156  $this->repo->quickCleanDir( $dir );
1157  }
1158 
1169  function getHistory( $limit = null, $start = null, $end = null, $inc = true ) {
1170  $dbr = $this->repo->getReplicaDB();
1171  $oldFileQuery = OldLocalFile::getQueryInfo();
1172 
1173  $tables = $oldFileQuery['tables'];
1174  $fields = $oldFileQuery['fields'];
1175  $join_conds = $oldFileQuery['joins'];
1176  $conds = $opts = [];
1177  $eq = $inc ? '=' : '';
1178  $conds[] = "oi_name = " . $dbr->addQuotes( $this->title->getDBkey() );
1179 
1180  if ( $start ) {
1181  $conds[] = "oi_timestamp <$eq " . $dbr->addQuotes( $dbr->timestamp( $start ) );
1182  }
1183 
1184  if ( $end ) {
1185  $conds[] = "oi_timestamp >$eq " . $dbr->addQuotes( $dbr->timestamp( $end ) );
1186  }
1187 
1188  if ( $limit ) {
1189  $opts['LIMIT'] = $limit;
1190  }
1191 
1192  // Search backwards for time > x queries
1193  $order = ( !$start && $end !== null ) ? 'ASC' : 'DESC';
1194  $opts['ORDER BY'] = "oi_timestamp $order";
1195  $opts['USE INDEX'] = [ 'oldimage' => 'oi_name_timestamp' ];
1196 
1197  // Avoid PHP 7.1 warning from passing $this by reference
1198  $localFile = $this;
1199  Hooks::run( 'LocalFile::getHistory', [ &$localFile, &$tables, &$fields,
1200  &$conds, &$opts, &$join_conds ] );
1201 
1202  $res = $dbr->select( $tables, $fields, $conds, __METHOD__, $opts, $join_conds );
1203  $r = [];
1204 
1205  foreach ( $res as $row ) {
1206  $r[] = $this->repo->newFileFromRow( $row );
1207  }
1208 
1209  if ( $order == 'ASC' ) {
1210  $r = array_reverse( $r ); // make sure it ends up descending
1211  }
1212 
1213  return $r;
1214  }
1215 
1225  public function nextHistoryLine() {
1226  # Polymorphic function name to distinguish foreign and local fetches
1227  $fname = static::class . '::' . __FUNCTION__;
1228 
1229  $dbr = $this->repo->getReplicaDB();
1230 
1231  if ( $this->historyLine == 0 ) { // called for the first time, return line from cur
1232  $fileQuery = self::getQueryInfo();
1233  $this->historyRes = $dbr->select( $fileQuery['tables'],
1234  $fileQuery['fields'] + [
1235  'oi_archive_name' => $dbr->addQuotes( '' ),
1236  'oi_deleted' => 0,
1237  ],
1238  [ 'img_name' => $this->title->getDBkey() ],
1239  $fname,
1240  [],
1241  $fileQuery['joins']
1242  );
1243 
1244  if ( 0 == $dbr->numRows( $this->historyRes ) ) {
1245  $this->historyRes = null;
1246 
1247  return false;
1248  }
1249  } elseif ( $this->historyLine == 1 ) {
1250  $fileQuery = OldLocalFile::getQueryInfo();
1251  $this->historyRes = $dbr->select(
1252  $fileQuery['tables'],
1253  $fileQuery['fields'],
1254  [ 'oi_name' => $this->title->getDBkey() ],
1255  $fname,
1256  [ 'ORDER BY' => 'oi_timestamp DESC' ],
1257  $fileQuery['joins']
1258  );
1259  }
1260  $this->historyLine++;
1261 
1262  return $dbr->fetchObject( $this->historyRes );
1263  }
1264 
1268  public function resetHistory() {
1269  $this->historyLine = 0;
1270 
1271  if ( !is_null( $this->historyRes ) ) {
1272  $this->historyRes = null;
1273  }
1274  }
1275 
1306  function upload( $src, $comment, $pageText, $flags = 0, $props = false,
1307  $timestamp = false, $user = null, $tags = []
1308  ) {
1309  if ( $this->getRepo()->getReadOnlyReason() !== false ) {
1310  return $this->readOnlyFatalStatus();
1311  } elseif ( MediaWikiServices::getInstance()->getRevisionStore()->isReadOnly() ) {
1312  // Check this in advance to avoid writing to FileBackend and the file tables,
1313  // only to fail on insert the revision due to the text store being unavailable.
1314  return $this->readOnlyFatalStatus();
1315  }
1316 
1317  $srcPath = ( $src instanceof FSFile ) ? $src->getPath() : $src;
1318  if ( !$props ) {
1319  if ( $this->repo->isVirtualUrl( $srcPath )
1320  || FileBackend::isStoragePath( $srcPath )
1321  ) {
1322  $props = $this->repo->getFileProps( $srcPath );
1323  } else {
1324  $mwProps = new MWFileProps( MediaWiki\MediaWikiServices::getInstance()->getMimeAnalyzer() );
1325  $props = $mwProps->getPropsFromPath( $srcPath, true );
1326  }
1327  }
1328 
1329  $options = [];
1330  $handler = MediaHandler::getHandler( $props['mime'] );
1331  if ( $handler ) {
1332  $metadata = Wikimedia\quietCall( 'unserialize', $props['metadata'] );
1333 
1334  if ( !is_array( $metadata ) ) {
1335  $metadata = [];
1336  }
1337 
1338  $options['headers'] = $handler->getContentHeaders( $metadata );
1339  } else {
1340  $options['headers'] = [];
1341  }
1342 
1343  // Trim spaces on user supplied text
1344  $comment = trim( $comment );
1345 
1346  $this->lock(); // begin
1347  $status = $this->publish( $src, $flags, $options );
1348 
1349  if ( $status->successCount >= 2 ) {
1350  // There will be a copy+(one of move,copy,store).
1351  // The first succeeding does not commit us to updating the DB
1352  // since it simply copied the current version to a timestamped file name.
1353  // It is only *preferable* to avoid leaving such files orphaned.
1354  // Once the second operation goes through, then the current version was
1355  // updated and we must therefore update the DB too.
1356  $oldver = $status->value;
1357  $uploadStatus = $this->recordUpload2(
1358  $oldver,
1359  $comment,
1360  $pageText,
1361  $props,
1362  $timestamp,
1363  $user,
1364  $tags
1365  );
1366  if ( !$uploadStatus->isOK() ) {
1367  if ( $uploadStatus->hasMessage( 'filenotfound' ) ) {
1368  // update filenotfound error with more specific path
1369  $status->fatal( 'filenotfound', $srcPath );
1370  } else {
1371  $status->merge( $uploadStatus );
1372  }
1373  }
1374  }
1375 
1376  $this->unlock(); // done
1377 
1378  return $status;
1379  }
1380 
1393  function recordUpload( $oldver, $desc, $license = '', $copyStatus = '', $source = '',
1394  $watch = false, $timestamp = false, User $user = null ) {
1395  if ( !$user ) {
1396  global $wgUser;
1397  $user = $wgUser;
1398  }
1399 
1400  $pageText = SpecialUpload::getInitialPageText( $desc, $license, $copyStatus, $source );
1401 
1402  if ( !$this->recordUpload2( $oldver, $desc, $pageText, false, $timestamp, $user )->isOK() ) {
1403  return false;
1404  }
1405 
1406  if ( $watch ) {
1407  $user->addWatch( $this->getTitle() );
1408  }
1409 
1410  return true;
1411  }
1412 
1424  function recordUpload2(
1425  $oldver, $comment, $pageText, $props = false, $timestamp = false, $user = null, $tags = []
1426  ) {
1428 
1429  if ( is_null( $user ) ) {
1430  global $wgUser;
1431  $user = $wgUser;
1432  }
1433 
1434  $dbw = $this->repo->getMasterDB();
1435 
1436  # Imports or such might force a certain timestamp; otherwise we generate
1437  # it and can fudge it slightly to keep (name,timestamp) unique on re-upload.
1438  if ( $timestamp === false ) {
1439  $timestamp = $dbw->timestamp();
1440  $allowTimeKludge = true;
1441  } else {
1442  $allowTimeKludge = false;
1443  }
1444 
1445  $props = $props ?: $this->repo->getFileProps( $this->getVirtualUrl() );
1446  $props['description'] = $comment;
1447  $props['user'] = $user->getId();
1448  $props['user_text'] = $user->getName();
1449  $props['actor'] = $user->getActorId( $dbw );
1450  $props['timestamp'] = wfTimestamp( TS_MW, $timestamp ); // DB -> TS_MW
1451  $this->setProps( $props );
1452 
1453  # Fail now if the file isn't there
1454  if ( !$this->fileExists ) {
1455  wfDebug( __METHOD__ . ": File " . $this->getRel() . " went missing!\n" );
1456 
1457  return Status::newFatal( 'filenotfound', $this->getRel() );
1458  }
1459 
1460  $dbw->startAtomic( __METHOD__ );
1461 
1462  # Test to see if the row exists using INSERT IGNORE
1463  # This avoids race conditions by locking the row until the commit, and also
1464  # doesn't deadlock. SELECT FOR UPDATE causes a deadlock for every race condition.
1465  $commentStore = CommentStore::getStore();
1466  list( $commentFields, $commentCallback ) =
1467  $commentStore->insertWithTempTable( $dbw, 'img_description', $comment );
1468  $actorMigration = ActorMigration::newMigration();
1469  $actorFields = $actorMigration->getInsertValues( $dbw, 'img_user', $user );
1470  $dbw->insert( 'image',
1471  [
1472  'img_name' => $this->getName(),
1473  'img_size' => $this->size,
1474  'img_width' => intval( $this->width ),
1475  'img_height' => intval( $this->height ),
1476  'img_bits' => $this->bits,
1477  'img_media_type' => $this->media_type,
1478  'img_major_mime' => $this->major_mime,
1479  'img_minor_mime' => $this->minor_mime,
1480  'img_timestamp' => $timestamp,
1481  'img_metadata' => $dbw->encodeBlob( $this->metadata ),
1482  'img_sha1' => $this->sha1
1483  ] + $commentFields + $actorFields,
1484  __METHOD__,
1485  'IGNORE'
1486  );
1487  $reupload = ( $dbw->affectedRows() == 0 );
1488 
1489  if ( $reupload ) {
1490  $row = $dbw->selectRow(
1491  'image',
1492  [ 'img_timestamp', 'img_sha1' ],
1493  [ 'img_name' => $this->getName() ],
1494  __METHOD__,
1495  [ 'LOCK IN SHARE MODE' ]
1496  );
1497 
1498  if ( $row && $row->img_sha1 === $this->sha1 ) {
1499  $dbw->endAtomic( __METHOD__ );
1500  wfDebug( __METHOD__ . ": File " . $this->getRel() . " already exists!\n" );
1501  $title = Title::newFromText( $this->getName(), NS_FILE );
1502  return Status::newFatal( 'fileexists-no-change', $title->getPrefixedText() );
1503  }
1504 
1505  if ( $allowTimeKludge ) {
1506  # Use LOCK IN SHARE MODE to ignore any transaction snapshotting
1507  $lUnixtime = $row ? wfTimestamp( TS_UNIX, $row->img_timestamp ) : false;
1508  # Avoid a timestamp that is not newer than the last version
1509  # TODO: the image/oldimage tables should be like page/revision with an ID field
1510  if ( $lUnixtime && wfTimestamp( TS_UNIX, $timestamp ) <= $lUnixtime ) {
1511  sleep( 1 ); // fast enough re-uploads would go far in the future otherwise
1512  $timestamp = $dbw->timestamp( $lUnixtime + 1 );
1513  $this->timestamp = wfTimestamp( TS_MW, $timestamp ); // DB -> TS_MW
1514  }
1515  }
1516 
1517  $tables = [ 'image' ];
1518  $fields = [
1519  'oi_name' => 'img_name',
1520  'oi_archive_name' => $dbw->addQuotes( $oldver ),
1521  'oi_size' => 'img_size',
1522  'oi_width' => 'img_width',
1523  'oi_height' => 'img_height',
1524  'oi_bits' => 'img_bits',
1525  'oi_timestamp' => 'img_timestamp',
1526  'oi_metadata' => 'img_metadata',
1527  'oi_media_type' => 'img_media_type',
1528  'oi_major_mime' => 'img_major_mime',
1529  'oi_minor_mime' => 'img_minor_mime',
1530  'oi_sha1' => 'img_sha1',
1531  ];
1532  $joins = [];
1533 
1535  $fields['oi_description'] = 'img_description';
1536  }
1538  $tables[] = 'image_comment_temp';
1539  $fields['oi_description_id'] = 'imgcomment_description_id';
1540  $joins['image_comment_temp'] = [
1541  $wgCommentTableSchemaMigrationStage === MIGRATION_NEW ? 'JOIN' : 'LEFT JOIN',
1542  [ 'imgcomment_name = img_name' ]
1543  ];
1544  }
1545 
1548  ) {
1549  // Upgrade any rows that are still old-style. Otherwise an upgrade
1550  // might be missed if a deletion happens while the migration script
1551  // is running.
1552  $res = $dbw->select(
1553  [ 'image', 'image_comment_temp' ],
1554  [ 'img_name', 'img_description' ],
1555  [ 'img_name' => $this->getName(), 'imgcomment_name' => null ],
1556  __METHOD__,
1557  [],
1558  [ 'image_comment_temp' => [ 'LEFT JOIN', [ 'imgcomment_name = img_name' ] ] ]
1559  );
1560  foreach ( $res as $row ) {
1561  list( , $callback ) = $commentStore->insertWithTempTable(
1562  $dbw, 'img_description', $row->img_description
1563  );
1564  $callback( $row->img_name );
1565  }
1566  }
1567 
1569  $fields['oi_user'] = 'img_user';
1570  $fields['oi_user_text'] = 'img_user_text';
1571  }
1573  $fields['oi_actor'] = 'img_actor';
1574  }
1575 
1578  ) {
1579  // Upgrade any rows that are still old-style. Otherwise an upgrade
1580  // might be missed if a deletion happens while the migration script
1581  // is running.
1582  $res = $dbw->select(
1583  [ 'image' ],
1584  [ 'img_name', 'img_user', 'img_user_text' ],
1585  [ 'img_name' => $this->getName(), 'img_actor' => 0 ],
1586  __METHOD__
1587  );
1588  foreach ( $res as $row ) {
1589  $actorId = User::newFromAnyId( $row->img_user, $row->img_user_text, null )->getActorId( $dbw );
1590  $dbw->update(
1591  'image',
1592  [ 'img_actor' => $actorId ],
1593  [ 'img_name' => $row->img_name, 'img_actor' => 0 ],
1594  __METHOD__
1595  );
1596  }
1597  }
1598 
1599  # (T36993) Note: $oldver can be empty here, if the previous
1600  # version of the file was broken. Allow registration of the new
1601  # version to continue anyway, because that's better than having
1602  # an image that's not fixable by user operations.
1603  # Collision, this is an update of a file
1604  # Insert previous contents into oldimage
1605  $dbw->insertSelect( 'oldimage', $tables, $fields,
1606  [ 'img_name' => $this->getName() ], __METHOD__, [], [], $joins );
1607 
1608  # Update the current image row
1609  $dbw->update( 'image',
1610  [
1611  'img_size' => $this->size,
1612  'img_width' => intval( $this->width ),
1613  'img_height' => intval( $this->height ),
1614  'img_bits' => $this->bits,
1615  'img_media_type' => $this->media_type,
1616  'img_major_mime' => $this->major_mime,
1617  'img_minor_mime' => $this->minor_mime,
1618  'img_timestamp' => $timestamp,
1619  'img_metadata' => $dbw->encodeBlob( $this->metadata ),
1620  'img_sha1' => $this->sha1
1621  ] + $commentFields + $actorFields,
1622  [ 'img_name' => $this->getName() ],
1623  __METHOD__
1624  );
1626  // So $commentCallback can insert the new row
1627  $dbw->delete( 'image_comment_temp', [ 'imgcomment_name' => $this->getName() ], __METHOD__ );
1628  }
1629  }
1630  $commentCallback( $this->getName() );
1631 
1632  $descTitle = $this->getTitle();
1633  $descId = $descTitle->getArticleID();
1634  $wikiPage = new WikiFilePage( $descTitle );
1635  $wikiPage->setFile( $this );
1636 
1637  // Add the log entry...
1638  $logEntry = new ManualLogEntry( 'upload', $reupload ? 'overwrite' : 'upload' );
1639  $logEntry->setTimestamp( $this->timestamp );
1640  $logEntry->setPerformer( $user );
1641  $logEntry->setComment( $comment );
1642  $logEntry->setTarget( $descTitle );
1643  // Allow people using the api to associate log entries with the upload.
1644  // Log has a timestamp, but sometimes different from upload timestamp.
1645  $logEntry->setParameters(
1646  [
1647  'img_sha1' => $this->sha1,
1648  'img_timestamp' => $timestamp,
1649  ]
1650  );
1651  // Note we keep $logId around since during new image
1652  // creation, page doesn't exist yet, so log_page = 0
1653  // but we want it to point to the page we're making,
1654  // so we later modify the log entry.
1655  // For a similar reason, we avoid making an RC entry
1656  // now and wait until the page exists.
1657  $logId = $logEntry->insert();
1658 
1659  if ( $descTitle->exists() ) {
1660  // Use own context to get the action text in content language
1661  $formatter = LogFormatter::newFromEntry( $logEntry );
1662  $formatter->setContext( RequestContext::newExtraneousContext( $descTitle ) );
1663  $editSummary = $formatter->getPlainActionText();
1664 
1665  $nullRevision = Revision::newNullRevision(
1666  $dbw,
1667  $descId,
1668  $editSummary,
1669  false,
1670  $user
1671  );
1672  if ( $nullRevision ) {
1673  $nullRevision->insertOn( $dbw );
1674  Hooks::run(
1675  'NewRevisionFromEditComplete',
1676  [ $wikiPage, $nullRevision, $nullRevision->getParentId(), $user ]
1677  );
1678  $wikiPage->updateRevisionOn( $dbw, $nullRevision );
1679  // Associate null revision id
1680  $logEntry->setAssociatedRevId( $nullRevision->getId() );
1681  }
1682 
1683  $newPageContent = null;
1684  } else {
1685  // Make the description page and RC log entry post-commit
1686  $newPageContent = ContentHandler::makeContent( $pageText, $descTitle );
1687  }
1688 
1689  # Defer purges, page creation, and link updates in case they error out.
1690  # The most important thing is that files and the DB registry stay synced.
1691  $dbw->endAtomic( __METHOD__ );
1692 
1693  # Do some cache purges after final commit so that:
1694  # a) Changes are more likely to be seen post-purge
1695  # b) They won't cause rollback of the log publish/update above
1697  new AutoCommitUpdate(
1698  $dbw,
1699  __METHOD__,
1700  function () use (
1701  $reupload, $wikiPage, $newPageContent, $comment, $user,
1702  $logEntry, $logId, $descId, $tags
1703  ) {
1704  # Update memcache after the commit
1705  $this->invalidateCache();
1706 
1707  $updateLogPage = false;
1708  if ( $newPageContent ) {
1709  # New file page; create the description page.
1710  # There's already a log entry, so don't make a second RC entry
1711  # CDN and file cache for the description page are purged by doEditContent.
1712  $status = $wikiPage->doEditContent(
1713  $newPageContent,
1714  $comment,
1716  false,
1717  $user
1718  );
1719 
1720  if ( isset( $status->value['revision'] ) ) {
1722  $rev = $status->value['revision'];
1723  // Associate new page revision id
1724  $logEntry->setAssociatedRevId( $rev->getId() );
1725  }
1726  // This relies on the resetArticleID() call in WikiPage::insertOn(),
1727  // which is triggered on $descTitle by doEditContent() above.
1728  if ( isset( $status->value['revision'] ) ) {
1730  $rev = $status->value['revision'];
1731  $updateLogPage = $rev->getPage();
1732  }
1733  } else {
1734  # Existing file page: invalidate description page cache
1735  $wikiPage->getTitle()->invalidateCache();
1736  $wikiPage->getTitle()->purgeSquid();
1737  # Allow the new file version to be patrolled from the page footer
1739  }
1740 
1741  # Update associated rev id. This should be done by $logEntry->insert() earlier,
1742  # but setAssociatedRevId() wasn't called at that point yet...
1743  $logParams = $logEntry->getParameters();
1744  $logParams['associated_rev_id'] = $logEntry->getAssociatedRevId();
1745  $update = [ 'log_params' => LogEntryBase::makeParamBlob( $logParams ) ];
1746  if ( $updateLogPage ) {
1747  # Also log page, in case where we just created it above
1748  $update['log_page'] = $updateLogPage;
1749  }
1750  $this->getRepo()->getMasterDB()->update(
1751  'logging',
1752  $update,
1753  [ 'log_id' => $logId ],
1754  __METHOD__
1755  );
1756  $this->getRepo()->getMasterDB()->insert(
1757  'log_search',
1758  [
1759  'ls_field' => 'associated_rev_id',
1760  'ls_value' => $logEntry->getAssociatedRevId(),
1761  'ls_log_id' => $logId,
1762  ],
1763  __METHOD__
1764  );
1765 
1766  # Add change tags, if any
1767  if ( $tags ) {
1768  $logEntry->setTags( $tags );
1769  }
1770 
1771  # Uploads can be patrolled
1772  $logEntry->setIsPatrollable( true );
1773 
1774  # Now that the log entry is up-to-date, make an RC entry.
1775  $logEntry->publish( $logId );
1776 
1777  # Run hook for other updates (typically more cache purging)
1778  Hooks::run( 'FileUpload', [ $this, $reupload, !$newPageContent ] );
1779 
1780  if ( $reupload ) {
1781  # Delete old thumbnails
1782  $this->purgeThumbnails();
1783  # Remove the old file from the CDN cache
1785  new CdnCacheUpdate( [ $this->getUrl() ] ),
1787  );
1788  } else {
1789  # Update backlink pages pointing to this title if created
1791  $this->getTitle(),
1792  'imagelinks',
1793  'upload-image',
1794  $user->getName()
1795  );
1796  }
1797 
1798  $this->prerenderThumbnails();
1799  }
1800  ),
1802  );
1803 
1804  if ( !$reupload ) {
1805  # This is a new file, so update the image count
1806  DeferredUpdates::addUpdate( SiteStatsUpdate::factory( [ 'images' => 1 ] ) );
1807  }
1808 
1809  # Invalidate cache for all pages using this file
1811  new HTMLCacheUpdate( $this->getTitle(), 'imagelinks', 'file-upload' )
1812  );
1813 
1814  return Status::newGood();
1815  }
1816 
1832  function publish( $src, $flags = 0, array $options = [] ) {
1833  return $this->publishTo( $src, $this->getRel(), $flags, $options );
1834  }
1835 
1851  function publishTo( $src, $dstRel, $flags = 0, array $options = [] ) {
1852  $srcPath = ( $src instanceof FSFile ) ? $src->getPath() : $src;
1853 
1854  $repo = $this->getRepo();
1855  if ( $repo->getReadOnlyReason() !== false ) {
1856  return $this->readOnlyFatalStatus();
1857  }
1858 
1859  $this->lock(); // begin
1860 
1861  $archiveName = wfTimestamp( TS_MW ) . '!' . $this->getName();
1862  $archiveRel = 'archive/' . $this->getHashPath() . $archiveName;
1863 
1864  if ( $repo->hasSha1Storage() ) {
1865  $sha1 = $repo->isVirtualUrl( $srcPath )
1866  ? $repo->getFileSha1( $srcPath )
1867  : FSFile::getSha1Base36FromPath( $srcPath );
1869  $wrapperBackend = $repo->getBackend();
1870  $dst = $wrapperBackend->getPathForSHA1( $sha1 );
1871  $status = $repo->quickImport( $src, $dst );
1872  if ( $flags & File::DELETE_SOURCE ) {
1873  unlink( $srcPath );
1874  }
1875 
1876  if ( $this->exists() ) {
1877  $status->value = $archiveName;
1878  }
1879  } else {
1880  $flags = $flags & File::DELETE_SOURCE ? LocalRepo::DELETE_SOURCE : 0;
1881  $status = $repo->publish( $srcPath, $dstRel, $archiveRel, $flags, $options );
1882 
1883  if ( $status->value == 'new' ) {
1884  $status->value = '';
1885  } else {
1886  $status->value = $archiveName;
1887  }
1888  }
1889 
1890  $this->unlock(); // done
1891 
1892  return $status;
1893  }
1894 
1912  function move( $target ) {
1913  if ( $this->getRepo()->getReadOnlyReason() !== false ) {
1914  return $this->readOnlyFatalStatus();
1915  }
1916 
1917  wfDebugLog( 'imagemove', "Got request to move {$this->name} to " . $target->getText() );
1918  $batch = new LocalFileMoveBatch( $this, $target );
1919 
1920  $this->lock(); // begin
1921  $batch->addCurrent();
1922  $archiveNames = $batch->addOlds();
1923  $status = $batch->execute();
1924  $this->unlock(); // done
1925 
1926  wfDebugLog( 'imagemove', "Finished moving {$this->name}" );
1927 
1928  // Purge the source and target files...
1929  $oldTitleFile = wfLocalFile( $this->title );
1930  $newTitleFile = wfLocalFile( $target );
1931  // To avoid slow purges in the transaction, move them outside...
1933  new AutoCommitUpdate(
1934  $this->getRepo()->getMasterDB(),
1935  __METHOD__,
1936  function () use ( $oldTitleFile, $newTitleFile, $archiveNames ) {
1937  $oldTitleFile->purgeEverything();
1938  foreach ( $archiveNames as $archiveName ) {
1939  $oldTitleFile->purgeOldThumbnails( $archiveName );
1940  }
1941  $newTitleFile->purgeEverything();
1942  }
1943  ),
1945  );
1946 
1947  if ( $status->isOK() ) {
1948  // Now switch the object
1949  $this->title = $target;
1950  // Force regeneration of the name and hashpath
1951  unset( $this->name );
1952  unset( $this->hashPath );
1953  }
1954 
1955  return $status;
1956  }
1957 
1971  function delete( $reason, $suppress = false, $user = null ) {
1972  if ( $this->getRepo()->getReadOnlyReason() !== false ) {
1973  return $this->readOnlyFatalStatus();
1974  }
1975 
1976  $batch = new LocalFileDeleteBatch( $this, $reason, $suppress, $user );
1977 
1978  $this->lock(); // begin
1979  $batch->addCurrent();
1980  // Get old version relative paths
1981  $archiveNames = $batch->addOlds();
1982  $status = $batch->execute();
1983  $this->unlock(); // done
1984 
1985  if ( $status->isOK() ) {
1986  DeferredUpdates::addUpdate( SiteStatsUpdate::factory( [ 'images' => -1 ] ) );
1987  }
1988 
1989  // To avoid slow purges in the transaction, move them outside...
1991  new AutoCommitUpdate(
1992  $this->getRepo()->getMasterDB(),
1993  __METHOD__,
1994  function () use ( $archiveNames ) {
1995  $this->purgeEverything();
1996  foreach ( $archiveNames as $archiveName ) {
1997  $this->purgeOldThumbnails( $archiveName );
1998  }
1999  }
2000  ),
2002  );
2003 
2004  // Purge the CDN
2005  $purgeUrls = [];
2006  foreach ( $archiveNames as $archiveName ) {
2007  $purgeUrls[] = $this->getArchiveUrl( $archiveName );
2008  }
2010 
2011  return $status;
2012  }
2013 
2029  function deleteOld( $archiveName, $reason, $suppress = false, $user = null ) {
2030  if ( $this->getRepo()->getReadOnlyReason() !== false ) {
2031  return $this->readOnlyFatalStatus();
2032  }
2033 
2034  $batch = new LocalFileDeleteBatch( $this, $reason, $suppress, $user );
2035 
2036  $this->lock(); // begin
2037  $batch->addOld( $archiveName );
2038  $status = $batch->execute();
2039  $this->unlock(); // done
2040 
2041  $this->purgeOldThumbnails( $archiveName );
2042  if ( $status->isOK() ) {
2043  $this->purgeDescription();
2044  }
2045 
2047  new CdnCacheUpdate( [ $this->getArchiveUrl( $archiveName ) ] ),
2049  );
2050 
2051  return $status;
2052  }
2053 
2065  function restore( $versions = [], $unsuppress = false ) {
2066  if ( $this->getRepo()->getReadOnlyReason() !== false ) {
2067  return $this->readOnlyFatalStatus();
2068  }
2069 
2070  $batch = new LocalFileRestoreBatch( $this, $unsuppress );
2071 
2072  $this->lock(); // begin
2073  if ( !$versions ) {
2074  $batch->addAll();
2075  } else {
2076  $batch->addIds( $versions );
2077  }
2078  $status = $batch->execute();
2079  if ( $status->isGood() ) {
2080  $cleanupStatus = $batch->cleanup();
2081  $cleanupStatus->successCount = 0;
2082  $cleanupStatus->failCount = 0;
2083  $status->merge( $cleanupStatus );
2084  }
2085  $this->unlock(); // done
2086 
2087  return $status;
2088  }
2089 
2099  function getDescriptionUrl() {
2100  return $this->title->getLocalURL();
2101  }
2102 
2111  function getDescriptionText( $lang = null ) {
2112  $revision = Revision::newFromTitle( $this->title, false, Revision::READ_NORMAL );
2113  if ( !$revision ) {
2114  return false;
2115  }
2116  $content = $revision->getContent();
2117  if ( !$content ) {
2118  return false;
2119  }
2120  $pout = $content->getParserOutput( $this->title, null, new ParserOptions( null, $lang ) );
2121 
2122  return $pout->getText();
2123  }
2124 
2130  function getDescription( $audience = self::FOR_PUBLIC, User $user = null ) {
2131  $this->load();
2132  if ( $audience == self::FOR_PUBLIC && $this->isDeleted( self::DELETED_COMMENT ) ) {
2133  return '';
2134  } elseif ( $audience == self::FOR_THIS_USER
2135  && !$this->userCan( self::DELETED_COMMENT, $user )
2136  ) {
2137  return '';
2138  } else {
2139  return $this->description;
2140  }
2141  }
2142 
2146  function getTimestamp() {
2147  $this->load();
2148 
2149  return $this->timestamp;
2150  }
2151 
2155  public function getDescriptionTouched() {
2156  // The DB lookup might return false, e.g. if the file was just deleted, or the shared DB repo
2157  // itself gets it from elsewhere. To avoid repeating the DB lookups in such a case, we
2158  // need to differentiate between null (uninitialized) and false (failed to load).
2159  if ( $this->descriptionTouched === null ) {
2160  $cond = [
2161  'page_namespace' => $this->title->getNamespace(),
2162  'page_title' => $this->title->getDBkey()
2163  ];
2164  $touched = $this->repo->getReplicaDB()->selectField( 'page', 'page_touched', $cond, __METHOD__ );
2165  $this->descriptionTouched = $touched ? wfTimestamp( TS_MW, $touched ) : false;
2166  }
2167 
2169  }
2170 
2174  function getSha1() {
2175  $this->load();
2176  // Initialise now if necessary
2177  if ( $this->sha1 == '' && $this->fileExists ) {
2178  $this->lock(); // begin
2179 
2180  $this->sha1 = $this->repo->getFileSha1( $this->getPath() );
2181  if ( !wfReadOnly() && strval( $this->sha1 ) != '' ) {
2182  $dbw = $this->repo->getMasterDB();
2183  $dbw->update( 'image',
2184  [ 'img_sha1' => $this->sha1 ],
2185  [ 'img_name' => $this->getName() ],
2186  __METHOD__ );
2187  $this->invalidateCache();
2188  }
2189 
2190  $this->unlock(); // done
2191  }
2192 
2193  return $this->sha1;
2194  }
2195 
2199  function isCacheable() {
2200  $this->load();
2201 
2202  // If extra data (metadata) was not loaded then it must have been large
2203  return $this->extraDataLoaded
2204  && strlen( serialize( $this->metadata ) ) <= self::CACHE_FIELD_MAX_LEN;
2205  }
2206 
2211  public function acquireFileLock() {
2212  return $this->getRepo()->getBackend()->lockFiles(
2213  [ $this->getPath() ], LockManager::LOCK_EX, 10
2214  );
2215  }
2216 
2221  public function releaseFileLock() {
2222  return $this->getRepo()->getBackend()->unlockFiles(
2223  [ $this->getPath() ], LockManager::LOCK_EX
2224  );
2225  }
2226 
2236  public function lock() {
2237  if ( !$this->locked ) {
2238  $logger = LoggerFactory::getInstance( 'LocalFile' );
2239 
2240  $dbw = $this->repo->getMasterDB();
2241  $makesTransaction = !$dbw->trxLevel();
2242  $dbw->startAtomic( self::ATOMIC_SECTION_LOCK );
2243  // T56736: use simple lock to handle when the file does not exist.
2244  // SELECT FOR UPDATE prevents changes, not other SELECTs with FOR UPDATE.
2245  // Also, that would cause contention on INSERT of similarly named rows.
2246  $status = $this->acquireFileLock(); // represents all versions of the file
2247  if ( !$status->isGood() ) {
2248  $dbw->endAtomic( self::ATOMIC_SECTION_LOCK );
2249  $logger->warning( "Failed to lock '{file}'", [ 'file' => $this->name ] );
2250 
2251  throw new LocalFileLockError( $status );
2252  }
2253  // Release the lock *after* commit to avoid row-level contention.
2254  // Make sure it triggers on rollback() as well as commit() (T132921).
2255  $dbw->onTransactionResolution(
2256  function () use ( $logger ) {
2257  $status = $this->releaseFileLock();
2258  if ( !$status->isGood() ) {
2259  $logger->error( "Failed to unlock '{file}'", [ 'file' => $this->name ] );
2260  }
2261  },
2262  __METHOD__
2263  );
2264  // Callers might care if the SELECT snapshot is safely fresh
2265  $this->lockedOwnTrx = $makesTransaction;
2266  }
2267 
2268  $this->locked++;
2269 
2270  return $this->lockedOwnTrx;
2271  }
2272 
2281  public function unlock() {
2282  if ( $this->locked ) {
2283  --$this->locked;
2284  if ( !$this->locked ) {
2285  $dbw = $this->repo->getMasterDB();
2286  $dbw->endAtomic( self::ATOMIC_SECTION_LOCK );
2287  $this->lockedOwnTrx = false;
2288  }
2289  }
2290  }
2291 
2295  protected function readOnlyFatalStatus() {
2296  return $this->getRepo()->newFatal( 'filereadonlyerror', $this->getName(),
2297  $this->getRepo()->getName(), $this->getRepo()->getReadOnlyReason() );
2298  }
2299 
2303  function __destruct() {
2304  $this->unlock();
2305  }
2306 } // LocalFile class
2307 
2308 # ------------------------------------------------------------------------------
2309 
2316  private $file;
2317 
2319  private $reason;
2320 
2322  private $srcRels = [];
2323 
2325  private $archiveUrls = [];
2326 
2329 
2331  private $suppress;
2332 
2334  private $status;
2335 
2337  private $user;
2338 
2345  function __construct( File $file, $reason = '', $suppress = false, $user = null ) {
2346  $this->file = $file;
2347  $this->reason = $reason;
2348  $this->suppress = $suppress;
2349  if ( $user ) {
2350  $this->user = $user;
2351  } else {
2352  global $wgUser;
2353  $this->user = $wgUser;
2354  }
2355  $this->status = $file->repo->newGood();
2356  }
2357 
2358  public function addCurrent() {
2359  $this->srcRels['.'] = $this->file->getRel();
2360  }
2361 
2365  public function addOld( $oldName ) {
2366  $this->srcRels[$oldName] = $this->file->getArchiveRel( $oldName );
2367  $this->archiveUrls[] = $this->file->getArchiveUrl( $oldName );
2368  }
2369 
2374  public function addOlds() {
2375  $archiveNames = [];
2376 
2377  $dbw = $this->file->repo->getMasterDB();
2378  $result = $dbw->select( 'oldimage',
2379  [ 'oi_archive_name' ],
2380  [ 'oi_name' => $this->file->getName() ],
2381  __METHOD__
2382  );
2383 
2384  foreach ( $result as $row ) {
2385  $this->addOld( $row->oi_archive_name );
2386  $archiveNames[] = $row->oi_archive_name;
2387  }
2388 
2389  return $archiveNames;
2390  }
2391 
2395  protected function getOldRels() {
2396  if ( !isset( $this->srcRels['.'] ) ) {
2397  $oldRels =& $this->srcRels;
2398  $deleteCurrent = false;
2399  } else {
2400  $oldRels = $this->srcRels;
2401  unset( $oldRels['.'] );
2402  $deleteCurrent = true;
2403  }
2404 
2405  return [ $oldRels, $deleteCurrent ];
2406  }
2407 
2411  protected function getHashes() {
2412  $hashes = [];
2413  list( $oldRels, $deleteCurrent ) = $this->getOldRels();
2414 
2415  if ( $deleteCurrent ) {
2416  $hashes['.'] = $this->file->getSha1();
2417  }
2418 
2419  if ( count( $oldRels ) ) {
2420  $dbw = $this->file->repo->getMasterDB();
2421  $res = $dbw->select(
2422  'oldimage',
2423  [ 'oi_archive_name', 'oi_sha1' ],
2424  [ 'oi_archive_name' => array_keys( $oldRels ),
2425  'oi_name' => $this->file->getName() ], // performance
2426  __METHOD__
2427  );
2428 
2429  foreach ( $res as $row ) {
2430  if ( rtrim( $row->oi_sha1, "\0" ) === '' ) {
2431  // Get the hash from the file
2432  $oldUrl = $this->file->getArchiveVirtualUrl( $row->oi_archive_name );
2433  $props = $this->file->repo->getFileProps( $oldUrl );
2434 
2435  if ( $props['fileExists'] ) {
2436  // Upgrade the oldimage row
2437  $dbw->update( 'oldimage',
2438  [ 'oi_sha1' => $props['sha1'] ],
2439  [ 'oi_name' => $this->file->getName(), 'oi_archive_name' => $row->oi_archive_name ],
2440  __METHOD__ );
2441  $hashes[$row->oi_archive_name] = $props['sha1'];
2442  } else {
2443  $hashes[$row->oi_archive_name] = false;
2444  }
2445  } else {
2446  $hashes[$row->oi_archive_name] = $row->oi_sha1;
2447  }
2448  }
2449  }
2450 
2451  $missing = array_diff_key( $this->srcRels, $hashes );
2452 
2453  foreach ( $missing as $name => $rel ) {
2454  $this->status->error( 'filedelete-old-unregistered', $name );
2455  }
2456 
2457  foreach ( $hashes as $name => $hash ) {
2458  if ( !$hash ) {
2459  $this->status->error( 'filedelete-missing', $this->srcRels[$name] );
2460  unset( $hashes[$name] );
2461  }
2462  }
2463 
2464  return $hashes;
2465  }
2466 
2467  protected function doDBInserts() {
2469 
2470  $now = time();
2471  $dbw = $this->file->repo->getMasterDB();
2472 
2473  $commentStore = CommentStore::getStore();
2474  $actorMigration = ActorMigration::newMigration();
2475 
2476  $encTimestamp = $dbw->addQuotes( $dbw->timestamp( $now ) );
2477  $encUserId = $dbw->addQuotes( $this->user->getId() );
2478  $encGroup = $dbw->addQuotes( 'deleted' );
2479  $ext = $this->file->getExtension();
2480  $dotExt = $ext === '' ? '' : ".$ext";
2481  $encExt = $dbw->addQuotes( $dotExt );
2482  list( $oldRels, $deleteCurrent ) = $this->getOldRels();
2483 
2484  // Bitfields to further suppress the content
2485  if ( $this->suppress ) {
2486  $bitfield = Revision::SUPPRESSED_ALL;
2487  } else {
2488  $bitfield = 'oi_deleted';
2489  }
2490 
2491  if ( $deleteCurrent ) {
2492  $tables = [ 'image' ];
2493  $fields = [
2494  'fa_storage_group' => $encGroup,
2495  'fa_storage_key' => $dbw->conditional(
2496  [ 'img_sha1' => '' ],
2497  $dbw->addQuotes( '' ),
2498  $dbw->buildConcat( [ "img_sha1", $encExt ] )
2499  ),
2500  'fa_deleted_user' => $encUserId,
2501  'fa_deleted_timestamp' => $encTimestamp,
2502  'fa_deleted' => $this->suppress ? $bitfield : 0,
2503  'fa_name' => 'img_name',
2504  'fa_archive_name' => 'NULL',
2505  'fa_size' => 'img_size',
2506  'fa_width' => 'img_width',
2507  'fa_height' => 'img_height',
2508  'fa_metadata' => 'img_metadata',
2509  'fa_bits' => 'img_bits',
2510  'fa_media_type' => 'img_media_type',
2511  'fa_major_mime' => 'img_major_mime',
2512  'fa_minor_mime' => 'img_minor_mime',
2513  'fa_timestamp' => 'img_timestamp',
2514  'fa_sha1' => 'img_sha1'
2515  ];
2516  $joins = [];
2517 
2518  $fields += array_map(
2519  [ $dbw, 'addQuotes' ],
2520  $commentStore->insert( $dbw, 'fa_deleted_reason', $this->reason )
2521  );
2522 
2524  $fields['fa_description'] = 'img_description';
2525  }
2527  $tables[] = 'image_comment_temp';
2528  $fields['fa_description_id'] = 'imgcomment_description_id';
2529  $joins['image_comment_temp'] = [
2530  $wgCommentTableSchemaMigrationStage === MIGRATION_NEW ? 'JOIN' : 'LEFT JOIN',
2531  [ 'imgcomment_name = img_name' ]
2532  ];
2533  }
2534 
2537  ) {
2538  // Upgrade any rows that are still old-style. Otherwise an upgrade
2539  // might be missed if a deletion happens while the migration script
2540  // is running.
2541  $res = $dbw->select(
2542  [ 'image', 'image_comment_temp' ],
2543  [ 'img_name', 'img_description' ],
2544  [ 'img_name' => $this->file->getName(), 'imgcomment_name' => null ],
2545  __METHOD__,
2546  [],
2547  [ 'image_comment_temp' => [ 'LEFT JOIN', [ 'imgcomment_name = img_name' ] ] ]
2548  );
2549  foreach ( $res as $row ) {
2550  list( , $callback ) = $commentStore->insertWithTempTable(
2551  $dbw, 'img_description', $row->img_description
2552  );
2553  $callback( $row->img_name );
2554  }
2555  }
2556 
2558  $fields['fa_user'] = 'img_user';
2559  $fields['fa_user_text'] = 'img_user_text';
2560  }
2562  $fields['fa_actor'] = 'img_actor';
2563  }
2564 
2567  ) {
2568  // Upgrade any rows that are still old-style. Otherwise an upgrade
2569  // might be missed if a deletion happens while the migration script
2570  // is running.
2571  $res = $dbw->select(
2572  [ 'image' ],
2573  [ 'img_name', 'img_user', 'img_user_text' ],
2574  [ 'img_name' => $this->file->getName(), 'img_actor' => 0 ],
2575  __METHOD__
2576  );
2577  foreach ( $res as $row ) {
2578  $actorId = User::newFromAnyId( $row->img_user, $row->img_user_text, null )->getActorId( $dbw );
2579  $dbw->update(
2580  'image',
2581  [ 'img_actor' => $actorId ],
2582  [ 'img_name' => $row->img_name, 'img_actor' => 0 ],
2583  __METHOD__
2584  );
2585  }
2586  }
2587 
2588  $dbw->insertSelect( 'filearchive', $tables, $fields,
2589  [ 'img_name' => $this->file->getName() ], __METHOD__, [], [], $joins );
2590  }
2591 
2592  if ( count( $oldRels ) ) {
2593  $fileQuery = OldLocalFile::getQueryInfo();
2594  $res = $dbw->select(
2595  $fileQuery['tables'],
2596  $fileQuery['fields'],
2597  [
2598  'oi_name' => $this->file->getName(),
2599  'oi_archive_name' => array_keys( $oldRels )
2600  ],
2601  __METHOD__,
2602  [ 'FOR UPDATE' ],
2603  $fileQuery['joins']
2604  );
2605  $rowsInsert = [];
2606  if ( $res->numRows() ) {
2607  $reason = $commentStore->createComment( $dbw, $this->reason );
2608  foreach ( $res as $row ) {
2609  $comment = $commentStore->getComment( 'oi_description', $row );
2610  $user = User::newFromAnyId( $row->oi_user, $row->oi_user_text, $row->oi_actor );
2611  $rowsInsert[] = [
2612  // Deletion-specific fields
2613  'fa_storage_group' => 'deleted',
2614  'fa_storage_key' => ( $row->oi_sha1 === '' )
2615  ? ''
2616  : "{$row->oi_sha1}{$dotExt}",
2617  'fa_deleted_user' => $this->user->getId(),
2618  'fa_deleted_timestamp' => $dbw->timestamp( $now ),
2619  // Counterpart fields
2620  'fa_deleted' => $this->suppress ? $bitfield : $row->oi_deleted,
2621  'fa_name' => $row->oi_name,
2622  'fa_archive_name' => $row->oi_archive_name,
2623  'fa_size' => $row->oi_size,
2624  'fa_width' => $row->oi_width,
2625  'fa_height' => $row->oi_height,
2626  'fa_metadata' => $row->oi_metadata,
2627  'fa_bits' => $row->oi_bits,
2628  'fa_media_type' => $row->oi_media_type,
2629  'fa_major_mime' => $row->oi_major_mime,
2630  'fa_minor_mime' => $row->oi_minor_mime,
2631  'fa_timestamp' => $row->oi_timestamp,
2632  'fa_sha1' => $row->oi_sha1
2633  ] + $commentStore->insert( $dbw, 'fa_deleted_reason', $reason )
2634  + $commentStore->insert( $dbw, 'fa_description', $comment )
2635  + $actorMigration->getInsertValues( $dbw, 'fa_user', $user );
2636  }
2637  }
2638 
2639  $dbw->insert( 'filearchive', $rowsInsert, __METHOD__ );
2640  }
2641  }
2642 
2643  function doDBDeletes() {
2645 
2646  $dbw = $this->file->repo->getMasterDB();
2647  list( $oldRels, $deleteCurrent ) = $this->getOldRels();
2648 
2649  if ( count( $oldRels ) ) {
2650  $dbw->delete( 'oldimage',
2651  [
2652  'oi_name' => $this->file->getName(),
2653  'oi_archive_name' => array_keys( $oldRels )
2654  ], __METHOD__ );
2655  }
2656 
2657  if ( $deleteCurrent ) {
2658  $dbw->delete( 'image', [ 'img_name' => $this->file->getName() ], __METHOD__ );
2660  $dbw->delete(
2661  'image_comment_temp', [ 'imgcomment_name' => $this->file->getName() ], __METHOD__
2662  );
2663  }
2664  }
2665  }
2666 
2671  public function execute() {
2672  $repo = $this->file->getRepo();
2673  $this->file->lock();
2674 
2675  // Prepare deletion batch
2676  $hashes = $this->getHashes();
2677  $this->deletionBatch = [];
2678  $ext = $this->file->getExtension();
2679  $dotExt = $ext === '' ? '' : ".$ext";
2680 
2681  foreach ( $this->srcRels as $name => $srcRel ) {
2682  // Skip files that have no hash (e.g. missing DB record, or sha1 field and file source)
2683  if ( isset( $hashes[$name] ) ) {
2684  $hash = $hashes[$name];
2685  $key = $hash . $dotExt;
2686  $dstRel = $repo->getDeletedHashPath( $key ) . $key;
2687  $this->deletionBatch[$name] = [ $srcRel, $dstRel ];
2688  }
2689  }
2690 
2691  if ( !$repo->hasSha1Storage() ) {
2692  // Removes non-existent file from the batch, so we don't get errors.
2693  // This also handles files in the 'deleted' zone deleted via revision deletion.
2694  $checkStatus = $this->removeNonexistentFiles( $this->deletionBatch );
2695  if ( !$checkStatus->isGood() ) {
2696  $this->status->merge( $checkStatus );
2697  return $this->status;
2698  }
2699  $this->deletionBatch = $checkStatus->value;
2700 
2701  // Execute the file deletion batch
2702  $status = $this->file->repo->deleteBatch( $this->deletionBatch );
2703  if ( !$status->isGood() ) {
2704  $this->status->merge( $status );
2705  }
2706  }
2707 
2708  if ( !$this->status->isOK() ) {
2709  // Critical file deletion error; abort
2710  $this->file->unlock();
2711 
2712  return $this->status;
2713  }
2714 
2715  // Copy the image/oldimage rows to filearchive
2716  $this->doDBInserts();
2717  // Delete image/oldimage rows
2718  $this->doDBDeletes();
2719 
2720  // Commit and return
2721  $this->file->unlock();
2722 
2723  return $this->status;
2724  }
2725 
2731  protected function removeNonexistentFiles( $batch ) {
2732  $files = $newBatch = [];
2733 
2734  foreach ( $batch as $batchItem ) {
2735  list( $src, ) = $batchItem;
2736  $files[$src] = $this->file->repo->getVirtualUrl( 'public' ) . '/' . rawurlencode( $src );
2737  }
2738 
2739  $result = $this->file->repo->fileExistsBatch( $files );
2740  if ( in_array( null, $result, true ) ) {
2741  return Status::newFatal( 'backend-fail-internal',
2742  $this->file->repo->getBackend()->getName() );
2743  }
2744 
2745  foreach ( $batch as $batchItem ) {
2746  if ( $result[$batchItem[0]] ) {
2747  $newBatch[] = $batchItem;
2748  }
2749  }
2750 
2751  return Status::newGood( $newBatch );
2752  }
2753 }
2754 
2755 # ------------------------------------------------------------------------------
2756 
2763  private $file;
2764 
2766  private $cleanupBatch;
2767 
2769  private $ids;
2770 
2772  private $all;
2773 
2775  private $unsuppress = false;
2776 
2781  function __construct( File $file, $unsuppress = false ) {
2782  $this->file = $file;
2783  $this->cleanupBatch = [];
2784  $this->ids = [];
2785  $this->unsuppress = $unsuppress;
2786  }
2787 
2792  public function addId( $fa_id ) {
2793  $this->ids[] = $fa_id;
2794  }
2795 
2800  public function addIds( $ids ) {
2801  $this->ids = array_merge( $this->ids, $ids );
2802  }
2803 
2807  public function addAll() {
2808  $this->all = true;
2809  }
2810 
2819  public function execute() {
2821  global $wgLang;
2822 
2823  $repo = $this->file->getRepo();
2824  if ( !$this->all && !$this->ids ) {
2825  // Do nothing
2826  return $repo->newGood();
2827  }
2828 
2829  $lockOwnsTrx = $this->file->lock();
2830 
2831  $dbw = $this->file->repo->getMasterDB();
2832 
2833  $commentStore = CommentStore::getStore();
2834  $actorMigration = ActorMigration::newMigration();
2835 
2836  $status = $this->file->repo->newGood();
2837 
2838  $exists = (bool)$dbw->selectField( 'image', '1',
2839  [ 'img_name' => $this->file->getName() ],
2840  __METHOD__,
2841  // The lock() should already prevents changes, but this still may need
2842  // to bypass any transaction snapshot. However, if lock() started the
2843  // trx (which it probably did) then snapshot is post-lock and up-to-date.
2844  $lockOwnsTrx ? [] : [ 'LOCK IN SHARE MODE' ]
2845  );
2846 
2847  // Fetch all or selected archived revisions for the file,
2848  // sorted from the most recent to the oldest.
2849  $conditions = [ 'fa_name' => $this->file->getName() ];
2850 
2851  if ( !$this->all ) {
2852  $conditions['fa_id'] = $this->ids;
2853  }
2854 
2855  $arFileQuery = ArchivedFile::getQueryInfo();
2856  $result = $dbw->select(
2857  $arFileQuery['tables'],
2858  $arFileQuery['fields'],
2859  $conditions,
2860  __METHOD__,
2861  [ 'ORDER BY' => 'fa_timestamp DESC' ],
2862  $arFileQuery['joins']
2863  );
2864 
2865  $idsPresent = [];
2866  $storeBatch = [];
2867  $insertBatch = [];
2868  $insertCurrent = false;
2869  $deleteIds = [];
2870  $first = true;
2871  $archiveNames = [];
2872 
2873  foreach ( $result as $row ) {
2874  $idsPresent[] = $row->fa_id;
2875 
2876  if ( $row->fa_name != $this->file->getName() ) {
2877  $status->error( 'undelete-filename-mismatch', $wgLang->timeanddate( $row->fa_timestamp ) );
2878  $status->failCount++;
2879  continue;
2880  }
2881 
2882  if ( $row->fa_storage_key == '' ) {
2883  // Revision was missing pre-deletion
2884  $status->error( 'undelete-bad-store-key', $wgLang->timeanddate( $row->fa_timestamp ) );
2885  $status->failCount++;
2886  continue;
2887  }
2888 
2889  $deletedRel = $repo->getDeletedHashPath( $row->fa_storage_key ) .
2890  $row->fa_storage_key;
2891  $deletedUrl = $repo->getVirtualUrl() . '/deleted/' . $deletedRel;
2892 
2893  if ( isset( $row->fa_sha1 ) ) {
2894  $sha1 = $row->fa_sha1;
2895  } else {
2896  // old row, populate from key
2897  $sha1 = LocalRepo::getHashFromKey( $row->fa_storage_key );
2898  }
2899 
2900  # Fix leading zero
2901  if ( strlen( $sha1 ) == 32 && $sha1[0] == '0' ) {
2902  $sha1 = substr( $sha1, 1 );
2903  }
2904 
2905  if ( is_null( $row->fa_major_mime ) || $row->fa_major_mime == 'unknown'
2906  || is_null( $row->fa_minor_mime ) || $row->fa_minor_mime == 'unknown'
2907  || is_null( $row->fa_media_type ) || $row->fa_media_type == 'UNKNOWN'
2908  || is_null( $row->fa_metadata )
2909  ) {
2910  // Refresh our metadata
2911  // Required for a new current revision; nice for older ones too. :)
2912  $props = RepoGroup::singleton()->getFileProps( $deletedUrl );
2913  } else {
2914  $props = [
2915  'minor_mime' => $row->fa_minor_mime,
2916  'major_mime' => $row->fa_major_mime,
2917  'media_type' => $row->fa_media_type,
2918  'metadata' => $row->fa_metadata
2919  ];
2920  }
2921 
2922  $comment = $commentStore->getComment( 'fa_description', $row );
2923  $user = User::newFromAnyId( $row->fa_user, $row->fa_user_text, $row->fa_actor );
2924  if ( $first && !$exists ) {
2925  // This revision will be published as the new current version
2926  $destRel = $this->file->getRel();
2927  list( $commentFields, $commentCallback ) =
2928  $commentStore->insertWithTempTable( $dbw, 'img_description', $comment );
2929  $actorFields = $actorMigration->getInsertValues( $dbw, 'img_user', $user );
2930  $insertCurrent = [
2931  'img_name' => $row->fa_name,
2932  'img_size' => $row->fa_size,
2933  'img_width' => $row->fa_width,
2934  'img_height' => $row->fa_height,
2935  'img_metadata' => $props['metadata'],
2936  'img_bits' => $row->fa_bits,
2937  'img_media_type' => $props['media_type'],
2938  'img_major_mime' => $props['major_mime'],
2939  'img_minor_mime' => $props['minor_mime'],
2940  'img_timestamp' => $row->fa_timestamp,
2941  'img_sha1' => $sha1
2942  ] + $commentFields + $actorFields;
2943 
2944  // The live (current) version cannot be hidden!
2945  if ( !$this->unsuppress && $row->fa_deleted ) {
2946  $status->fatal( 'undeleterevdel' );
2947  $this->file->unlock();
2948  return $status;
2949  }
2950  } else {
2951  $archiveName = $row->fa_archive_name;
2952 
2953  if ( $archiveName == '' ) {
2954  // This was originally a current version; we
2955  // have to devise a new archive name for it.
2956  // Format is <timestamp of archiving>!<name>
2957  $timestamp = wfTimestamp( TS_UNIX, $row->fa_deleted_timestamp );
2958 
2959  do {
2960  $archiveName = wfTimestamp( TS_MW, $timestamp ) . '!' . $row->fa_name;
2961  $timestamp++;
2962  } while ( isset( $archiveNames[$archiveName] ) );
2963  }
2964 
2965  $archiveNames[$archiveName] = true;
2966  $destRel = $this->file->getArchiveRel( $archiveName );
2967  $insertBatch[] = [
2968  'oi_name' => $row->fa_name,
2969  'oi_archive_name' => $archiveName,
2970  'oi_size' => $row->fa_size,
2971  'oi_width' => $row->fa_width,
2972  'oi_height' => $row->fa_height,
2973  'oi_bits' => $row->fa_bits,
2974  'oi_timestamp' => $row->fa_timestamp,
2975  'oi_metadata' => $props['metadata'],
2976  'oi_media_type' => $props['media_type'],
2977  'oi_major_mime' => $props['major_mime'],
2978  'oi_minor_mime' => $props['minor_mime'],
2979  'oi_deleted' => $this->unsuppress ? 0 : $row->fa_deleted,
2980  'oi_sha1' => $sha1
2981  ] + $commentStore->insert( $dbw, 'oi_description', $comment )
2982  + $actorMigration->getInsertValues( $dbw, 'oi_user', $user );
2983  }
2984 
2985  $deleteIds[] = $row->fa_id;
2986 
2987  if ( !$this->unsuppress && $row->fa_deleted & File::DELETED_FILE ) {
2988  // private files can stay where they are
2989  $status->successCount++;
2990  } else {
2991  $storeBatch[] = [ $deletedUrl, 'public', $destRel ];
2992  $this->cleanupBatch[] = $row->fa_storage_key;
2993  }
2994 
2995  $first = false;
2996  }
2997 
2998  unset( $result );
2999 
3000  // Add a warning to the status object for missing IDs
3001  $missingIds = array_diff( $this->ids, $idsPresent );
3002 
3003  foreach ( $missingIds as $id ) {
3004  $status->error( 'undelete-missing-filearchive', $id );
3005  }
3006 
3007  if ( !$repo->hasSha1Storage() ) {
3008  // Remove missing files from batch, so we don't get errors when undeleting them
3009  $checkStatus = $this->removeNonexistentFiles( $storeBatch );
3010  if ( !$checkStatus->isGood() ) {
3011  $status->merge( $checkStatus );
3012  return $status;
3013  }
3014  $storeBatch = $checkStatus->value;
3015 
3016  // Run the store batch
3017  // Use the OVERWRITE_SAME flag to smooth over a common error
3018  $storeStatus = $this->file->repo->storeBatch( $storeBatch, FileRepo::OVERWRITE_SAME );
3019  $status->merge( $storeStatus );
3020 
3021  if ( !$status->isGood() ) {
3022  // Even if some files could be copied, fail entirely as that is the
3023  // easiest thing to do without data loss
3024  $this->cleanupFailedBatch( $storeStatus, $storeBatch );
3025  $status->setOK( false );
3026  $this->file->unlock();
3027 
3028  return $status;
3029  }
3030  }
3031 
3032  // Run the DB updates
3033  // Because we have locked the image row, key conflicts should be rare.
3034  // If they do occur, we can roll back the transaction at this time with
3035  // no data loss, but leaving unregistered files scattered throughout the
3036  // public zone.
3037  // This is not ideal, which is why it's important to lock the image row.
3038  if ( $insertCurrent ) {
3039  $dbw->insert( 'image', $insertCurrent, __METHOD__ );
3040  $commentCallback( $insertCurrent['img_name'] );
3041  }
3042 
3043  if ( $insertBatch ) {
3044  $dbw->insert( 'oldimage', $insertBatch, __METHOD__ );
3045  }
3046 
3047  if ( $deleteIds ) {
3048  $dbw->delete( 'filearchive',
3049  [ 'fa_id' => $deleteIds ],
3050  __METHOD__ );
3051  }
3052 
3053  // If store batch is empty (all files are missing), deletion is to be considered successful
3054  if ( $status->successCount > 0 || !$storeBatch || $repo->hasSha1Storage() ) {
3055  if ( !$exists ) {
3056  wfDebug( __METHOD__ . " restored {$status->successCount} items, creating a new current\n" );
3057 
3058  DeferredUpdates::addUpdate( SiteStatsUpdate::factory( [ 'images' => 1 ] ) );
3059 
3060  $this->file->purgeEverything();
3061  } else {
3062  wfDebug( __METHOD__ . " restored {$status->successCount} as archived versions\n" );
3063  $this->file->purgeDescription();
3064  }
3065  }
3066 
3067  $this->file->unlock();
3068 
3069  return $status;
3070  }
3071 
3077  protected function removeNonexistentFiles( $triplets ) {
3078  $files = $filteredTriplets = [];
3079  foreach ( $triplets as $file ) {
3080  $files[$file[0]] = $file[0];
3081  }
3082 
3083  $result = $this->file->repo->fileExistsBatch( $files );
3084  if ( in_array( null, $result, true ) ) {
3085  return Status::newFatal( 'backend-fail-internal',
3086  $this->file->repo->getBackend()->getName() );
3087  }
3088 
3089  foreach ( $triplets as $file ) {
3090  if ( $result[$file[0]] ) {
3091  $filteredTriplets[] = $file;
3092  }
3093  }
3094 
3095  return Status::newGood( $filteredTriplets );
3096  }
3097 
3103  protected function removeNonexistentFromCleanup( $batch ) {
3104  $files = $newBatch = [];
3105  $repo = $this->file->repo;
3106 
3107  foreach ( $batch as $file ) {
3108  $files[$file] = $repo->getVirtualUrl( 'deleted' ) . '/' .
3109  rawurlencode( $repo->getDeletedHashPath( $file ) . $file );
3110  }
3111 
3112  $result = $repo->fileExistsBatch( $files );
3113 
3114  foreach ( $batch as $file ) {
3115  if ( $result[$file] ) {
3116  $newBatch[] = $file;
3117  }
3118  }
3119 
3120  return $newBatch;
3121  }
3122 
3128  public function cleanup() {
3129  if ( !$this->cleanupBatch ) {
3130  return $this->file->repo->newGood();
3131  }
3132 
3133  $this->cleanupBatch = $this->removeNonexistentFromCleanup( $this->cleanupBatch );
3134 
3135  $status = $this->file->repo->cleanupDeletedBatch( $this->cleanupBatch );
3136 
3137  return $status;
3138  }
3139 
3147  protected function cleanupFailedBatch( $storeStatus, $storeBatch ) {
3148  $cleanupBatch = [];
3149 
3150  foreach ( $storeStatus->success as $i => $success ) {
3151  // Check if this item of the batch was successfully copied
3152  if ( $success ) {
3153  // Item was successfully copied and needs to be removed again
3154  // Extract ($dstZone, $dstRel) from the batch
3155  $cleanupBatch[] = [ $storeBatch[$i][1], $storeBatch[$i][2] ];
3156  }
3157  }
3158  $this->file->repo->cleanupBatch( $cleanupBatch );
3159  }
3160 }
3161 
3162 # ------------------------------------------------------------------------------
3163 
3170  protected $file;
3171 
3173  protected $target;
3174 
3175  protected $cur;
3176 
3177  protected $olds;
3178 
3179  protected $oldCount;
3180 
3181  protected $archive;
3182 
3184  protected $db;
3185 
3191  $this->file = $file;
3192  $this->target = $target;
3193  $this->oldHash = $this->file->repo->getHashPath( $this->file->getName() );
3194  $this->newHash = $this->file->repo->getHashPath( $this->target->getDBkey() );
3195  $this->oldName = $this->file->getName();
3196  $this->newName = $this->file->repo->getNameFromTitle( $this->target );
3197  $this->oldRel = $this->oldHash . $this->oldName;
3198  $this->newRel = $this->newHash . $this->newName;
3199  $this->db = $file->getRepo()->getMasterDB();
3200  }
3201 
3205  public function addCurrent() {
3206  $this->cur = [ $this->oldRel, $this->newRel ];
3207  }
3208 
3213  public function addOlds() {
3214  $archiveBase = 'archive';
3215  $this->olds = [];
3216  $this->oldCount = 0;
3217  $archiveNames = [];
3218 
3219  $result = $this->db->select( 'oldimage',
3220  [ 'oi_archive_name', 'oi_deleted' ],
3221  [ 'oi_name' => $this->oldName ],
3222  __METHOD__,
3223  [ 'LOCK IN SHARE MODE' ] // ignore snapshot
3224  );
3225 
3226  foreach ( $result as $row ) {
3227  $archiveNames[] = $row->oi_archive_name;
3228  $oldName = $row->oi_archive_name;
3229  $bits = explode( '!', $oldName, 2 );
3230 
3231  if ( count( $bits ) != 2 ) {
3232  wfDebug( "Old file name missing !: '$oldName' \n" );
3233  continue;
3234  }
3235 
3236  list( $timestamp, $filename ) = $bits;
3237 
3238  if ( $this->oldName != $filename ) {
3239  wfDebug( "Old file name doesn't match: '$oldName' \n" );
3240  continue;
3241  }
3242 
3243  $this->oldCount++;
3244 
3245  // Do we want to add those to oldCount?
3246  if ( $row->oi_deleted & File::DELETED_FILE ) {
3247  continue;
3248  }
3249 
3250  $this->olds[] = [
3251  "{$archiveBase}/{$this->oldHash}{$oldName}",
3252  "{$archiveBase}/{$this->newHash}{$timestamp}!{$this->newName}"
3253  ];
3254  }
3255 
3256  return $archiveNames;
3257  }
3258 
3263  public function execute() {
3264  $repo = $this->file->repo;
3265  $status = $repo->newGood();
3266  $destFile = wfLocalFile( $this->target );
3267 
3268  $this->file->lock(); // begin
3269  $destFile->lock(); // quickly fail if destination is not available
3270 
3271  $triplets = $this->getMoveTriplets();
3272  $checkStatus = $this->removeNonexistentFiles( $triplets );
3273  if ( !$checkStatus->isGood() ) {
3274  $destFile->unlock();
3275  $this->file->unlock();
3276  $status->merge( $checkStatus ); // couldn't talk to file backend
3277  return $status;
3278  }
3279  $triplets = $checkStatus->value;
3280 
3281  // Verify the file versions metadata in the DB.
3282  $statusDb = $this->verifyDBUpdates();
3283  if ( !$statusDb->isGood() ) {
3284  $destFile->unlock();
3285  $this->file->unlock();
3286  $statusDb->setOK( false );
3287 
3288  return $statusDb;
3289  }
3290 
3291  if ( !$repo->hasSha1Storage() ) {
3292  // Copy the files into their new location.
3293  // If a prior process fataled copying or cleaning up files we tolerate any
3294  // of the existing files if they are identical to the ones being stored.
3295  $statusMove = $repo->storeBatch( $triplets, FileRepo::OVERWRITE_SAME );
3296  wfDebugLog( 'imagemove', "Moved files for {$this->file->getName()}: " .
3297  "{$statusMove->successCount} successes, {$statusMove->failCount} failures" );
3298  if ( !$statusMove->isGood() ) {
3299  // Delete any files copied over (while the destination is still locked)
3300  $this->cleanupTarget( $triplets );
3301  $destFile->unlock();
3302  $this->file->unlock();
3303  wfDebugLog( 'imagemove', "Error in moving files: "
3304  . $statusMove->getWikiText( false, false, 'en' ) );
3305  $statusMove->setOK( false );
3306 
3307  return $statusMove;
3308  }
3309  $status->merge( $statusMove );
3310  }
3311 
3312  // Rename the file versions metadata in the DB.
3313  $this->doDBUpdates();
3314 
3315  wfDebugLog( 'imagemove', "Renamed {$this->file->getName()} in database: " .
3316  "{$statusDb->successCount} successes, {$statusDb->failCount} failures" );
3317 
3318  $destFile->unlock();
3319  $this->file->unlock(); // done
3320 
3321  // Everything went ok, remove the source files
3322  $this->cleanupSource( $triplets );
3323 
3324  $status->merge( $statusDb );
3325 
3326  return $status;
3327  }
3328 
3335  protected function verifyDBUpdates() {
3336  $repo = $this->file->repo;
3337  $status = $repo->newGood();
3338  $dbw = $this->db;
3339 
3340  $hasCurrent = $dbw->selectField(
3341  'image',
3342  '1',
3343  [ 'img_name' => $this->oldName ],
3344  __METHOD__,
3345  [ 'FOR UPDATE' ]
3346  );
3347  $oldRowCount = $dbw->selectRowCount(
3348  'oldimage',
3349  '*',
3350  [ 'oi_name' => $this->oldName ],
3351  __METHOD__,
3352  [ 'FOR UPDATE' ]
3353  );
3354 
3355  if ( $hasCurrent ) {
3356  $status->successCount++;
3357  } else {
3358  $status->failCount++;
3359  }
3360  $status->successCount += $oldRowCount;
3361  // T36934: oldCount is based on files that actually exist.
3362  // There may be more DB rows than such files, in which case $affected
3363  // can be greater than $total. We use max() to avoid negatives here.
3364  $status->failCount += max( 0, $this->oldCount - $oldRowCount );
3365  if ( $status->failCount ) {
3366  $status->error( 'imageinvalidfilename' );
3367  }
3368 
3369  return $status;
3370  }
3371 
3376  protected function doDBUpdates() {
3378 
3379  $dbw = $this->db;
3380 
3381  // Update current image
3382  $dbw->update(
3383  'image',
3384  [ 'img_name' => $this->newName ],
3385  [ 'img_name' => $this->oldName ],
3386  __METHOD__
3387  );
3389  $dbw->update(
3390  'image_comment_temp',
3391  [ 'imgcomment_name' => $this->newName ],
3392  [ 'imgcomment_name' => $this->oldName ],
3393  __METHOD__
3394  );
3395  }
3396 
3397  // Update old images
3398  $dbw->update(
3399  'oldimage',
3400  [
3401  'oi_name' => $this->newName,
3402  'oi_archive_name = ' . $dbw->strreplace( 'oi_archive_name',
3403  $dbw->addQuotes( $this->oldName ), $dbw->addQuotes( $this->newName ) ),
3404  ],
3405  [ 'oi_name' => $this->oldName ],
3406  __METHOD__
3407  );
3408  }
3409 
3414  protected function getMoveTriplets() {
3415  $moves = array_merge( [ $this->cur ], $this->olds );
3416  $triplets = []; // The format is: (srcUrl, destZone, destUrl)
3417 
3418  foreach ( $moves as $move ) {
3419  // $move: (oldRelativePath, newRelativePath)
3420  $srcUrl = $this->file->repo->getVirtualUrl() . '/public/' . rawurlencode( $move[0] );
3421  $triplets[] = [ $srcUrl, 'public', $move[1] ];
3422  wfDebugLog(
3423  'imagemove',
3424  "Generated move triplet for {$this->file->getName()}: {$srcUrl} :: public :: {$move[1]}"
3425  );
3426  }
3427 
3428  return $triplets;
3429  }
3430 
3436  protected function removeNonexistentFiles( $triplets ) {
3437  $files = [];
3438 
3439  foreach ( $triplets as $file ) {
3440  $files[$file[0]] = $file[0];
3441  }
3442 
3443  $result = $this->file->repo->fileExistsBatch( $files );
3444  if ( in_array( null, $result, true ) ) {
3445  return Status::newFatal( 'backend-fail-internal',
3446  $this->file->repo->getBackend()->getName() );
3447  }
3448 
3449  $filteredTriplets = [];
3450  foreach ( $triplets as $file ) {
3451  if ( $result[$file[0]] ) {
3452  $filteredTriplets[] = $file;
3453  } else {
3454  wfDebugLog( 'imagemove', "File {$file[0]} does not exist" );
3455  }
3456  }
3457 
3458  return Status::newGood( $filteredTriplets );
3459  }
3460 
3466  protected function cleanupTarget( $triplets ) {
3467  // Create dest pairs from the triplets
3468  $pairs = [];
3469  foreach ( $triplets as $triplet ) {
3470  // $triplet: (old source virtual URL, dst zone, dest rel)
3471  $pairs[] = [ $triplet[1], $triplet[2] ];
3472  }
3473 
3474  $this->file->repo->cleanupBatch( $pairs );
3475  }
3476 
3482  protected function cleanupSource( $triplets ) {
3483  // Create source file names from the triplets
3484  $files = [];
3485  foreach ( $triplets as $triplet ) {
3486  $files[] = $triplet[0];
3487  }
3488 
3489  $this->file->repo->cleanupBatch( $files );
3490  }
3491 }
3492 
3494  public function __construct( Status $status ) {
3495  parent::__construct(
3496  'actionfailed',
3497  $status->getMessage()
3498  );
3499  }
3500 
3501  public function report() {
3502  global $wgOut;
3503  $wgOut->setStatusCode( 429 );
3504  parent::report();
3505  }
3506 }
LocalFileDeleteBatch\$reason
string $reason
Definition: LocalFile.php:2319
LocalFileMoveBatch\$target
Title $target
Definition: LocalFile.php:3173
LocalFile\$media_type
string $media_type
MEDIATYPE_xxx (bitmap, drawing, audio...)
Definition: LocalFile.php:64
LocalFile\getSha1
getSha1()
Definition: LocalFile.php:2174
$user
please add to it if you re going to add events to the MediaWiki code where normally authentication against an external auth plugin would be creating a account $user
Definition: hooks.txt:247
ParserOptions
Set options of the Parser.
Definition: ParserOptions.php:40
LocalFile\ATOMIC_SECTION_LOCK
const ATOMIC_SECTION_LOCK
Definition: LocalFile.php:132
LocalFile\$fileExists
bool $fileExists
Does the file exist on disk? (loadFromXxx)
Definition: LocalFile.php:52
File\getPath
getPath()
Return the storage path to the file.
Definition: File.php:417
$wgUpdateCompatibleMetadata
$wgUpdateCompatibleMetadata
If to automatically update the img_metadata field if the metadata field is outdated but compatible wi...
Definition: DefaultSettings.php:698
SpecialUpload\getInitialPageText
static getInitialPageText( $comment='', $license='', $copyStatus='', $source='', Config $config=null)
Get the initial image page text based on a comment and optional file status information.
Definition: SpecialUpload.php:593
LocalFile\maybeUpgradeRow
maybeUpgradeRow()
Upgrade a row if it needs it.
Definition: LocalFile.php:661
Wikimedia\Rdbms\Database
Relational database abstraction object.
Definition: Database.php:48
LocalFileRestoreBatch
Helper class for file undeletion.
Definition: LocalFile.php:2761
LocalFileDeleteBatch\$deletionBatch
array $deletionBatch
Items to be processed in the deletion batch.
Definition: LocalFile.php:2328
$wgUser
$wgUser
Definition: Setup.php:902
LocalFileRestoreBatch\$cleanupBatch
string[] $cleanupBatch
List of file IDs to restore.
Definition: LocalFile.php:2766
LocalFile\getMutableCacheKeys
getMutableCacheKeys(WANObjectCache $cache)
Definition: LocalFile.php:308
FileRepo\getReadOnlyReason
getReadOnlyReason()
Get an explanatory message if this repo is read-only.
Definition: FileRepo.php:228
LocalFile\unprefixRow
unprefixRow( $row, $prefix='img_')
Definition: LocalFile.php:554
Title\newFromText
static newFromText( $text, $defaultNamespace=NS_MAIN)
Create a new Title from text, such as what one would find in a link.
Definition: Title.php:273
File\$repo
FileRepo LocalRepo ForeignAPIRepo bool $repo
Some member variables can be lazy-initialised using __get().
Definition: File.php:96
LocalFile\$width
int $width
Image width.
Definition: LocalFile.php:55
File\getArchiveThumbPath
getArchiveThumbPath( $archiveName, $suffix=false)
Get the path of an archived file's thumbs, or a particular thumb if $suffix is specified.
Definition: File.php:1618
RepoGroup\singleton
static singleton()
Get a RepoGroup instance.
Definition: RepoGroup.php:59
Revision\SUPPRESSED_ALL
const SUPPRESSED_ALL
Definition: Revision.php:52
LocalFile\__construct
__construct( $title, $repo)
Do not call this except from inside a repo class.
Definition: LocalFile.php:281
LocalFile\unlock
unlock()
Decrement the lock reference count and end the atomic section if it reaches zero.
Definition: LocalFile.php:2281
use
Apache License January AND DISTRIBUTION Definitions License shall mean the terms and conditions for use
Definition: APACHE-LICENSE-2.0.txt:10
User\getId
getId()
Get the user's ID.
Definition: User.php:2457
LocalFile\getTimestamp
getTimestamp()
Definition: LocalFile.php:2146
LocalFileMoveBatch\$file
LocalFile $file
Definition: LocalFile.php:3170
LocalFileDeleteBatch\addOld
addOld( $oldName)
Definition: LocalFile.php:2365
File\isMultipage
isMultipage()
Returns 'true' if this file is a type which supports multiple pages, e.g.
Definition: File.php:1979
LocalFile\getUser
getUser( $type='text')
Returns user who uploaded the file.
Definition: LocalFile.php:881
User\getActorId
getActorId(IDatabase $dbw=null)
Get the user's actor ID.
Definition: User.php:2520
FileRepo\OVERWRITE_SAME
const OVERWRITE_SAME
Definition: FileRepo.php:40
array
the array() calling protocol came about after MediaWiki 1.4rc1.
LocalFileDeleteBatch\doDBDeletes
doDBDeletes()
Definition: LocalFile.php:2643
LocalFile\loadFromDB
loadFromDB( $flags=0)
Load file metadata from the DB.
Definition: LocalFile.php:448
$lang
if(!isset( $args[0])) $lang
Definition: testCompression.php:33
LocalFile\purgeThumbList
purgeThumbList( $dir, $files)
Delete a list of thumbnails visible at urls.
Definition: LocalFile.php:1129
File\getRel
getRel()
Get the path of the file relative to the public zone root.
Definition: File.php:1532
LocalFileMoveBatch\cleanupSource
cleanupSource( $triplets)
Cleanup a fully moved array of triplets by deleting the source files.
Definition: LocalFile.php:3482
AutoCommitUpdate
Deferrable Update for closure/callback updates that should use auto-commit mode.
Definition: AutoCommitUpdate.php:9
OldLocalFile\getQueryInfo
static getQueryInfo(array $options=[])
Return the tables, fields, and join conditions to be selected to create a new oldlocalfile object.
Definition: OldLocalFile.php:157
LocalFile\$missing
bool $missing
True if file is not present in file system.
Definition: LocalFile.php:127
LocalFileDeleteBatch
Helper class for file deletion.
Definition: LocalFile.php:2314
$wgCommentTableSchemaMigrationStage
int $wgCommentTableSchemaMigrationStage
Comment table schema migration stage.
Definition: DefaultSettings.php:8871
MediaHandler\filterThumbnailPurgeList
filterThumbnailPurgeList(&$files, $options)
Remove files from the purge list.
Definition: MediaHandler.php:721
LocalFileRestoreBatch\execute
execute()
Run the transaction, except the cleanup batch.
Definition: LocalFile.php:2819
LocalFileRestoreBatch\addId
addId( $fa_id)
Add a file by ID.
Definition: LocalFile.php:2792
wfTimestamp
wfTimestamp( $outputtype=TS_UNIX, $ts=0)
Get a timestamp string in one of various formats.
Definition: GlobalFunctions.php:1980
LocalFileMoveBatch\verifyDBUpdates
verifyDBUpdates()
Verify the database updates and return a new Status indicating how many rows would be updated.
Definition: LocalFile.php:3335
$ret
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses & $ret
Definition: hooks.txt:2005
FileBackendError
File backend exception for checked exceptions (e.g.
Definition: FileBackendError.php:8
LocalFile\$upgraded
bool $upgraded
Whether the row was upgraded on load.
Definition: LocalFile.php:115
LocalFile\getDescriptionShortUrl
getDescriptionShortUrl()
Get short description URL for a file based on the page ID.
Definition: LocalFile.php:902
LocalFileRestoreBatch\$ids
string[] $ids
List of file IDs to restore.
Definition: LocalFile.php:2769
LocalFile\getCacheFields
getCacheFields( $prefix='img_')
Returns the list of object properties that are included as-is in the cache.
Definition: LocalFile.php:411
MIGRATION_NEW
const MIGRATION_NEW
Definition: Defines.php:305
LocalFileRestoreBatch\$all
bool $all
Add all revisions of the file.
Definition: LocalFile.php:2772
LocalFileMoveBatch\__construct
__construct(File $file, Title $target)
Definition: LocalFile.php:3190
Title\getPrefixedText
getPrefixedText()
Get the prefixed title with spaces.
Definition: Title.php:1625
DeferredUpdates\addUpdate
static addUpdate(DeferrableUpdate $update, $stage=self::POSTSEND)
Add an update to the deferred list to be run later by execute()
Definition: DeferredUpdates.php:76
LocalFileDeleteBatch\execute
execute()
Run the transaction.
Definition: LocalFile.php:2671
StatusValue\newFatal
static newFatal( $message)
Factory function for fatal errors.
Definition: StatusValue.php:68
LocalFile\getHistory
getHistory( $limit=null, $start=null, $end=null, $inc=true)
purgeDescription inherited
Definition: LocalFile.php:1169
LocalFile\getMediaType
getMediaType()
Returns the type of the media in the file.
Definition: LocalFile.php:957
File\getUrl
getUrl()
Return the URL of the file.
Definition: File.php:348
LocalFile\$dataLoaded
bool $dataLoaded
Whether or not core data has been loaded from the database (loadFromXxx)
Definition: LocalFile.php:79
NS_FILE
const NS_FILE
Definition: Defines.php:80
LocalFile\readOnlyFatalStatus
readOnlyFatalStatus()
Definition: LocalFile.php:2295
MIGRATION_WRITE_BOTH
const MIGRATION_WRITE_BOTH
Definition: Defines.php:303
LocalFile\newFromTitle
static newFromTitle( $title, $repo, $unused=null)
Create a LocalFile from a title Do not call this except from inside a repo class.
Definition: LocalFile.php:146
serialize
serialize()
Definition: ApiMessage.php:184
wfReadOnly
wfReadOnly()
Check whether the wiki is in read-only mode.
Definition: GlobalFunctions.php:1262
ArchivedFile\getQueryInfo
static getQueryInfo()
Return the tables, fields, and join conditions to be selected to create a new archivedfile object.
Definition: ArchivedFile.php:266
RequestContext\newExtraneousContext
static newExtraneousContext(Title $title, $request=[])
Create a new extraneous context.
Definition: RequestContext.php:604
LocalFile\$upgrading
bool $upgrading
Whether the row was scheduled to upgrade on load.
Definition: LocalFile.php:118
User\newFromAnyId
static newFromAnyId( $userId, $userName, $actorId)
Static factory method for creation from an ID, name, and/or actor ID.
Definition: User.php:657
LocalFile\getSize
getSize()
Returns the size of the image file, in bytes.
Definition: LocalFile.php:936
LocalFile\purgeOldThumbnails
purgeOldThumbnails( $archiveName)
Delete cached transformed files for an archived version only.
Definition: LocalFile.php:1046
$res
$res
Definition: database.txt:21
LocalFile\$historyRes
int $historyRes
Result of the query for the file's history (nextHistoryLine)
Definition: LocalFile.php:94
LocalFile\getThumbnails
getThumbnails( $archiveName=false)
getTransformScript inherited
Definition: LocalFile.php:994
LocalFile\$sha1
string $sha1
SHA-1 base 36 content hash.
Definition: LocalFile.php:76
File\splitMime
static splitMime( $mime)
Split an internet media type into its two components; if not a two-part name, set the minor type to '...
Definition: File.php:273
LocalFileRestoreBatch\$file
LocalFile $file
Definition: LocalFile.php:2763
$success
$success
Definition: NoLocalSettings.php:42
Wikimedia\Rdbms\IDatabase\selectField
selectField( $table, $var, $cond='', $fname=__METHOD__, $options=[], $join_conds=[])
A SELECT wrapper which returns a single field from a single result row.
LocalFileRestoreBatch\__construct
__construct(File $file, $unsuppress=false)
Definition: LocalFile.php:2781
$result
The index of the header message $result[1]=The index of the body text message $result[2 through n]=Parameters passed to body text message. Please note the header message cannot receive/use parameters. 'ImgAuthModifyHeaders':Executed just before a file is streamed to a user via img_auth.php, allowing headers to be modified beforehand. $title:LinkTarget object & $headers:HTTP headers(name=> value, names are case insensitive). Two headers get special handling:If-Modified-Since(value must be a valid HTTP date) and Range(must be of the form "bytes=(\d*-\d*)") will be honored when streaming the file. 'ImportHandleLogItemXMLTag':When parsing a XML tag in a log item. Return false to stop further processing of the tag $reader:XMLReader object $logInfo:Array of information 'ImportHandlePageXMLTag':When parsing a XML tag in a page. Return false to stop further processing of the tag $reader:XMLReader object & $pageInfo:Array of information 'ImportHandleRevisionXMLTag':When parsing a XML tag in a page revision. Return false to stop further processing of the tag $reader:XMLReader object $pageInfo:Array of page information $revisionInfo:Array of revision information 'ImportHandleToplevelXMLTag':When parsing a top level XML tag. Return false to stop further processing of the tag $reader:XMLReader object 'ImportHandleUnknownUser':When a user doesn 't exist locally, this hook is called to give extensions an opportunity to auto-create it. If the auto-creation is successful, return false. $name:User name 'ImportHandleUploadXMLTag':When parsing a XML tag in a file upload. Return false to stop further processing of the tag $reader:XMLReader object $revisionInfo:Array of information 'ImportLogInterwikiLink':Hook to change the interwiki link used in log entries and edit summaries for transwiki imports. & $fullInterwikiPrefix:Interwiki prefix, may contain colons. & $pageTitle:String that contains page title. 'ImportSources':Called when reading from the $wgImportSources configuration variable. Can be used to lazy-load the import sources list. & $importSources:The value of $wgImportSources. Modify as necessary. See the comment in DefaultSettings.php for the detail of how to structure this array. 'InfoAction':When building information to display on the action=info page. $context:IContextSource object & $pageInfo:Array of information 'InitializeArticleMaybeRedirect':MediaWiki check to see if title is a redirect. & $title:Title object for the current page & $request:WebRequest & $ignoreRedirect:boolean to skip redirect check & $target:Title/string of redirect target & $article:Article object 'InternalParseBeforeLinks':during Parser 's internalParse method before links but after nowiki/noinclude/includeonly/onlyinclude and other processings. & $parser:Parser object & $text:string containing partially parsed text & $stripState:Parser 's internal StripState object 'InternalParseBeforeSanitize':during Parser 's internalParse method just before the parser removes unwanted/dangerous HTML tags and after nowiki/noinclude/includeonly/onlyinclude and other processings. Ideal for syntax-extensions after template/parser function execution which respect nowiki and HTML-comments. & $parser:Parser object & $text:string containing partially parsed text & $stripState:Parser 's internal StripState object 'InterwikiLoadPrefix':When resolving if a given prefix is an interwiki or not. Return true without providing an interwiki to continue interwiki search. $prefix:interwiki prefix we are looking for. & $iwData:output array describing the interwiki with keys iw_url, iw_local, iw_trans and optionally iw_api and iw_wikiid. 'InvalidateEmailComplete':Called after a user 's email has been invalidated successfully. $user:user(object) whose email is being invalidated 'IRCLineURL':When constructing the URL to use in an IRC notification. Callee may modify $url and $query, URL will be constructed as $url . $query & $url:URL to index.php & $query:Query string $rc:RecentChange object that triggered url generation 'IsFileCacheable':Override the result of Article::isFileCacheable()(if true) & $article:article(object) being checked 'IsTrustedProxy':Override the result of IP::isTrustedProxy() & $ip:IP being check & $result:Change this value to override the result of IP::isTrustedProxy() 'IsUploadAllowedFromUrl':Override the result of UploadFromUrl::isAllowedUrl() $url:URL used to upload from & $allowed:Boolean indicating if uploading is allowed for given URL 'isValidEmailAddr':Override the result of Sanitizer::validateEmail(), for instance to return false if the domain name doesn 't match your organization. $addr:The e-mail address entered by the user & $result:Set this and return false to override the internal checks 'isValidPassword':Override the result of User::isValidPassword() $password:The password entered by the user & $result:Set this and return false to override the internal checks $user:User the password is being validated for 'Language::getMessagesFileName':$code:The language code or the language we 're looking for a messages file for & $file:The messages file path, you can override this to change the location. 'LanguageGetMagic':DEPRECATED! Use $magicWords in a file listed in $wgExtensionMessagesFiles instead. Use this to define synonyms of magic words depending of the language & $magicExtensions:associative array of magic words synonyms $lang:language code(string) 'LanguageGetNamespaces':Provide custom ordering for namespaces or remove namespaces. Do not use this hook to add namespaces. Use CanonicalNamespaces for that. & $namespaces:Array of namespaces indexed by their numbers 'LanguageGetSpecialPageAliases':DEPRECATED! Use $specialPageAliases in a file listed in $wgExtensionMessagesFiles instead. Use to define aliases of special pages names depending of the language & $specialPageAliases:associative array of magic words synonyms $lang:language code(string) 'LanguageGetTranslatedLanguageNames':Provide translated language names. & $names:array of language code=> language name $code:language of the preferred translations 'LanguageLinks':Manipulate a page 's language links. This is called in various places to allow extensions to define the effective language links for a page. $title:The page 's Title. & $links:Array with elements of the form "language:title" in the order that they will be output. & $linkFlags:Associative array mapping prefixed links to arrays of flags. Currently unused, but planned to provide support for marking individual language links in the UI, e.g. for featured articles. 'LanguageSelector':Hook to change the language selector available on a page. $out:The output page. $cssClassName:CSS class name of the language selector. 'LinkBegin':DEPRECATED! Use HtmlPageLinkRendererBegin instead. Used when generating internal and interwiki links in Linker::link(), before processing starts. Return false to skip default processing and return $ret. See documentation for Linker::link() for details on the expected meanings of parameters. $skin:the Skin object $target:the Title that the link is pointing to & $html:the contents that the< a > tag should have(raw HTML) $result
Definition: hooks.txt:1993
LocalFile\$minor_mime
string $minor_mime
Minor MIME type.
Definition: LocalFile.php:100
File\isDeleted
isDeleted( $field)
Is this file a "deleted" file in a private archive? STUB.
Definition: File.php:1895
wfDebugLog
wfDebugLog( $logGroup, $text, $dest='all', array $context=[])
Send a line to a supplementary debug log file, if configured, or main debug log if not.
Definition: GlobalFunctions.php:1087
LocalFileDeleteBatch\$status
Status $status
Definition: LocalFile.php:2334
ActorMigration\newMigration
static newMigration()
Static constructor.
Definition: ActorMigration.php:89
LocalRepo\getHashFromKey
static getHashFromKey( $key)
Gets the SHA1 hash from a storage key.
Definition: LocalRepo.php:181
php
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:37
LocalFile\acquireFileLock
acquireFileLock()
Definition: LocalFile.php:2211
Wikimedia\Rdbms\IDatabase
Basic database interface for live and lazy-loaded relation database handles.
Definition: IDatabase.php:38
$dbr
$dbr
Definition: testCompression.php:50
LocalFile\isCacheable
isCacheable()
Definition: LocalFile.php:2199
FileRepo\publish
publish( $src, $dstRel, $archiveRel, $flags=0, array $options=[])
Copy or move a file either from a storage path, virtual URL, or file system path, into this repositor...
Definition: FileRepo.php:1180
Status
Generic operation result class Has warning/error list, boolean status and arbitrary value.
Definition: Status.php:40
LocalFileMoveBatch\$oldCount
$oldCount
Definition: LocalFile.php:3179
LocalFileMoveBatch\addOlds
addOlds()
Add the old versions of the image to the batch.
Definition: LocalFile.php:3213
width
width
Definition: parserTests.txt:163
key
design txt This is a brief overview of the new design More thorough and up to date information is available on the documentation wiki at etc Handles the details of getting and saving to the user table of the and dealing with sessions and cookies OutputPage Encapsulates the entire HTML page that will be sent in response to any server request It is used by calling its functions to add in any and then calling but I prefer the flexibility This should also do the output encoding The system allocates a global one in $wgOut Title Represents the title of an and does all the work of translating among various forms such as plain database key
Definition: design.txt:26
LocalFile\decodeRow
decodeRow( $row, $prefix='img_')
Decode a row from the database (either object or array) to an array with timestamps and MIME types de...
Definition: LocalFile.php:579
LocalFile\$bits
int $bits
Returned by getimagesize (loadFromXxx)
Definition: LocalFile.php:61
Revision\newFromTitle
static newFromTitle(LinkTarget $linkTarget, $id=0, $flags=0)
Load either the current, or a specified, revision that's attached to a given link target.
Definition: Revision.php:133
file
We ve cleaned up the code here by removing clumps of infrequently used code and moving them off somewhere else It s much easier for someone working with this code to see what s _really_ going and make changes or fix bugs In we can take all the code that deals with the little used title reversing we can concentrate it all in an extension file
Definition: hooks.txt:106
LocalFileRestoreBatch\cleanupFailedBatch
cleanupFailedBatch( $storeStatus, $storeBatch)
Cleanup a failed batch.
Definition: LocalFile.php:3147
LocalFile\purgeThumbnails
purgeThumbnails( $options=[])
Delete cached transformed files for the current version only.
Definition: LocalFile.php:1069
LocalFileDeleteBatch\addCurrent
addCurrent()
Definition: LocalFile.php:2358
FileRepo\hasSha1Storage
hasSha1Storage()
Returns whether or not storage is SHA-1 based.
Definition: FileRepo.php:1944
MediaHandler\METADATA_COMPATIBLE
const METADATA_COMPATIBLE
Definition: MediaHandler.php:34
File
Implements some public methods and some protected utility functions which are required by multiple ch...
Definition: File.php:51
LocalFile\loadExtraFromDB
loadExtraFromDB()
Load lazy file metadata from the DB.
Definition: LocalFile.php:480
LocalFile\publishTo
publishTo( $src, $dstRel, $flags=0, array $options=[])
Move or copy a file to a specified location.
Definition: LocalFile.php:1851
File\$url
string $url
The URL corresponding to one of the four basic zones.
Definition: File.php:117
MWException
MediaWiki exception.
Definition: MWException.php:26
LocalFile\newFromRow
static newFromRow( $row, $repo)
Create a LocalFile from a title Do not call this except from inside a repo class.
Definition: LocalFile.php:159
LocalFile\getDescriptionTouched
getDescriptionTouched()
Definition: LocalFile.php:2155
user
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such and we might be restricted by PHP settings such as safe mode or open_basedir We cannot assume that the software even has read access anywhere useful Many shared hosts run all users web applications under the same user
Wikitext formatted, in the key only.
Definition: distributors.txt:25
wfDeprecated
wfDeprecated( $function, $version=false, $component=false, $callerOffset=2)
Throws a warning that $function is deprecated.
Definition: GlobalFunctions.php:1123
LocalFile\purgeMetadataCache
purgeMetadataCache()
Refresh metadata in memcached, but don't touch thumbnails or CDN.
Definition: LocalFile.php:1017
File\getThumbPath
getThumbPath( $suffix=false)
Get the path of the thumbnail directory, or a particular file if $suffix is specified.
Definition: File.php:1631
FileRepo\quickImport
quickImport( $src, $dst, $options=null)
Import a file from the local file system into the repo.
Definition: FileRepo.php:976
LocalFile\getUpgraded
getUpgraded()
Definition: LocalFile.php:700
FileBackend\isStoragePath
static isStoragePath( $path)
Check if a given path is a "mwstore://" path.
Definition: FileBackend.php:1435
LocalFile\deleteOld
deleteOld( $archiveName, $reason, $suppress=false, $user=null)
Delete an old version of the file.
Definition: LocalFile.php:2029
LocalFileLockError\__construct
__construct(Status $status)
Definition: LocalFile.php:3494
LocalFile\CACHE_FIELD_MAX_LEN
const CACHE_FIELD_MAX_LEN
Definition: LocalFile.php:49
LocalFileLockError\report
report()
Output a report about the exception and takes care of formatting.
Definition: LocalFile.php:3501
LocalFile\loadFromRow
loadFromRow( $row, $prefix='img_')
Load file metadata from a DB result row.
Definition: LocalFile.php:625
LocalFile\__destruct
__destruct()
Clean up any dangling locks.
Definition: LocalFile.php:2303
LocalFile\$deleted
int $deleted
Bitfield akin to rev_deleted.
Definition: LocalFile.php:85
$wgUploadThumbnailRenderMap
$wgUploadThumbnailRenderMap
When defined, is an array of thumbnail widths to be rendered at upload time.
Definition: DefaultSettings.php:1444
FSFile\getSha1Base36FromPath
static getSha1Base36FromPath( $path)
Get a SHA-1 hash of a file in the local filesystem, in base-36 lower case encoding,...
Definition: FSFile.php:218
title
title
Definition: parserTests.txt:219
MediaWiki
A helper class for throttling authentication attempts.
LocalFileDeleteBatch\$file
LocalFile $file
Definition: LocalFile.php:2316
LocalFileDeleteBatch\$suppress
bool $suppress
Whether to suppress all suppressable fields when deleting.
Definition: LocalFile.php:2331
$wgLang
this class mediates it Skin Encapsulates a look and feel for the wiki All of the functions that render HTML and make choices about how to render it are here and are called from various other places when and is meant to be subclassed with other skins that may override some of its functions The User object contains a reference to a and so rather than having a global skin object we just rely on the global User and get the skin with $wgUser and also has some character encoding functions and other locale stuff The current user interface language is instantiated as $wgLang
Definition: design.txt:56
SiteStatsUpdate\factory
static factory(array $deltas)
Definition: SiteStatsUpdate.php:66
MWFileProps
MimeMagic helper wrapper.
Definition: MWFileProps.php:28
LocalFile\prerenderThumbnails
prerenderThumbnails()
Prerenders a configurable set of thumbnails.
Definition: LocalFile.php:1102
Title\makeTitle
static makeTitle( $ns, $title, $fragment='', $interwiki='')
Create a new Title from a namespace index and a DB key.
Definition: Title.php:534
global
when a variable name is used in a it is silently declared as a new masking the global
Definition: design.txt:95
LocalFileDeleteBatch\$user
User $user
Definition: LocalFile.php:2337
LocalFile\getCacheKey
getCacheKey()
Get the memcached key for the main data for this file, or false if there is no access to the shared c...
Definition: LocalFile.php:299
User\addWatch
addWatch( $title, $checkRights=self::CHECK_USER_RIGHTS)
Watch an article.
Definition: User.php:3919
LocalFileMoveBatch\$db
IDatabase $db
Definition: LocalFile.php:3184
MediaHandler\getPageDimensions
getPageDimensions(File $image, $page)
Get an associative array of page dimensions Currently "width" and "height" are understood,...
Definition: MediaHandler.php:414
LocalFileRestoreBatch\addAll
addAll()
Add all revisions of the file.
Definition: LocalFile.php:2807
LocalFile\$mime
string $mime
MIME type, determined by MimeMagic::guessMimeType.
Definition: LocalFile.php:67
LocalFileRestoreBatch\$unsuppress
bool $unsuppress
Whether to remove all settings for suppressed fields.
Definition: LocalFile.php:2775
wfDebug
wfDebug( $text, $dest='all', array $context=[])
Sends a line to the debug log if enabled or, optionally, to a comment in output.
Definition: GlobalFunctions.php:994
LocalFile\setProps
setProps( $info)
Set properties in this object to be equal to those given in the associative array $info.
Definition: LocalFile.php:762
FileRepo\getFileSha1
getFileSha1( $virtualUrl)
Get the sha1 (base 36) of a file with a given virtual URL/storage path.
Definition: FileRepo.php:1605
list
deferred txt A few of the database updates required by various functions here can be deferred until after the result page is displayed to the user For updating the view updating the linked to tables after a etc PHP does not yet have any way to tell the server to actually return and disconnect while still running these but it might have such a feature in the future We handle these by creating a deferred update object and putting those objects on a global list
Definition: deferred.txt:11
LocalFile
Class to represent a local file in the wiki's own database.
Definition: LocalFile.php:46
ContentHandler\makeContent
static makeContent( $text, Title $title=null, $modelId=null, $format=null)
Convenience function for creating a Content object from a given textual representation.
Definition: ContentHandler.php:129
LocalFileMoveBatch\$archive
$archive
Definition: LocalFile.php:3181
LocalFile\getMimeType
getMimeType()
Returns the MIME type of the file.
Definition: LocalFile.php:946
LocalFile\getDescription
getDescription( $audience=self::FOR_PUBLIC, User $user=null)
Definition: LocalFile.php:2130
$urls
$urls
Definition: opensearch_desc.php:76
MIGRATION_OLD
const MIGRATION_OLD
Definition: Defines.php:302
$fname
if(defined( 'MW_SETUP_CALLBACK')) $fname
Customization point after all loading (constants, functions, classes, DefaultSettings,...
Definition: Setup.php:112
$options
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped & $options
Definition: hooks.txt:2001
LocalFile\$extraDataLoaded
bool $extraDataLoaded
Whether or not lazy-loaded data has been loaded from the database.
Definition: LocalFile.php:82
ThumbnailRenderJob
Job for asynchronous rendering of thumbnails.
Definition: ThumbnailRenderJob.php:29
LocalFile\$size
int $size
Size in bytes (loadFromXxx)
Definition: LocalFile.php:70
HTMLCacheUpdate
Class to invalidate the HTML cache of all the pages linking to a given title.
Definition: HTMLCacheUpdate.php:29
File\purgeDescription
purgeDescription()
Purge the file description page, but don't go after pages using the file.
Definition: File.php:1447
LocalFileDeleteBatch\getHashes
getHashes()
Definition: LocalFile.php:2411
LocalFile\LOAD_ALL
const LOAD_ALL
Definition: LocalFile.php:130
$value
$value
Definition: styleTest.css.php:45
LocalFile\lock
lock()
Start an atomic DB section and lock the image for update or increments a reference counter if the loc...
Definition: LocalFile.php:2236
File\$handler
MediaHandler $handler
Definition: File.php:114
LocalFileLockError
Definition: LocalFile.php:3493
CdnCacheUpdate
Handles purging appropriate CDN URLs given a title (or titles)
Definition: CdnCacheUpdate.php:30
File\assertTitleDefined
assertTitleDefined()
Assert that $this->title is set to a Title.
Definition: File.php:2297
StatusValue\newGood
static newGood( $value=null)
Factory function for good results.
Definition: StatusValue.php:81
LocalFile\$historyLine
int $historyLine
Number of line to return by nextHistoryLine() (constructor)
Definition: LocalFile.php:91
LocalFileMoveBatch\getMoveTriplets
getMoveTriplets()
Generate triplets for FileRepo::storeBatch().
Definition: LocalFile.php:3414
LocalFile\releaseFileLock
releaseFileLock()
Definition: LocalFile.php:2221
LocalFile\upgradeRow
upgradeRow()
Fix assorted version-related problems with the image row by reloading it from the file.
Definition: LocalFile.php:707
LocalFile\load
load( $flags=0)
Load file metadata from cache or DB, unless already loaded.
Definition: LocalFile.php:643
WANObjectCache
Multi-datacenter aware caching interface.
Definition: WANObjectCache.php:87
LocalFile\newFromKey
static newFromKey( $sha1, $repo, $timestamp=false)
Create a LocalFile from a SHA-1 key Do not call this except from inside a repo class.
Definition: LocalFile.php:176
LocalFile\nextHistoryLine
nextHistoryLine()
Returns the history of this file, line by line.
Definition: LocalFile.php:1225
File\$title
Title string bool $title
Definition: File.php:99
LocalFile\$metadata
string $metadata
Handler-specific metadata.
Definition: LocalFile.php:73
LocalFile\getBitDepth
getBitDepth()
Definition: LocalFile.php:926
LocalFile\$height
int $height
Image height.
Definition: LocalFile.php:58
LocalFile\$user
User $user
Uploader.
Definition: LocalFile.php:106
File\getArchiveThumbUrl
getArchiveThumbUrl( $archiveName, $suffix=false)
Get the URL of the archived file's thumbs, or a particular thumb if $suffix is specified.
Definition: File.php:1675
File\getName
getName()
Return the name of this file.
Definition: File.php:297
File\getArchiveUrl
getArchiveUrl( $suffix=false)
Get the URL of the archive directory, or a particular file if $suffix is specified.
Definition: File.php:1655
$status
Status::newGood()` to allow deletion, and then `return false` from the hook function. Ensure you consume the 'ChangeTagAfterDelete' hook to carry out custom deletion actions. $tag:name of the tag $user:user initiating the action & $status:Status object. See above. 'ChangeTagsListActive':Allows you to nominate which of the tags your extension uses are in active use. & $tags:list of all active tags. Append to this array. 'ChangeTagsAfterUpdateTags':Called after tags have been updated with the ChangeTags::updateTags function. Params:$addedTags:tags effectively added in the update $removedTags:tags effectively removed in the update $prevTags:tags that were present prior to the update $rc_id:recentchanges table id $rev_id:revision table id $log_id:logging table id $params:tag params $rc:RecentChange being tagged when the tagging accompanies the action or null $user:User who performed the tagging when the tagging is subsequent to the action or null 'ChangeTagsAllowedAdd':Called when checking if a user can add tags to a change. & $allowedTags:List of all the tags the user is allowed to add. Any tags the user wants to add( $addTags) that are not in this array will cause it to fail. You may add or remove tags to this array as required. $addTags:List of tags user intends to add. $user:User who is adding the tags. 'ChangeUserGroups':Called before user groups are changed. $performer:The User who will perform the change $user:The User whose groups will be changed & $add:The groups that will be added & $remove:The groups that will be removed 'Collation::factory':Called if $wgCategoryCollation is an unknown collation. $collationName:Name of the collation in question & $collationObject:Null. Replace with a subclass of the Collation class that implements the collation given in $collationName. 'ConfirmEmailComplete':Called after a user 's email has been confirmed successfully. $user:user(object) whose email is being confirmed 'ContentAlterParserOutput':Modify parser output for a given content object. Called by Content::getParserOutput after parsing has finished. Can be used for changes that depend on the result of the parsing but have to be done before LinksUpdate is called(such as adding tracking categories based on the rendered HTML). $content:The Content to render $title:Title of the page, as context $parserOutput:ParserOutput to manipulate 'ContentGetParserOutput':Customize parser output for a given content object, called by AbstractContent::getParserOutput. May be used to override the normal model-specific rendering of page content. $content:The Content to render $title:Title of the page, as context $revId:The revision ID, as context $options:ParserOptions for rendering. To avoid confusing the parser cache, the output can only depend on parameters provided to this hook function, not on global state. $generateHtml:boolean, indicating whether full HTML should be generated. If false, generation of HTML may be skipped, but other information should still be present in the ParserOutput object. & $output:ParserOutput, to manipulate or replace 'ContentHandlerDefaultModelFor':Called when the default content model is determined for a given title. May be used to assign a different model for that title. $title:the Title in question & $model:the model name. Use with CONTENT_MODEL_XXX constants. 'ContentHandlerForModelID':Called when a ContentHandler is requested for a given content model name, but no entry for that model exists in $wgContentHandlers. Note:if your extension implements additional models via this hook, please use GetContentModels hook to make them known to core. $modeName:the requested content model name & $handler:set this to a ContentHandler object, if desired. 'ContentModelCanBeUsedOn':Called to determine whether that content model can be used on a given page. This is especially useful to prevent some content models to be used in some special location. $contentModel:ID of the content model in question $title:the Title in question. & $ok:Output parameter, whether it is OK to use $contentModel on $title. Handler functions that modify $ok should generally return false to prevent further hooks from further modifying $ok. 'ContribsPager::getQueryInfo':Before the contributions query is about to run & $pager:Pager object for contributions & $queryInfo:The query for the contribs Pager 'ContribsPager::reallyDoQuery':Called before really executing the query for My Contributions & $data:an array of results of all contribs queries $pager:The ContribsPager object hooked into $offset:Index offset, inclusive $limit:Exact query limit $descending:Query direction, false for ascending, true for descending 'ContributionsLineEnding':Called before a contributions HTML line is finished $page:SpecialPage object for contributions & $ret:the HTML line $row:the DB row for this line & $classes:the classes to add to the surrounding< li > & $attribs:associative array of other HTML attributes for the< li > element. Currently only data attributes reserved to MediaWiki are allowed(see Sanitizer::isReservedDataAttribute). 'ContributionsToolLinks':Change tool links above Special:Contributions $id:User identifier $title:User page title & $tools:Array of tool links $specialPage:SpecialPage instance for context and services. Can be either SpecialContributions or DeletedContributionsPage. Extensions should type hint against a generic SpecialPage though. 'ConvertContent':Called by AbstractContent::convert when a conversion to another content model is requested. Handler functions that modify $result should generally return false to disable further attempts at conversion. $content:The Content object to be converted. $toModel:The ID of the content model to convert to. $lossy:boolean indicating whether lossy conversion is allowed. & $result:Output parameter, in case the handler function wants to provide a converted Content object. Note that $result->getContentModel() must return $toModel. 'CustomEditor':When invoking the page editor Return true to allow the normal editor to be used, or false if implementing a custom editor, e.g. for a special namespace, etc. $article:Article being edited $user:User performing the edit 'DatabaseOraclePostInit':Called after initialising an Oracle database $db:the DatabaseOracle object 'DeletedContribsPager::reallyDoQuery':Called before really executing the query for Special:DeletedContributions Similar to ContribsPager::reallyDoQuery & $data:an array of results of all contribs queries $pager:The DeletedContribsPager object hooked into $offset:Index offset, inclusive $limit:Exact query limit $descending:Query direction, false for ascending, true for descending 'DeletedContributionsLineEnding':Called before a DeletedContributions HTML line is finished. Similar to ContributionsLineEnding $page:SpecialPage object for DeletedContributions & $ret:the HTML line $row:the DB row for this line & $classes:the classes to add to the surrounding< li > & $attribs:associative array of other HTML attributes for the< li > element. Currently only data attributes reserved to MediaWiki are allowed(see Sanitizer::isReservedDataAttribute). 'DeleteUnknownPreferences':Called by the cleanupPreferences.php maintenance script to build a WHERE clause with which to delete preferences that are not known about. This hook is used by extensions that have dynamically-named preferences that should not be deleted in the usual cleanup process. For example, the Gadgets extension creates preferences prefixed with 'gadget-', and so anything with that prefix is excluded from the deletion. &where:An array that will be passed as the $cond parameter to IDatabase::select() to determine what will be deleted from the user_properties table. $db:The IDatabase object, useful for accessing $db->buildLike() etc. 'DifferenceEngineAfterLoadNewText':called in DifferenceEngine::loadNewText() after the new revision 's content has been loaded into the class member variable $differenceEngine->mNewContent but before returning true from this function. $differenceEngine:DifferenceEngine object 'DifferenceEngineLoadTextAfterNewContentIsLoaded':called in DifferenceEngine::loadText() after the new revision 's content has been loaded into the class member variable $differenceEngine->mNewContent but before checking if the variable 's value is null. This hook can be used to inject content into said class member variable. $differenceEngine:DifferenceEngine object 'DifferenceEngineMarkPatrolledLink':Allows extensions to change the "mark as patrolled" link which is shown both on the diff header as well as on the bottom of a page, usually wrapped in a span element which has class="patrollink". $differenceEngine:DifferenceEngine object & $markAsPatrolledLink:The "mark as patrolled" link HTML(string) $rcid:Recent change ID(rc_id) for this change(int) 'DifferenceEngineMarkPatrolledRCID':Allows extensions to possibly change the rcid parameter. For example the rcid might be set to zero due to the user being the same as the performer of the change but an extension might still want to show it under certain conditions. & $rcid:rc_id(int) of the change or 0 $differenceEngine:DifferenceEngine object $change:RecentChange object $user:User object representing the current user 'DifferenceEngineNewHeader':Allows extensions to change the $newHeader variable, which contains information about the new revision, such as the revision 's author, whether the revision was marked as a minor edit or not, etc. $differenceEngine:DifferenceEngine object & $newHeader:The string containing the various #mw-diff-otitle[1-5] divs, which include things like revision author info, revision comment, RevisionDelete link and more $formattedRevisionTools:Array containing revision tools, some of which may have been injected with the DiffRevisionTools hook $nextlink:String containing the link to the next revision(if any) $status
Definition: hooks.txt:1255
Wikimedia\Rdbms\IDatabase\update
update( $table, $values, $conds, $fname=__METHOD__, $options=[])
UPDATE wrapper.
FSFile
Class representing a non-directory file on the file system.
Definition: FSFile.php:29
LocalFile\$timestamp
string $timestamp
Upload timestamp.
Definition: LocalFile.php:103
FileRepo\getBackend
getBackend()
Get the file backend instance.
Definition: FileRepo.php:218
LocalFile\$descriptionTouched
string $descriptionTouched
TS_MW timestamp of the last change of the file description.
Definition: LocalFile.php:112
File\DELETE_SOURCE
const DELETE_SOURCE
Definition: File.php:66
LocalFileDeleteBatch\$archiveUrls
array $archiveUrls
Definition: LocalFile.php:2325
LocalFileDeleteBatch\addOlds
addOlds()
Add the old versions of the image to the batch.
Definition: LocalFile.php:2374
LocalFile\recordUpload
recordUpload( $oldver, $desc, $license='', $copyStatus='', $source='', $watch=false, $timestamp=false, User $user=null)
Record a file upload in the upload log and the image table.
Definition: LocalFile.php:1393
LocalFile\recordUpload2
recordUpload2( $oldver, $comment, $pageText, $props=false, $timestamp=false, $user=null, $tags=[])
Record a file upload in the upload log and the image table.
Definition: LocalFile.php:1424
EDIT_NEW
const EDIT_NEW
Definition: Defines.php:162
LocalFile\$locked
bool $locked
True if the image row is locked.
Definition: LocalFile.php:121
$rev
presenting them properly to the user as errors is done by the caller return true use this to change the list i e etc $rev
Definition: hooks.txt:1777
LocalFile\$description
string $description
Description of current revision of the file.
Definition: LocalFile.php:109
LocalFile\getLazyCacheFields
getLazyCacheFields( $prefix='img_')
Returns the list of object properties that are included as-is in the cache, only when they're not too...
Definition: LocalFile.php:433
LocalFile\selectFields
static selectFields()
Fields in the image table.
Definition: LocalFile.php:200
File\getTitle
getTitle()
Return the associated title object.
Definition: File.php:326
LocalFile\getQueryInfo
static getQueryInfo(array $options=[])
Return the tables, fields, and join conditions to be selected to create a new localfile object.
Definition: LocalFile.php:243
Title
Represents a title within MediaWiki.
Definition: Title.php:39
LocalFile\getMetadata
getMetadata()
Get handler-specific metadata.
Definition: LocalFile.php:918
$name
Allows to change the fields on the form that will be generated $name
Definition: hooks.txt:302
LocalFileRestoreBatch\addIds
addIds( $ids)
Add a whole lot of files by ID.
Definition: LocalFile.php:2800
JobQueueGroup\singleton
static singleton( $domain=false)
Definition: JobQueueGroup.php:72
MediaHandler\getContentHeaders
getContentHeaders( $metadata)
Get useful response headers for GET/HEAD requests for a file with the given metadata.
Definition: MediaHandler.php:923
$cache
$cache
Definition: mcc.php:33
LocalFile\loadFromFile
loadFromFile()
Load metadata from the file itself.
Definition: LocalFile.php:400
File\assertRepoDefined
assertRepoDefined()
Assert that $this->repo is set to a valid FileRepo instance.
Definition: File.php:2287
LocalFileMoveBatch\execute
execute()
Perform the move.
Definition: LocalFile.php:3263
ObjectCache\getMainWANInstance
static getMainWANInstance()
Get the main WAN cache object.
Definition: ObjectCache.php:380
$tables
this hook is for auditing only RecentChangesLinked and Watchlist RecentChangesLinked and Watchlist Do not use this to implement individual filters if they are compatible with the ChangesListFilter and ChangesListFilterGroup structure use sub classes of those in conjunction with the ChangesListSpecialPageStructuredFilters hook This hook can be used to implement filters that do not implement that or custom behavior that is not an individual filter e g Watchlist & $tables
Definition: hooks.txt:1015
DeferredUpdates\PRESEND
const PRESEND
Definition: DeferredUpdates.php:60
LocalFile\getDescriptionText
getDescriptionText( $lang=null)
Get the HTML text of the description page This is not used by ImagePage for local files,...
Definition: LocalFile.php:2111
LocalFile\upload
upload( $src, $comment, $pageText, $flags=0, $props=false, $timestamp=false, $user=null, $tags=[])
getHashPath inherited
Definition: LocalFile.php:1306
LocalFile\resetHistory
resetHistory()
Reset the history pointer to the first element of the history.
Definition: LocalFile.php:1268
LocalFileMoveBatch\removeNonexistentFiles
removeNonexistentFiles( $triplets)
Removes non-existent files from move batch.
Definition: LocalFile.php:3436
LogEntryBase\makeParamBlob
static makeParamBlob( $params)
Create a blob from a parameter array.
Definition: LogEntry.php:142
LocalFileRestoreBatch\cleanup
cleanup()
Delete unused files in the deleted zone.
Definition: LocalFile.php:3128
MediaHandler\getHandler
static getHandler( $type)
Get a MediaHandler for a given MIME type from the instance cache.
Definition: MediaHandler.php:46
LocalFileDeleteBatch\$srcRels
array $srcRels
Definition: LocalFile.php:2322
as
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:22
LocalFileRestoreBatch\removeNonexistentFiles
removeNonexistentFiles( $triplets)
Removes non-existent files from a store batch.
Definition: LocalFile.php:3077
FileRepo\isVirtualUrl
static isVirtualUrl( $url)
Determine if a string is an mwrepo:// URL.
Definition: FileRepo.php:257
LinksUpdate\queueRecursiveJobsForTable
static queueRecursiveJobsForTable(Title $title, $table, $action='unknown', $userName='unknown')
Queue a RefreshLinks job for any table.
Definition: LinksUpdate.php:345
LocalFile\loadExtraFieldsWithTimestamp
loadExtraFieldsWithTimestamp( $dbr, $fname)
Definition: LocalFile.php:505
LocalFileMoveBatch
Helper class for file movement.
Definition: LocalFile.php:3168
MediaHandler\METADATA_BAD
const METADATA_BAD
Definition: MediaHandler.php:33
LoggerFactory
MediaWiki Logger LoggerFactory implements a PSR[0] compatible message logging system Named Psr Log LoggerInterface instances can be obtained from the MediaWiki Logger LoggerFactory::getInstance() static method. MediaWiki\Logger\LoggerFactory expects a class implementing the MediaWiki\Logger\Spi interface to act as a factory for new Psr\Log\LoggerInterface instances. The "Spi" in MediaWiki\Logger\Spi stands for "service provider interface". An SPI is an API intended to be implemented or extended by a third party. This software design pattern is intended to enable framework extension and replaceable components. It is specifically used in the MediaWiki\Logger\LoggerFactory service to allow alternate PSR-3 logging implementations to be easily integrated with MediaWiki. The service provider interface allows the backend logging library to be implemented in multiple ways. The $wgMWLoggerDefaultSpi global provides the classname of the default MediaWiki\Logger\Spi implementation to be loaded at runtime. This can either be the name of a class implementing the MediaWiki\Logger\Spi with a zero argument const ructor or a callable that will return an MediaWiki\Logger\Spi instance. Alternately the MediaWiki\Logger\LoggerFactory MediaWiki Logger LoggerFactory
Definition: logger.txt:5
$source
$source
Definition: mwdoc-filter.php:46
$batch
$batch
Definition: linkcache.txt:23
LocalFileDeleteBatch\getOldRels
getOldRels()
Definition: LocalFile.php:2395
ManualLogEntry
Class for creating log entries manually, to inject them into the database.
Definition: LogEntry.php:432
Revision\newNullRevision
static newNullRevision( $dbw, $pageId, $summary, $minor, $user=null)
Create a new null-revision for insertion into a page's history.
Definition: Revision.php:1159
$hashes
$hashes
Definition: testCompression.php:66
FileRepo\DELETE_SOURCE
const DELETE_SOURCE
Definition: FileRepo.php:38
WikiFilePage
Special handling for file pages.
Definition: WikiFilePage.php:30
File\$name
string $name
The name of a file from its title object.
Definition: File.php:123
File\DELETED_FILE
const DELETED_FILE
Definition: File.php:53
LocalFile\publish
publish( $src, $flags=0, array $options=[])
Move or copy a file to its public location.
Definition: LocalFile.php:1832
name
design txt This is a brief overview of the new design More thorough and up to date information is available on the documentation wiki at name
Definition: design.txt:12
class
you have access to all of the normal MediaWiki so you can get a DB use the etc For full docs on the Maintenance class
Definition: maintenance.txt:56
EDIT_SUPPRESS_RC
const EDIT_SUPPRESS_RC
Definition: Defines.php:165
File\getRepo
getRepo()
Returns the repository.
Definition: File.php:1874
LocalFile\getWidth
getWidth( $page=1)
Return the width of the image.
Definition: LocalFile.php:816
MediaWikiServices
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency MediaWikiServices
Definition: injection.txt:25
File\getThumbUrl
getThumbUrl( $suffix=false)
Get the URL of the thumbnail directory, or a particular file if $suffix is specified.
Definition: File.php:1713
LocalFile\$major_mime
string $major_mime
Major MIME type.
Definition: LocalFile.php:97
File\isVectorized
isVectorized()
Return true if the file is vectorized.
Definition: File.php:555
File\getHandler
getHandler()
Get a MediaHandler instance for this file.
Definition: File.php:1383
$wgOut
$wgOut
Definition: Setup.php:912
ErrorPageError
An error page which can definitely be safely rendered using the OutputPage.
Definition: ErrorPageError.php:27
LockManager\LOCK_EX
const LOCK_EX
Definition: LockManager.php:69
LocalFile\getHeight
getHeight( $page=1)
Return the height of the image.
Definition: LocalFile.php:848
LocalFile\isMissing
isMissing()
splitMime inherited
Definition: LocalFile.php:801
CommentStore\getStore
static getStore()
Definition: CommentStore.php:130
LocalFile\invalidateCache
invalidateCache()
Purge the file object/metadata cache.
Definition: LocalFile.php:383
File\userCan
userCan( $field, User $user=null)
Determine if the current user is allowed to view a particular field of this file, if it's marked as d...
Definition: File.php:2167
LocalFile\$lockedOwnTrx
bool $lockedOwnTrx
True if the image row is locked with a lock initiated transaction.
Definition: LocalFile.php:124
User
The User object encapsulates all of the user-specific settings (user_id, name, rights,...
Definition: User.php:53
LocalFileDeleteBatch\__construct
__construct(File $file, $reason='', $suppress=false, $user=null)
Definition: LocalFile.php:2345
wfLocalFile
wfLocalFile( $title)
Get an object referring to a locally registered file.
Definition: GlobalFunctions.php:2864
DeferredUpdates\addCallableUpdate
static addCallableUpdate( $callable, $stage=self::POSTSEND, $dbw=null)
Add a callable update.
Definition: DeferredUpdates.php:111
LocalFile\VERSION
const VERSION
Definition: LocalFile.php:47
Hooks\run
static run( $event, array $args=[], $deprecatedVersion=null)
Call hook functions defined in Hooks::register and $wgHooks.
Definition: Hooks.php:203
LocalFile\getDescriptionUrl
getDescriptionUrl()
isMultipage inherited
Definition: LocalFile.php:2099
LocalFile\move
move( $target)
getLinksTo inherited
Definition: LocalFile.php:1912
$ext
$ext
Definition: router.php:55
LocalFileMoveBatch\addCurrent
addCurrent()
Add the current image to the batch.
Definition: LocalFile.php:3205
LocalFile\$repoClass
string $repoClass
Definition: LocalFile.php:88
MediaHandler\isMetadataValid
isMetadataValid( $image, $metadata)
Check if the metadata string is valid for this handler.
Definition: MediaHandler.php:198
User\getName
getName()
Get the user name, or the IP of an anonymous user.
Definition: User.php:2482
LocalFileDeleteBatch\removeNonexistentFiles
removeNonexistentFiles( $batch)
Removes non-existent files from a deletion batch.
Definition: LocalFile.php:2731
LocalFileMoveBatch\doDBUpdates
doDBUpdates()
Do the database updates and return a new Status indicating how many rows where updated.
Definition: LocalFile.php:3376
false
processing should stop and the error should be shown to the user * false
Definition: hooks.txt:187
LocalFile\restore
restore( $versions=[], $unsuppress=false)
Restore all or specified deleted revisions to the given file.
Definition: LocalFile.php:2065
Language
Internationalisation code.
Definition: Language.php:35
File\purgeEverything
purgeEverything()
Purge metadata and all affected pages when the file is created, deleted, or majorly updated.
Definition: File.php:1459
File\getHashPath
getHashPath()
Get the filename hash component of the directory including trailing slash, e.g.
Definition: File.php:1517
LocalFileMoveBatch\$olds
$olds
Definition: LocalFile.php:3177
LocalFile\exists
exists()
canRender inherited
Definition: LocalFile.php:973
File\getThumbnails
getThumbnails()
Get all thumbnail names previously generated for this file STUB Overridden by LocalFile.
Definition: File.php:1428
$e
div flags Integer display flags(NO_ACTION_LINK, NO_EXTRA_USER_LINKS) 'LogException' returning false will NOT prevent logging $e
Definition: hooks.txt:2171
LocalFileMoveBatch\$cur
$cur
Definition: LocalFile.php:3175
LocalFile\loadFromCache
loadFromCache()
Try to load file metadata from memcached, falling back to the database.
Definition: LocalFile.php:315
LocalFile\purgeCache
purgeCache( $options=[])
Delete all previously generated thumbnails, refresh metadata in memcached and purge the CDN.
Definition: LocalFile.php:1028
LocalFileMoveBatch\cleanupTarget
cleanupTarget( $triplets)
Cleanup a partially moved array of triplets by deleting the target files.
Definition: LocalFile.php:3466
File\getVirtualUrl
getVirtualUrl( $suffix=false)
Get the public zone virtual URL for a current version source file.
Definition: File.php:1733
LocalFileDeleteBatch\doDBInserts
doDBInserts()
Definition: LocalFile.php:2467
LocalFileRestoreBatch\removeNonexistentFromCleanup
removeNonexistentFromCleanup( $batch)
Removes non-existent files from a cleanup batch.
Definition: LocalFile.php:3103
LogFormatter\newFromEntry
static newFromEntry(LogEntry $entry)
Constructs a new formatter suitable for given entry.
Definition: LogFormatter.php:50
Article\purgePatrolFooterCache
static purgePatrolFooterCache( $articleID)
Purge the cache used to check if it is worth showing the patrol footer For example,...
Definition: Article.php:1140
$type
$type
Definition: testCompression.php:48
$wgActorTableSchemaMigrationStage
int $wgActorTableSchemaMigrationStage
Actor table schema migration stage.
Definition: DefaultSettings.php:8878