SpecialUploadStash.php

Go to the documentation of this file.

<?php
class SpecialUploadStash extends UnlistedSpecialPage {
    // UploadStash
    private $stash;
 
    const MAX_SERVE_BYTES = 1048576; // 1MB
 
    public function __construct() {
        parent::__construct( 'UploadStash', 'upload' );
    }
 
    public function doesWrites() {
        return true;
    }
 
    public function execute( $subPage ) {
        $this->useTransactionalTimeLimit();
 
        $this->stash = RepoGroup::singleton()->getLocalRepo()->getUploadStash( $this->getUser() );
        $this->checkPermissions();
 
        if ( $subPage === null || $subPage === '' ) {
            return $this->showUploads();
        }
 
        return $this->showUpload( $subPage );
    }
 
    public function showUpload( $key ) {
        // prevent callers from doing standard HTML output -- we'll take it from here
        $this->getOutput()->disable();
 
        try {
            $params = $this->parseKey( $key );
            if ( $params['type'] === 'thumb' ) {
                return $this->outputThumbFromStash( $params['file'], $params['params'] );
            } else {
                return $this->outputLocalFile( $params['file'] );
            }
        } catch ( UploadStashFileNotFoundException $e ) {
            $code = 404;
            $message = $e->getMessage();
        } catch ( UploadStashZeroLengthFileException $e ) {
            $code = 500;
            $message = $e->getMessage();
        } catch ( UploadStashBadPathException $e ) {
            $code = 500;
            $message = $e->getMessage();
        } catch ( SpecialUploadStashTooLargeException $e ) {
            $code = 500;
            $message = 'Cannot serve a file larger than ' . self::MAX_SERVE_BYTES .
                ' bytes. ' . $e->getMessage();
        } catch ( Exception $e ) {
            $code = 500;
            $message = $e->getMessage();
        }
 
        throw new HttpError( $code, $message );
    }
 
    private function parseKey( $key ) {
        $type = strtok( $key, '/' );
 
        if ( $type !== 'file' && $type !== 'thumb' ) {
            throw new UploadStashBadPathException( "Unknown type '$type'" );
        }
        $fileName = strtok( '/' );
        $thumbPart = strtok( '/' );
        $file = $this->stash->getFile( $fileName );
        if ( $type === 'thumb' ) {
            $srcNamePos = strrpos( $thumbPart, $fileName );
            if ( $srcNamePos === false || $srcNamePos < 1 ) {
                throw new UploadStashBadPathException( 'Unrecognized thumb name' );
            }
            $paramString = substr( $thumbPart, 0, $srcNamePos - 1 );
 
            $handler = $file->getHandler();
            if ( $handler ) {
                $params = $handler->parseParamString( $paramString );
 
                return [ 'file' => $file, 'type' => $type, 'params' => $params ];
            } else {
                throw new UploadStashBadPathException( 'No handler found for ' .
                    "mime {$file->getMimeType()} of file {$file->getPath()}" );
            }
        }
 
        return [ 'file' => $file, 'type' => $type ];
    }
 
    private function outputThumbFromStash( $file, $params ) {
        $flags = 0;
        // this config option, if it exists, points to a "scaler", as you might find in
        // the Wikimedia Foundation cluster. See outputRemoteScaledThumb(). This
        // is part of our horrible NFS-based system, we create a file on a mount
        // point here, but fetch the scaled file from somewhere else that
        // happens to share it over NFS.
        if ( $this->getConfig()->get( 'UploadStashScalerBaseUrl' ) ) {
            $this->outputRemoteScaledThumb( $file, $params, $flags );
        } else {
            $this->outputLocallyScaledThumb( $file, $params, $flags );
        }
    }
 
    private function outputLocallyScaledThumb( $file, $params, $flags ) {
        // n.b. this is stupid, we insist on re-transforming the file every time we are invoked. We rely
        // on HTTP caching to ensure this doesn't happen.
 
        $flags |= File::RENDER_NOW;
 
        $thumbnailImage = $file->transform( $params, $flags );
        if ( !$thumbnailImage ) {
            throw new MWException( 'Could not obtain thumbnail' );
        }
 
        // we should have just generated it locally
        if ( !$thumbnailImage->getStoragePath() ) {
            throw new UploadStashFileNotFoundException( "no local path for scaled item" );
        }
 
        // now we should construct a File, so we can get MIME and other such info in a standard way
        // n.b. MIME type may be different from original (ogx original -> jpeg thumb)
        $thumbFile = new UnregisteredLocalFile( false,
            $this->stash->repo, $thumbnailImage->getStoragePath(), false );
        if ( !$thumbFile ) {
            throw new UploadStashFileNotFoundException( "couldn't create local file object for thumbnail" );
        }
 
        return $this->outputLocalFile( $thumbFile );
    }
 
    private function outputRemoteScaledThumb( $file, $params, $flags ) {
        // This option probably looks something like
        // '//upload.wikimedia.org/wikipedia/test/thumb/temp'. Do not use
        // trailing slash.
        $scalerBaseUrl = $this->getConfig()->get( 'UploadStashScalerBaseUrl' );
 
        if ( preg_match( '/^\/\//', $scalerBaseUrl ) ) {
            // this is apparently a protocol-relative URL, which makes no sense in this context,
            // since this is used for communication that's internal to the application.
            // default to http.
            $scalerBaseUrl = wfExpandUrl( $scalerBaseUrl, PROTO_CANONICAL );
        }
 
        // We need to use generateThumbName() instead of thumbName(), because
        // the suffix needs to match the file name for the remote thumbnailer
        // to work
        $scalerThumbName = $file->generateThumbName( $file->getName(), $params );
        $scalerThumbUrl = $scalerBaseUrl . '/' . $file->getUrlRel() .
            '/' . rawurlencode( $scalerThumbName );
 
        // make a curl call to the scaler to create a thumbnail
        $httpOptions = [
            'method' => 'GET',
            'timeout' => 5 // T90599 attempt to time out cleanly
        ];
        $req = MWHttpRequest::factory( $scalerThumbUrl, $httpOptions, __METHOD__ );
        $status = $req->execute();
        if ( !$status->isOK() ) {
            $errors = $status->getErrorsArray();
            $errorStr = "Fetching thumbnail failed: " . print_r( $errors, 1 );
            $errorStr .= "\nurl = $scalerThumbUrl\n";
            throw new MWException( $errorStr );
        }
        $contentType = $req->getResponseHeader( "content-type" );
        if ( !$contentType ) {
            throw new MWException( "Missing content-type header" );
        }
 
        return $this->outputContents( $req->getContent(), $contentType );
    }
 
    private function outputLocalFile( File $file ) {
        if ( $file->getSize() > self::MAX_SERVE_BYTES ) {
            throw new SpecialUploadStashTooLargeException();
        }
 
        return $file->getRepo()->streamFile( $file->getPath(),
            [ 'Content-Transfer-Encoding: binary',
                'Expires: Sun, 17-Jan-2038 19:14:07 GMT' ]
        );
    }
 
    private function outputContents( $content, $contentType ) {
        $size = strlen( $content );
        if ( $size > self::MAX_SERVE_BYTES ) {
            throw new SpecialUploadStashTooLargeException();
        }
        // Cancel output buffering and gzipping if set
        wfResetOutputBuffers();
        self::outputFileHeaders( $contentType, $size );
        print $content;
 
        return true;
    }
 
    private static function outputFileHeaders( $contentType, $size ) {
        header( "Content-Type: $contentType", true );
        header( 'Content-Transfer-Encoding: binary', true );
        header( 'Expires: Sun, 17-Jan-2038 19:14:07 GMT', true );
        // Bug 53032 - It shouldn't be a problem here, but let's be safe and not cache
        header( 'Cache-Control: private' );
        header( "Content-Length: $size", true );
    }
 
    public static function tryClearStashedUploads( $formData, $form ) {
        if ( isset( $formData['Clear'] ) ) {
            $stash = RepoGroup::singleton()->getLocalRepo()->getUploadStash( $form->getUser() );
            wfDebug( 'stash has: ' . print_r( $stash->listFiles(), true ) . "\n" );
 
            if ( !$stash->clear() ) {
                return Status::newFatal( 'uploadstash-errclear' );
            }
        }
 
        return Status::newGood();
    }
 
    private function showUploads() {
        // sets the title, etc.
        $this->setHeaders();
        $this->outputHeader();
 
        // create the form, which will also be used to execute a callback to process incoming form data
        // this design is extremely dubious, but supposedly HTMLForm is our standard now?
 
        $context = new DerivativeContext( $this->getContext() );
        $context->setTitle( $this->getPageTitle() ); // Remove subpage
        $form = HTMLForm::factory( 'ooui', [
            'Clear' => [
                'type' => 'hidden',
                'default' => true,
                'name' => 'clear',
            ]
        ], $context, 'clearStashedUploads' );
        $form->setSubmitDestructive();
        $form->setSubmitCallback( [ __CLASS__, 'tryClearStashedUploads' ] );
        $form->setSubmitTextMsg( 'uploadstash-clear' );
 
        $form->prepareForm();
        $formResult = $form->tryAuthorizedSubmit();
 
        // show the files + form, if there are any, or just say there are none
        $refreshHtml = Html::element( 'a',
            [ 'href' => $this->getPageTitle()->getLocalURL() ],
            $this->msg( 'uploadstash-refresh' )->text() );
        $files = $this->stash->listFiles();
        if ( $files && count( $files ) ) {
            sort( $files );
            $fileListItemsHtml = '';
            $linkRenderer = $this->getLinkRenderer();
            foreach ( $files as $file ) {
                $itemHtml = $linkRenderer->makeKnownLink(
                    $this->getPageTitle( "file/$file" ),
                    $file
                );
                try {
                    $fileObj = $this->stash->getFile( $file );
                    $thumb = $fileObj->generateThumbName( $file, [ 'width' => 220 ] );
                    $itemHtml .=
                        $this->msg( 'word-separator' )->escaped() .
                        $this->msg( 'parentheses' )->rawParams(
                            $linkRenderer->makeKnownLink(
                                $this->getPageTitle( "thumb/$file/$thumb" ),
                                $this->msg( 'uploadstash-thumbnail' )->text()
                            )
                        )->escaped();
                } catch ( Exception $e ) {
                }
                $fileListItemsHtml .= Html::rawElement( 'li', [], $itemHtml );
            }
            $this->getOutput()->addHTML( Html::rawElement( 'ul', [], $fileListItemsHtml ) );
            $form->displayForm( $formResult );
            $this->getOutput()->addHTML( Html::rawElement( 'p', [], $refreshHtml ) );
        } else {
            $this->getOutput()->addHTML( Html::rawElement( 'p', [],
                Html::element( 'span', [], $this->msg( 'uploadstash-nofiles' )->text() )
                . ' '
                . $refreshHtml
            ) );
        }
 
        return true;
    }
}
 
class SpecialUploadStashTooLargeException extends MWException {
}