includes/libs/filebackend/fsfile/TempFSFile.php

   1 <?php
   2
   3 /**
   4  * Location holder of files stored temporarily
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  * http://www.gnu.org/copyleft/gpl.html
  20  *
  21  * @file
  22  * @ingroup FileBackend
  23  */
  24
  25 namespace Wikimedia\FileBackend\FSFile;
  26
  27 use MediaWiki\FileBackend\FSFile\TempFSFileFactory;
  28 use RuntimeException;
  29 use WeakMap;
  30 use Wikimedia\AtEase\AtEase;
  31
  32 /**
  33  * This class is used to hold the location and do limited manipulation
  34  * of files stored temporarily (this will be whatever wfTempDir() returns)
  35  *
  36  * @ingroup FileBackend
  37  */
  38 class TempFSFile extends FSFile {
  39         /** @var bool Garbage collect the temp file */
  40         protected $canDelete = false;
  41
  42         /** @var array Map of (path => 1) for paths to delete on shutdown */
  43         protected static $pathsCollect = null;
  44
  45         /**
  46          * A WeakMap where the key is an object which depends on the file, and the
  47          * value is a TempFSFile responsible for deleting the file. This keeps each
  48          * TempFSFile alive until all associated objects have been destroyed.
  49          * @var WeakMap|null
  50          */
  51         private static $references;
  52
  53         /**
  54          * Do not call directly. Use TempFSFileFactory
  55          *
  56          * @param string $path
  57          */
  58         public function __construct( $path ) {
  59                 parent::__construct( $path );
  60
  61                 if ( self::$pathsCollect === null ) {
  62                         // @codeCoverageIgnoreStart
  63                         self::$pathsCollect = [];
  64                         register_shutdown_function( [ __CLASS__, 'purgeAllOnShutdown' ] );
  65                         // @codeCoverageIgnoreEnd
  66                 }
  67         }
  68
  69         /**
  70          * Make a new temporary file on the file system.
  71          * Temporary files may be purged when the file object falls out of scope.
  72          *
  73          * @deprecated since 1.34, use TempFSFileFactory directly
  74          *
  75          * @param string $prefix
  76          * @param string $extension Optional file extension
  77          * @param string|null $tmpDirectory Optional parent directory
  78          * @return TempFSFile|null
  79          */
  80         public static function factory( $prefix, $extension = '', $tmpDirectory = null ) {
  81                 return ( new TempFSFileFactory( $tmpDirectory ) )->newTempFSFile( $prefix, $extension );
  82         }
  83
  84         /**
  85          * @todo Is there any useful way to test this? Would it be useful to make this non-static on
  86          * TempFSFileFactory?
  87          *
  88          * @return string Filesystem path to a temporary directory
  89          * @throws RuntimeException if no writable temporary directory can be found
  90          */
  91         public static function getUsableTempDirectory() {
  92                 $tmpDir = array_map( 'getenv', [ 'TMPDIR', 'TMP', 'TEMP' ] );
  93                 $tmpDir[] = sys_get_temp_dir();
  94                 $tmpDir[] = ini_get( 'upload_tmp_dir' );
  95                 foreach ( $tmpDir as $tmp ) {
  96                         if ( $tmp != '' && is_dir( $tmp ) && is_writable( $tmp ) ) {
  97                                 return $tmp;
  98                         }
  99                 }
 100
 101                 // PHP on Windows will detect C:\Windows\Temp as not writable even though PHP can write to
 102                 // it so create a directory within that called 'mwtmp' with a suffix of the user running
 103                 // the current process.
 104                 // The user is included as if various scripts are run by different users they will likely
 105                 // not be able to access each others temporary files.
 106                 if ( PHP_OS_FAMILY === 'Windows' ) {
 107                         $tmp = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'mwtmp-' . get_current_user();
 108                         if ( !is_dir( $tmp ) ) {
 109                                 mkdir( $tmp );
 110                         }
 111                         if ( is_dir( $tmp ) && is_writable( $tmp ) ) {
 112                                 return $tmp;
 113                         }
 114                 }
 115
 116                 throw new RuntimeException(
 117                         'No writable temporary directory could be found. ' .
 118                         'Please explicitly specify a writable directory in configuration.' );
 119         }
 120
 121         /**
 122          * Purge this file off the file system
 123          *
 124          * @return bool Success
 125          */
 126         public function purge() {
 127                 $this->canDelete = false; // done
 128                 AtEase::suppressWarnings();
 129                 $ok = unlink( $this->path );
 130                 AtEase::restoreWarnings();
 131
 132                 unset( self::$pathsCollect[$this->path] );
 133
 134                 return $ok;
 135         }
 136
 137         /**
 138          * Clean up the temporary file only after an object goes out of scope
 139          *
 140          * @param mixed $object
 141          * @return TempFSFile This object
 142          */
 143         public function bind( $object ) {
 144                 if ( is_object( $object ) ) {
 145                         // Use a WeakMap on PHP >= 8.0 to avoid dynamic property creation (T324894)
 146                         if ( PHP_VERSION_ID >= 80000 ) {
 147                                 if ( self::$references === null ) {
 148                                         self::$references = new WeakMap;
 149                                 }
 150                                 self::$references[$object] = $this;
 151                         } else {
 152                                 // PHP 7.4
 153                                 if ( !isset( $object->tempFSFileReferences ) ) {
 154                                         // Init first since $object might use __get() and return only a copy variable
 155                                         $object->tempFSFileReferences = [];
 156                                 }
 157                                 $object->tempFSFileReferences[] = $this;
 158                         }
 159                 }
 160
 161                 return $this;
 162         }
 163
 164         /**
 165          * Set flag to not clean up after the temporary file
 166          *
 167          * @return TempFSFile This object
 168          */
 169         public function preserve() {
 170                 $this->canDelete = false;
 171
 172                 unset( self::$pathsCollect[$this->path] );
 173
 174                 return $this;
 175         }
 176
 177         /**
 178          * Set flag clean up after the temporary file
 179          *
 180          * @return TempFSFile This object
 181          */
 182         public function autocollect() {
 183                 $this->canDelete = true;
 184
 185                 self::$pathsCollect[$this->path] = 1;
 186
 187                 return $this;
 188         }
 189
 190         /**
 191          * Try to make sure that all files are purged on error
 192          *
 193          * This method should only be called internally
 194          *
 195          * @codeCoverageIgnore
 196          */
 197         public static function purgeAllOnShutdown() {
 198                 foreach ( self::$pathsCollect as $path => $unused ) {
 199                         AtEase::suppressWarnings();
 200                         unlink( $path );
 201                         AtEase::restoreWarnings();
 202                 }
 203         }
 204
 205         /**
 206          * Cleans up after the temporary file by deleting it
 207          */
 208         public function __destruct() {
 209                 if ( $this->canDelete ) {
 210                         $this->purge();
 211                 }
 212         }
 213 }
 214
 215 /** @deprecated class alias since 1.43 */
 216 class_alias( TempFSFile::class, 'TempFSFile' );