SpecialUploadStash.php

Go to the documentation of this file.

<?php
class SpecialUploadStash extends UnlistedSpecialPage {
    // UploadStash
    private $stash;

    // Since we are directly writing the file to STDOUT,
    // we should not be reading in really big files and serving them out.
    //
    // We also don't want people using this as a file drop, even if they
    // share credentials.
    //
    // This service is really for thumbnails and other such previews while
    // uploading.
    const MAX_SERVE_BYTES = 1048576; // 1MB

    public function __construct() {
        parent::__construct( 'UploadStash', 'upload' );
        try {
            $this->stash = RepoGroup::singleton()->getLocalRepo()->getUploadStash();
        } catch ( UploadStashNotAvailableException $e ) {
        }
    }

    public function execute( $subPage ) {
        $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 array( 'file' => $file, 'type' => $type, 'params' => $params );
            } else {
                throw new UploadStashBadPathException( 'No handler found for ' .
                        "mime {$file->getMimeType()} of file {$file->getPath()}" );
            }
        }

        return array( 'file' => $file, 'type' => $type );
    }

    private function outputThumbFromStash( $file, $params ) {

        // this global, 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
        global $wgUploadStashScalerBaseUrl;

        $flags = 0;
        if ( $wgUploadStashScalerBaseUrl ) {
            $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. mimetype 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 global probably looks something like 'http://upload.wikimedia.org/wikipedia/test/thumb/temp'
        // do not use trailing slash
        global $wgUploadStashScalerBaseUrl;
        $scalerBaseUrl = $wgUploadStashScalerBaseUrl;

        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 = array(
            'method' => 'GET',
            'timeout' => 'default'
        );
        $req = MWHttpRequest::factory( $scalerThumbUrl, $httpOptions );
        $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(),
            array( '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();
        }
        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 ) {
        if ( isset( $formData['Clear'] ) ) {
            $stash = RepoGroup::singleton()->getLocalRepo()->getUploadStash();
            wfDebug( "stash has: " . print_r( $stash->listFiles(), true ) );
            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->getTitle() ); // Remove subpage
        $form = new HTMLForm( array(
            'Clear' => array(
                'type' => 'hidden',
                'default' => true,
                'name' => 'clear',
            )
        ), $context, 'clearStashedUploads' );
        $form->setSubmitCallback( array( __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',
            array( 'href' => $this->getTitle()->getLocalURL() ),
            $this->msg( 'uploadstash-refresh' )->text() );
        $files = $this->stash->listFiles();
        if ( $files && count( $files ) ) {
            sort( $files );
            $fileListItemsHtml = '';
            foreach ( $files as $file ) {
                // TODO: Use Linker::link or even construct the list in plain wikitext
                $fileListItemsHtml .= Html::rawElement( 'li', array(),
                    Html::element( 'a', array( 'href' =>
                        $this->getTitle( "file/$file" )->getLocalURL() ), $file )
                );
            }
            $this->getOutput()->addHtml( Html::rawElement( 'ul', array(), $fileListItemsHtml ) );
            $form->displayForm( $formResult );
            $this->getOutput()->addHtml( Html::rawElement( 'p', array(), $refreshHtml ) );
        } else {
            $this->getOutput()->addHtml( Html::rawElement( 'p', array(),
                Html::element( 'span', array(), $this->msg( 'uploadstash-nofiles' )->text() )
                . ' '
                . $refreshHtml
            ) );
        }

        return true;
    }
}

class SpecialUploadStashTooLargeException extends MWException {};