Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
69.05% covered (warning)
69.05%
29 / 42
75.00% covered (warning)
75.00%
6 / 8
 CRAP
0.00% covered (danger)
0.00%
0 / 1
TempFSFile
70.73% covered (warning)
70.73%
29 / 41
75.00% covered (warning)
75.00%
6 / 8
 38.44
0.00% covered (danger)
0.00%
0 / 1
 __construct
100.00% covered (success)
100.00%
2 / 2
100.00% covered (success)
100.00%
1 / 1
 2
 factory
100.00% covered (success)
100.00%
1 / 1
100.00% covered (success)
100.00%
1 / 1
 1
 getUsableTempDirectory
40.00% covered (danger)
40.00%
6 / 15
0.00% covered (danger)
0.00%
0 / 1
 26.50
 purge
100.00% covered (success)
100.00%
6 / 6
100.00% covered (success)
100.00%
1 / 1
 1
 bind
66.67% covered (warning)
66.67%
6 / 9
0.00% covered (danger)
0.00%
0 / 1
 5.93
 preserve
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
 1
 autocollect
100.00% covered (success)
100.00%
3 / 3
100.00% covered (success)
100.00%
1 / 1
 1
 purgeAllOnShutdown
n/a
0 / 0
n/a
0 / 0
 2
 __destruct
100.00% covered (success)
100.00%
2 / 2
100.00% covered (success)
100.00%
1 / 1
 2
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
25namespace Wikimedia\FileBackend\FSFile;
26
27use MediaWiki\FileBackend\FSFile\TempFSFileFactory;
28use RuntimeException;
29use WeakMap;
30use 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 */
38class 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 */
216class_alias( TempFSFile::class, 'TempFSFile' );