Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00% covered (danger)
0.00%
0 / 228
0.00% covered (danger)
0.00%
0 / 15
CRAP
0.00% covered (danger)
0.00%
0 / 1
UploadFromChunks
0.00% covered (danger)
0.00%
0 / 228
0.00% covered (danger)
0.00%
0 / 15
1332
0.00% covered (danger)
0.00%
0 / 1
 __construct
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
12
 tryStashFile
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 doStashFile
0.00% covered (danger)
0.00%
0 / 8
0.00% covered (danger)
0.00%
0 / 1
2
 continueChunks
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
2
 concatenateChunks
0.00% covered (danger)
0.00%
0 / 98
0.00% covered (danger)
0.00%
0 / 1
72
 getVirtualChunkLocation
0.00% covered (danger)
0.00%
0 / 6
0.00% covered (danger)
0.00%
0 / 1
2
 addChunk
0.00% covered (danger)
0.00%
0 / 25
0.00% covered (danger)
0.00%
0 / 1
30
 updateChunkStatus
0.00% covered (danger)
0.00%
0 / 18
0.00% covered (danger)
0.00%
0 / 1
2
 getChunkStatus
0.00% covered (danger)
0.00%
0 / 10
0.00% covered (danger)
0.00%
0 / 1
6
 getChunkIndex
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 getOffset
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 outputChunk
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
6
 getChunkFileKey
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 verifyChunk
0.00% covered (danger)
0.00%
0 / 8
0.00% covered (danger)
0.00%
0 / 1
6
 logFileBackendStatus
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
12
1<?php
2
3use MediaWiki\Deferred\AutoCommitUpdate;
4use MediaWiki\Deferred\DeferredUpdates;
5use MediaWiki\Logger\LoggerFactory;
6use MediaWiki\MediaWikiServices;
7use MediaWiki\Request\WebRequestUpload;
8use MediaWiki\Status\Status;
9use MediaWiki\User\User;
10use Psr\Log\LoggerInterface;
11use Wikimedia\FileBackend\FileBackend;
12
13/**
14 * Backend for uploading files from chunks.
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License along
27 * with this program; if not, write to the Free Software Foundation, Inc.,
28 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
29 * http://www.gnu.org/copyleft/gpl.html
30 *
31 * @file
32 * @ingroup Upload
33 */
34
35/**
36 * Implements uploading from chunks
37 *
38 * @ingroup Upload
39 * @author Michael Dale
40 */
41class UploadFromChunks extends UploadFromFile {
42    /** @var LocalRepo */
43    private $repo;
44    /** @var UploadStash */
45    public $stash;
46    /** @var User */
47    public $user;
48
49    protected $mOffset;
50    protected $mChunkIndex;
51    protected $mFileKey;
52    protected $mVirtualTempPath;
53
54    private LoggerInterface $logger;
55
56    /** @noinspection PhpMissingParentConstructorInspection */
57
58    /**
59     * Setup local pointers to stash, repo and user (similar to UploadFromStash)
60     *
61     * @param User $user
62     * @param UploadStash|false $stash Default: false
63     * @param FileRepo|false $repo Default: false
64     */
65    public function __construct( User $user, $stash = false, $repo = false ) {
66        $this->user = $user;
67
68        if ( $repo ) {
69            $this->repo = $repo;
70        } else {
71            $this->repo = MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo();
72        }
73
74        if ( $stash ) {
75            $this->stash = $stash;
76        } else {
77            wfDebug( __METHOD__ . " creating new UploadFromChunks instance for " . $user->getId() );
78            $this->stash = new UploadStash( $this->repo, $this->user );
79        }
80
81        $this->logger = LoggerFactory::getInstance( 'upload' );
82    }
83
84    /**
85     * @inheritDoc
86     */
87    public function tryStashFile( User $user, $isPartial = false ) {
88        try {
89            $this->verifyChunk();
90        } catch ( UploadChunkVerificationException $e ) {
91            return Status::newFatal( $e->msg );
92        }
93
94        return parent::tryStashFile( $user, $isPartial );
95    }
96
97    /**
98     * Calls the parent doStashFile and updates the uploadsession table to handle "chunks"
99     *
100     * @param User|null $user
101     * @return UploadStashFile Stashed file
102     */
103    protected function doStashFile( User $user = null ) {
104        // Stash file is the called on creating a new chunk session:
105        $this->mChunkIndex = 0;
106        $this->mOffset = 0;
107
108        // Create a local stash target
109        $this->mStashFile = parent::doStashFile( $user );
110        // Update the initial file offset (based on file size)
111        $this->mOffset = $this->mStashFile->getSize();
112        $this->mFileKey = $this->mStashFile->getFileKey();
113
114        // Output a copy of this first to chunk 0 location:
115        $this->outputChunk( $this->mStashFile->getPath() );
116
117        // Update db table to reflect initial "chunk" state
118        $this->updateChunkStatus();
119
120        return $this->mStashFile;
121    }
122
123    /**
124     * Continue chunk uploading
125     *
126     * @param string $name
127     * @param string $key
128     * @param WebRequestUpload $webRequestUpload
129     */
130    public function continueChunks( $name, $key, $webRequestUpload ) {
131        $this->mFileKey = $key;
132        $this->mUpload = $webRequestUpload;
133        // Get the chunk status form the db:
134        $this->getChunkStatus();
135
136        $metadata = $this->stash->getMetadata( $key );
137        $this->initializePathInfo( $name,
138            $this->getRealPath( $metadata['us_path'] ),
139            $metadata['us_size'],
140            false
141        );
142    }
143
144    /**
145     * Append the final chunk and ready file for parent::performUpload()
146     * @return Status
147     */
148    public function concatenateChunks() {
149        $oldFileKey = $this->mFileKey;
150        $chunkIndex = $this->getChunkIndex();
151        $this->logger->debug(
152            __METHOD__ . ' concatenate {totalChunks} chunks: {offset} inx: {curIndex}',
153            [
154                'offset' => $this->getOffset(),
155                'totalChunks' => $this->mChunkIndex,
156                'curIndex' => $chunkIndex,
157                'filekey' => $oldFileKey
158            ]
159        );
160
161        // Concatenate all the chunks to mVirtualTempPath
162        $fileList = [];
163        // The first chunk is stored at the mVirtualTempPath path so we start on "chunk 1"
164        for ( $i = 0; $i <= $chunkIndex; $i++ ) {
165            $fileList[] = $this->getVirtualChunkLocation( $i );
166        }
167
168        // Get the file extension from the last chunk
169        $ext = FileBackend::extensionFromPath( $this->mVirtualTempPath );
170        // Get a 0-byte temp file to perform the concatenation at
171        $tmpFile = MediaWikiServices::getInstance()->getTempFSFileFactory()
172            ->newTempFSFile( 'chunkedupload_', $ext );
173        $tmpPath = false; // fail in concatenate()
174        if ( $tmpFile ) {
175            // keep alive with $this
176            $tmpPath = $tmpFile->bind( $this )->getPath();
177        } else {
178            $this->logger->warning( "Error getting tmp file", [ 'filekey' => $oldFileKey ] );
179        }
180
181        // Concatenate the chunks at the temp file
182        $tStart = microtime( true );
183        $status = $this->repo->concatenate( $fileList, $tmpPath );
184        $tAmount = microtime( true ) - $tStart;
185        if ( !$status->isOK() ) {
186            // This is a backend error and not user-related, so log is safe
187            // Upload verification further on is not safe to log server side
188            $this->logFileBackendStatus(
189                $status,
190                '[{type}] Error on concatenate {chunks} stashed files ({details})',
191                [ 'chunks' => $chunkIndex, 'filekey' => $oldFileKey ]
192            );
193            return $status;
194        } else {
195            // Delete old chunks in deferred job. Put in deferred job because deleting
196            // lots of chunks can take a long time, sometimes to the point of causing
197            // a timeout, and we do not want that to tank the operation. Note that chunks
198            // are also automatically deleted after a set time by cleanupUploadStash.php
199            // Additionally, using AutoCommitUpdate ensures that we do not delete files
200            // if the main transaction is rolled back for some reason.
201            DeferredUpdates::addUpdate( new AutoCommitUpdate(
202                $this->repo->getPrimaryDB(),
203                __METHOD__,
204                function () use( $fileList, $oldFileKey ) {
205                    $status = $this->repo->quickPurgeBatch( $fileList );
206                    if ( !$status->isOK() ) {
207                        $this->logger->warning(
208                            "Could not delete chunks of {filekey} - {status}",
209                            [
210                                'status' => (string)$status,
211                                'filekey' => $oldFileKey,
212                            ]
213                        );
214                    }
215                }
216            ) );
217        }
218
219        wfDebugLog( 'fileconcatenate', "Combined $i chunks in $tAmount seconds." );
220
221        // File system path of the actual full temp file
222        $this->setTempFile( $tmpPath );
223
224        $ret = $this->verifyUpload();
225        if ( $ret['status'] !== UploadBase::OK ) {
226            $this->logger->info(
227                "Verification failed for chunked upload {filekey}",
228                [
229                    'user' => $this->user->getName(),
230                    'filekey' => $oldFileKey
231                ]
232            );
233            $status->fatal( $this->getVerificationErrorCode( $ret['status'] ) );
234
235            return $status;
236        }
237
238        // Update the mTempPath and mStashFile
239        // (for FileUpload or normal Stash to take over)
240        $tStart = microtime( true );
241        // This is a re-implementation of UploadBase::tryStashFile(), we can't call it because we
242        // override doStashFile() with completely different functionality in this class...
243        $error = $this->runUploadStashFileHook( $this->user );
244        if ( $error ) {
245            $status->fatal( ...$error );
246            $this->logger->info( "Aborting stash upload due to hook - {status}",
247                [
248                    'status' => (string)$status,
249                    'user' => $this->user->getName(),
250                    'filekey' => $this->mFileKey
251                ]
252            );
253            return $status;
254        }
255        try {
256            $this->mStashFile = parent::doStashFile( $this->user );
257        } catch ( UploadStashException $e ) {
258            $this->logger->warning( "Could not stash file for {user} because {error} {msg}",
259                [
260                    'user' => $this->user->getName(),
261                    'error' => get_class( $e ),
262                    'msg' => $e->getMessage(),
263                    'filekey' => $this->mFileKey
264                ]
265            );
266            $status->fatal( 'uploadstash-exception', get_class( $e ), $e->getMessage() );
267            return $status;
268        }
269
270        $tAmount = microtime( true ) - $tStart;
271        // @phan-suppress-next-line PhanTypeMismatchArgumentNullable tmpFile is set when tmpPath is set here
272        $this->mStashFile->setLocalReference( $tmpFile ); // reuse (e.g. for getImageInfo())
273        $this->logger->info( "Stashed combined ({chunks} chunks) of {oldkey} under new name {filekey}",
274            [
275                'chunks' => $i,
276                'stashTime' => $tAmount,
277                'oldpath' => $this->mVirtualTempPath,
278                'filekey' => $this->mStashFile->getFileKey(),
279                'oldkey' => $oldFileKey,
280                'newpath' => $this->mStashFile->getPath(),
281                'user' => $this->user->getName()
282            ]
283        );
284        wfDebugLog( 'fileconcatenate', "Stashed combined file ($i chunks) in $tAmount seconds." );
285
286        return $status;
287    }
288
289    /**
290     * Returns the virtual chunk location:
291     * @param int $index
292     * @return string
293     */
294    private function getVirtualChunkLocation( $index ) {
295        return $this->repo->getVirtualUrl( 'temp' ) .
296            '/' .
297            $this->repo->getHashPath(
298                $this->getChunkFileKey( $index )
299            ) .
300            $this->getChunkFileKey( $index );
301    }
302
303    /**
304     * Add a chunk to the temporary directory
305     *
306     * @param string $chunkPath Path to temporary chunk file
307     * @param int $chunkSize Size of the current chunk
308     * @param int $offset Offset of current chunk ( mutch match database chunk offset )
309     * @return Status
310     */
311    public function addChunk( $chunkPath, $chunkSize, $offset ) {
312        // Get the offset before we add the chunk to the file system
313        $preAppendOffset = $this->getOffset();
314
315        if ( $preAppendOffset + $chunkSize > $this->getMaxUploadSize() ) {
316            $status = Status::newFatal( 'file-too-large' );
317        } else {
318            // Make sure the client is uploading the correct chunk with a matching offset.
319            if ( $preAppendOffset == $offset ) {
320                // Update local chunk index for the current chunk
321                $this->mChunkIndex++;
322                try {
323                    # For some reason mTempPath is set to first part
324                    $oldTemp = $this->mTempPath;
325                    $this->mTempPath = $chunkPath;
326                    $this->verifyChunk();
327                    $this->mTempPath = $oldTemp;
328                } catch ( UploadChunkVerificationException $e ) {
329                    $this->logger->info( "Error verifying upload chunk {msg}",
330                        [
331                            'user' => $this->user->getName(),
332                            'msg' => $e->getMessage(),
333                            'chunkIndex' => $this->mChunkIndex,
334                            'filekey' => $this->mFileKey
335                        ]
336                    );
337
338                    return Status::newFatal( $e->msg );
339                }
340                $status = $this->outputChunk( $chunkPath );
341                if ( $status->isGood() ) {
342                    // Update local offset:
343                    $this->mOffset = $preAppendOffset + $chunkSize;
344                    // Update chunk table status db
345                    $this->updateChunkStatus();
346                }
347            } else {
348                $status = Status::newFatal( 'invalid-chunk-offset' );
349            }
350        }
351
352        return $status;
353    }
354
355    /**
356     * Update the chunk db table with the current status:
357     */
358    private function updateChunkStatus() {
359        $this->logger->info( "update chunk status for {filekey} offset: {offset} inx: {inx}",
360            [
361                'offset' => $this->getOffset(),
362                'inx' => $this->getChunkIndex(),
363                'filekey' => $this->mFileKey,
364                'user' => $this->user->getName()
365            ]
366        );
367
368        $dbw = $this->repo->getPrimaryDB();
369        $dbw->newUpdateQueryBuilder()
370            ->update( 'uploadstash' )
371            ->set( [
372                'us_status' => 'chunks',
373                'us_chunk_inx' => $this->getChunkIndex(),
374                'us_size' => $this->getOffset()
375            ] )
376            ->where( [ 'us_key' => $this->mFileKey ] )
377            ->caller( __METHOD__ )->execute();
378    }
379
380    /**
381     * Get the chunk db state and populate update relevant local values
382     */
383    private function getChunkStatus() {
384        // get primary db to avoid race conditions.
385        // Otherwise, if chunk upload time < replag there will be spurious errors
386        $dbw = $this->repo->getPrimaryDB();
387        $row = $dbw->newSelectQueryBuilder()
388            ->select( [ 'us_chunk_inx', 'us_size', 'us_path' ] )
389            ->from( 'uploadstash' )
390            ->where( [ 'us_key' => $this->mFileKey ] )
391            ->caller( __METHOD__ )->fetchRow();
392        // Handle result:
393        if ( $row ) {
394            $this->mChunkIndex = $row->us_chunk_inx;
395            $this->mOffset = $row->us_size;
396            $this->mVirtualTempPath = $row->us_path;
397        }
398    }
399
400    /**
401     * Get the current Chunk index
402     * @return int Index of the current chunk
403     */
404    private function getChunkIndex() {
405        if ( $this->mChunkIndex !== null ) {
406            return $this->mChunkIndex;
407        }
408
409        return 0;
410    }
411
412    /**
413     * Get the offset at which the next uploaded chunk will be appended to
414     * @return int Current byte offset of the chunk file set
415     */
416    public function getOffset() {
417        if ( $this->mOffset !== null ) {
418            return $this->mOffset;
419        }
420
421        return 0;
422    }
423
424    /**
425     * Output the chunk to disk
426     *
427     * @param string $chunkPath
428     * @throws UploadChunkFileException
429     * @return Status
430     */
431    private function outputChunk( $chunkPath ) {
432        // Key is fileKey + chunk index
433        $fileKey = $this->getChunkFileKey();
434
435        // Store the chunk per its indexed fileKey:
436        $hashPath = $this->repo->getHashPath( $fileKey );
437        $storeStatus = $this->repo->quickImport( $chunkPath,
438            $this->repo->getZonePath( 'temp' ) . "/{$hashPath}{$fileKey}" );
439
440        // Check for error in stashing the chunk:
441        if ( !$storeStatus->isOK() ) {
442            $error = $this->logFileBackendStatus(
443                $storeStatus,
444                '[{type}] Error storing chunk in "{chunkPath}" for {fileKey} ({details})',
445                [ 'chunkPath' => $chunkPath, 'fileKey' => $fileKey ]
446            );
447            throw new UploadChunkFileException( "Error storing file in '{chunkPath}': " .
448                implode( '; ', $error ), [ 'chunkPath' => $chunkPath ] );
449        }
450
451        return $storeStatus;
452    }
453
454    private function getChunkFileKey( $index = null ) {
455        return $this->mFileKey . '.' . ( $index ?? $this->getChunkIndex() );
456    }
457
458    /**
459     * Verify that the chunk isn't really an evil html file
460     *
461     * @throws UploadChunkVerificationException
462     */
463    private function verifyChunk() {
464        // Rest mDesiredDestName here so we verify the name as if it were mFileKey
465        $oldDesiredDestName = $this->mDesiredDestName;
466        $this->mDesiredDestName = $this->mFileKey;
467        $this->mTitle = false;
468        $res = $this->verifyPartialFile();
469        $this->mDesiredDestName = $oldDesiredDestName;
470        $this->mTitle = false;
471        if ( is_array( $res ) ) {
472            throw new UploadChunkVerificationException( $res );
473        }
474    }
475
476    /**
477     * Log a status object from FileBackend functions (via FileRepo functions) to the upload log channel.
478     * Return a array with the first error to build up a exception message
479     *
480     * @param Status $status
481     * @param string $logMessage
482     * @param array $context
483     * @return array
484     */
485    private function logFileBackendStatus( Status $status, string $logMessage, array $context = [] ): array {
486        $logger = $this->logger;
487        $errorToThrow = null;
488        $warningToThrow = null;
489
490        foreach ( $status->getErrors() as $errorItem ) {
491            // The message key stands for distinct error situation from the file backend,
492            // each error situation should be shown up in aggregated stats as own point, replace in message
493            $logMessageType = str_replace( '{type}', $errorItem['message'], $logMessage );
494
495            // The message arguments often contains the name of the failing datacenter or file names
496            // and should not show up in aggregated stats, add to context
497            $context['details'] = implode( '; ', $errorItem['params'] );
498            $context['user'] = $this->user->getName();
499
500            if ( $errorItem['type'] === 'error' ) {
501                // Use the first error of the list for the exception text
502                $errorToThrow ??= [ $errorItem['message'], ...$errorItem['params'] ];
503                $logger->error( $logMessageType, $context );
504            } else {
505                // When no error is found, fall back to the first warning
506                $warningToThrow ??= [ $errorItem['message'], ...$errorItem['params'] ];
507                $logger->warning( $logMessageType, $context );
508            }
509        }
510        return $errorToThrow ?? $warningToThrow ?? [ 'unknown', 'no error recorded' ];
511    }
512}