File.php

Go to the documentation of this file.

<?php
abstract class File implements IDBAccessObject {
    // Bitfield values akin to the Revision deletion constants
    const DELETED_FILE = 1;
    const DELETED_COMMENT = 2;
    const DELETED_USER = 4;
    const DELETED_RESTRICTED = 8;

    const RENDER_NOW = 1;
    const RENDER_FORCE = 2;

    const DELETE_SOURCE = 1;

    // Audience options for File::getDescription()
    const FOR_PUBLIC = 1;
    const FOR_THIS_USER = 2;
    const RAW = 3;

    // Options for File::thumbName()
    const THUMB_FULL_NAME = 1;

    public $repo;

    protected $title;

    protected $lastError;

    protected $redirected;

    protected $redirectedTitle;

    protected $fsFile;

    protected $handler;

    protected $url;

    protected $extension;

    protected $name;

    protected $path;

    protected $hashPath;

    protected $pageCount;

    protected $transformScript;

    protected $redirectTitle;

    protected $canRender;

    protected $isSafeFile;

    protected $repoClass = 'FileRepo';

    protected $tmpBucketedThumbCache = [];

    function __construct( $title, $repo ) {
        // Some subclasses do not use $title, but set name/title some other way
        if ( $title !== false ) {
            $title = self::normalizeTitle( $title, 'exception' );
        }
        $this->title = $title;
        $this->repo = $repo;
    }

    static function normalizeTitle( $title, $exception = false ) {
        $ret = $title;
        if ( $ret instanceof Title ) {
            # Normalize NS_MEDIA -> NS_FILE
            if ( $ret->getNamespace() == NS_MEDIA ) {
                $ret = Title::makeTitleSafe( NS_FILE, $ret->getDBkey() );
            # Sanity check the title namespace
            } elseif ( $ret->getNamespace() !== NS_FILE ) {
                $ret = null;
            }
        } else {
            # Convert strings to Title objects
            $ret = Title::makeTitleSafe( NS_FILE, (string)$ret );
        }
        if ( !$ret && $exception !== false ) {
            throw new MWException( "`$title` is not a valid file title." );
        }

        return $ret;
    }

    function __get( $name ) {
        $function = [ $this, 'get' . ucfirst( $name ) ];
        if ( !is_callable( $function ) ) {
            return null;
        } else {
            $this->$name = call_user_func( $function );

            return $this->$name;
        }
    }

    static function normalizeExtension( $extension ) {
        $lower = strtolower( $extension );
        $squish = [
            'htm' => 'html',
            'jpeg' => 'jpg',
            'mpeg' => 'mpg',
            'tiff' => 'tif',
            'ogv' => 'ogg' ];
        if ( isset( $squish[$lower] ) ) {
            return $squish[$lower];
        } elseif ( preg_match( '/^[0-9a-z]+$/', $lower ) ) {
            return $lower;
        } else {
            return '';
        }
    }

    static function checkExtensionCompatibility( File $old, $new ) {
        $oldMime = $old->getMimeType();
        $n = strrpos( $new, '.' );
        $newExt = self::normalizeExtension( $n ? substr( $new, $n + 1 ) : '' );
        $mimeMagic = MimeMagic::singleton();

        return $mimeMagic->isMatchingExtension( $newExt, $oldMime );
    }

    function upgradeRow() {
    }

    public static function splitMime( $mime ) {
        if ( strpos( $mime, '/' ) !== false ) {
            return explode( '/', $mime, 2 );
        } else {
            return [ $mime, 'unknown' ];
        }
    }

    public static function compare( File $a, File $b ) {
        return strcmp( $a->getName(), $b->getName() );
    }

    public function getName() {
        if ( !isset( $this->name ) ) {
            $this->assertRepoDefined();
            $this->name = $this->repo->getNameFromTitle( $this->title );
        }

        return $this->name;
    }

    function getExtension() {
        if ( !isset( $this->extension ) ) {
            $n = strrpos( $this->getName(), '.' );
            $this->extension = self::normalizeExtension(
                $n ? substr( $this->getName(), $n + 1 ) : '' );
        }

        return $this->extension;
    }

    public function getTitle() {
        return $this->title;
    }

    public function getOriginalTitle() {
        if ( $this->redirected ) {
            return $this->getRedirectedTitle();
        }

        return $this->title;
    }

    public function getUrl() {
        if ( !isset( $this->url ) ) {
            $this->assertRepoDefined();
            $ext = $this->getExtension();
            $this->url = $this->repo->getZoneUrl( 'public', $ext ) . '/' . $this->getUrlRel();
        }

        return $this->url;
    }

    /*
     * Get short description URL for a files based on the page ID
     *
     * @return string|null
     * @since 1.27
     */
    public function getDescriptionShortUrl() {
        return null;
    }

    public function getFullUrl() {
        return wfExpandUrl( $this->getUrl(), PROTO_RELATIVE );
    }

    public function getCanonicalUrl() {
        return wfExpandUrl( $this->getUrl(), PROTO_CANONICAL );
    }

    function getViewURL() {
        if ( $this->mustRender() ) {
            if ( $this->canRender() ) {
                return $this->createThumb( $this->getWidth() );
            } else {
                wfDebug( __METHOD__ . ': supposed to render ' . $this->getName() .
                    ' (' . $this->getMimeType() . "), but can't!\n" );

                return $this->getUrl(); # hm... return NULL?
            }
        } else {
            return $this->getUrl();
        }
    }

    public function getPath() {
        if ( !isset( $this->path ) ) {
            $this->assertRepoDefined();
            $this->path = $this->repo->getZonePath( 'public' ) . '/' . $this->getRel();
        }

        return $this->path;
    }

    public function getLocalRefPath() {
        $this->assertRepoDefined();
        if ( !isset( $this->fsFile ) ) {
            $starttime = microtime( true );
            $this->fsFile = $this->repo->getLocalReference( $this->getPath() );

            $statTiming = microtime( true ) - $starttime;
            RequestContext::getMain()->getStats()->timing(
                'media.thumbnail.generate.fetchoriginal', 1000 * $statTiming );

            if ( !$this->fsFile ) {
                $this->fsFile = false; // null => false; cache negative hits
            }
        }

        return ( $this->fsFile )
            ? $this->fsFile->getPath()
            : false;
    }

    public function getWidth( $page = 1 ) {
        return false;
    }

    public function getHeight( $page = 1 ) {
        return false;
    }

    public function getThumbnailBucket( $desiredWidth, $page = 1 ) {
        global $wgThumbnailBuckets, $wgThumbnailMinimumBucketDistance;

        $imageWidth = $this->getWidth( $page );

        if ( $imageWidth === false ) {
            return false;
        }

        if ( $desiredWidth > $imageWidth ) {
            return false;
        }

        if ( !$wgThumbnailBuckets ) {
            return false;
        }

        $sortedBuckets = $wgThumbnailBuckets;

        sort( $sortedBuckets );

        foreach ( $sortedBuckets as $bucket ) {
            if ( $bucket >= $imageWidth ) {
                return false;
            }

            if ( $bucket - $wgThumbnailMinimumBucketDistance > $desiredWidth ) {
                return $bucket;
            }
        }

        // Image is bigger than any available bucket
        return false;
    }

    public function getUser( $type = 'text' ) {
        return null;
    }

    public function getLength() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getLength( $this );
        } else {
            return 0;
        }
    }

    public function isVectorized() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->isVectorized( $this );
        } else {
            return false;
        }
    }

    public function getAvailableLanguages() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getAvailableLanguages( $this );
        } else {
            return [];
        }
    }

    public function getDefaultRenderLanguage() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getDefaultRenderLanguage( $this );
        } else {
            return null;
        }
    }

    public function canAnimateThumbIfAppropriate() {
        $handler = $this->getHandler();
        if ( !$handler ) {
            // We cannot handle image whatsoever, thus
            // one would not expect it to be animated
            // so true.
            return true;
        } else {
            if ( $this->allowInlineDisplay()
                && $handler->isAnimatedImage( $this )
                && !$handler->canAnimateThumbnail( $this )
            ) {
                // Image is animated, but thumbnail isn't.
                // This is unexpected to the user.
                return false;
            } else {
                // Image is not animated, so one would
                // not expect thumb to be
                return true;
            }
        }
    }

    public function getMetadata() {
        return false;
    }

    public function getCommonMetaArray() {
        $handler = $this->getHandler();

        if ( !$handler ) {
            return false;
        }

        return $handler->getCommonMetaArray( $this );
    }

    public function convertMetadataVersion( $metadata, $version ) {
        $handler = $this->getHandler();
        if ( !is_array( $metadata ) ) {
            // Just to make the return type consistent
            $metadata = unserialize( $metadata );
        }
        if ( $handler ) {
            return $handler->convertMetadataVersion( $metadata, $version );
        } else {
            return $metadata;
        }
    }

    public function getBitDepth() {
        return 0;
    }

    public function getSize() {
        return false;
    }

    function getMimeType() {
        return 'unknown/unknown';
    }

    function getMediaType() {
        return MEDIATYPE_UNKNOWN;
    }

    function canRender() {
        if ( !isset( $this->canRender ) ) {
            $this->canRender = $this->getHandler() && $this->handler->canRender( $this ) && $this->exists();
        }

        return $this->canRender;
    }

    protected function getCanRender() {
        return $this->canRender();
    }

    function mustRender() {
        return $this->getHandler() && $this->handler->mustRender( $this );
    }

    function allowInlineDisplay() {
        return $this->canRender();
    }

    function isSafeFile() {
        if ( !isset( $this->isSafeFile ) ) {
            $this->isSafeFile = $this->getIsSafeFileUncached();
        }

        return $this->isSafeFile;
    }

    protected function getIsSafeFile() {
        return $this->isSafeFile();
    }

    protected function getIsSafeFileUncached() {
        global $wgTrustedMediaFormats;

        if ( $this->allowInlineDisplay() ) {
            return true;
        }
        if ( $this->isTrustedFile() ) {
            return true;
        }

        $type = $this->getMediaType();
        $mime = $this->getMimeType();
        # wfDebug( "LocalFile::isSafeFile: type= $type, mime= $mime\n" );

        if ( !$type || $type === MEDIATYPE_UNKNOWN ) {
            return false; # unknown type, not trusted
        }
        if ( in_array( $type, $wgTrustedMediaFormats ) ) {
            return true;
        }

        if ( $mime === "unknown/unknown" ) {
            return false; # unknown type, not trusted
        }
        if ( in_array( $mime, $wgTrustedMediaFormats ) ) {
            return true;
        }

        return false;
    }

    function isTrustedFile() {
        # this could be implemented to check a flag in the database,
        # look for signatures, etc
        return false;
    }

    public function load( $flags = 0 ) {
    }

    public function exists() {
        return $this->getPath() && $this->repo->fileExists( $this->path );
    }

    public function isVisible() {
        return $this->exists();
    }

    function getTransformScript() {
        if ( !isset( $this->transformScript ) ) {
            $this->transformScript = false;
            if ( $this->repo ) {
                $script = $this->repo->getThumbScriptUrl();
                if ( $script ) {
                    $this->transformScript = wfAppendQuery( $script, [ 'f' => $this->getName() ] );
                }
            }
        }

        return $this->transformScript;
    }

    function getUnscaledThumb( $handlerParams = [] ) {
        $hp =& $handlerParams;
        $page = isset( $hp['page'] ) ? $hp['page'] : false;
        $width = $this->getWidth( $page );
        if ( !$width ) {
            return $this->iconThumb();
        }
        $hp['width'] = $width;
        // be sure to ignore any height specification as well (bug 62258)
        unset( $hp['height'] );

        return $this->transform( $hp );
    }

    public function thumbName( $params, $flags = 0 ) {
        $name = ( $this->repo && !( $flags & self::THUMB_FULL_NAME ) )
            ? $this->repo->nameForThumb( $this->getName() )
            : $this->getName();

        return $this->generateThumbName( $name, $params );
    }

    public function generateThumbName( $name, $params ) {
        if ( !$this->getHandler() ) {
            return null;
        }
        $extension = $this->getExtension();
        list( $thumbExt, ) = $this->getHandler()->getThumbType(
            $extension, $this->getMimeType(), $params );
        $thumbName = $this->getHandler()->makeParamString( $params );

        if ( $this->repo->supportsSha1URLs() ) {
            $thumbName .= '-' . $this->getSha1() . '.' . $thumbExt;
        } else {
            $thumbName .= '-' . $name;

            if ( $thumbExt != $extension ) {
                $thumbName .= ".$thumbExt";
            }
        }

        return $thumbName;
    }

    public function createThumb( $width, $height = -1 ) {
        $params = [ 'width' => $width ];
        if ( $height != -1 ) {
            $params['height'] = $height;
        }
        $thumb = $this->transform( $params );
        if ( !$thumb || $thumb->isError() ) {
            return '';
        }

        return $thumb->getUrl();
    }

    protected function transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags ) {
        global $wgIgnoreImageErrors;

        $handler = $this->getHandler();
        if ( $handler && $wgIgnoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
            return $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
        } else {
            return new MediaTransformError( 'thumbnail_error',
                $params['width'], 0, wfMessage( 'thumbnail-dest-create' )->text() );
        }
    }

    function transform( $params, $flags = 0 ) {
        global $wgThumbnailEpoch;

        do {
            if ( !$this->canRender() ) {
                $thumb = $this->iconThumb();
                break; // not a bitmap or renderable image, don't try
            }

            // Get the descriptionUrl to embed it as comment into the thumbnail. Bug 19791.
            $descriptionUrl = $this->getDescriptionUrl();
            if ( $descriptionUrl ) {
                $params['descriptionUrl'] = wfExpandUrl( $descriptionUrl, PROTO_CANONICAL );
            }

            $handler = $this->getHandler();
            $script = $this->getTransformScript();
            if ( $script && !( $flags & self::RENDER_NOW ) ) {
                // Use a script to transform on client request, if possible
                $thumb = $handler->getScriptedTransform( $this, $script, $params );
                if ( $thumb ) {
                    break;
                }
            }

            $normalisedParams = $params;
            $handler->normaliseParams( $this, $normalisedParams );

            $thumbName = $this->thumbName( $normalisedParams );
            $thumbUrl = $this->getThumbUrl( $thumbName );
            $thumbPath = $this->getThumbPath( $thumbName ); // final thumb path

            if ( $this->repo ) {
                // Defer rendering if a 404 handler is set up...
                if ( $this->repo->canTransformVia404() && !( $flags & self::RENDER_NOW ) ) {
                    // XXX: Pass in the storage path even though we are not rendering anything
                    // and the path is supposed to be an FS path. This is due to getScalerType()
                    // getting called on the path and clobbering $thumb->getUrl() if it's false.
                    $thumb = $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
                    break;
                }
                // Check if an up-to-date thumbnail already exists...
                wfDebug( __METHOD__ . ": Doing stat for $thumbPath\n" );
                if ( !( $flags & self::RENDER_FORCE ) && $this->repo->fileExists( $thumbPath ) ) {
                    $timestamp = $this->repo->getFileTimestamp( $thumbPath );
                    if ( $timestamp !== false && $timestamp >= $wgThumbnailEpoch ) {
                        // XXX: Pass in the storage path even though we are not rendering anything
                        // and the path is supposed to be an FS path. This is due to getScalerType()
                        // getting called on the path and clobbering $thumb->getUrl() if it's false.
                        $thumb = $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
                        $thumb->setStoragePath( $thumbPath );
                        break;
                    }
                } elseif ( $flags & self::RENDER_FORCE ) {
                    wfDebug( __METHOD__ . " forcing rendering per flag File::RENDER_FORCE\n" );
                }

                // If the backend is ready-only, don't keep generating thumbnails
                // only to return transformation errors, just return the error now.
                if ( $this->repo->getReadOnlyReason() !== false ) {
                    $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
                    break;
                }
            }

            $tmpFile = $this->makeTransformTmpFile( $thumbPath );

            if ( !$tmpFile ) {
                $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
            } else {
                $thumb = $this->generateAndSaveThumb( $tmpFile, $params, $flags );
            }
        } while ( false );

        return is_object( $thumb ) ? $thumb : false;
    }

    public function generateAndSaveThumb( $tmpFile, $transformParams, $flags ) {
        global $wgIgnoreImageErrors;

        $stats = RequestContext::getMain()->getStats();

        $handler = $this->getHandler();

        $normalisedParams = $transformParams;
        $handler->normaliseParams( $this, $normalisedParams );

        $thumbName = $this->thumbName( $normalisedParams );
        $thumbUrl = $this->getThumbUrl( $thumbName );
        $thumbPath = $this->getThumbPath( $thumbName ); // final thumb path

        $tmpThumbPath = $tmpFile->getPath();

        if ( $handler->supportsBucketing() ) {
            $this->generateBucketsIfNeeded( $normalisedParams, $flags );
        }

        $starttime = microtime( true );

        // Actually render the thumbnail...
        $thumb = $handler->doTransform( $this, $tmpThumbPath, $thumbUrl, $transformParams );
        $tmpFile->bind( $thumb ); // keep alive with $thumb

        $statTiming = microtime( true ) - $starttime;
        $stats->timing( 'media.thumbnail.generate.transform', 1000 * $statTiming );

        if ( !$thumb ) { // bad params?
            $thumb = false;
        } elseif ( $thumb->isError() ) { // transform error
            $this->lastError = $thumb->toText();
            // Ignore errors if requested
            if ( $wgIgnoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
                $thumb = $handler->getTransform( $this, $tmpThumbPath, $thumbUrl, $transformParams );
            }
        } elseif ( $this->repo && $thumb->hasFile() && !$thumb->fileIsSource() ) {
            // Copy the thumbnail from the file system into storage...

            $starttime = microtime( true );

            $disposition = $this->getThumbDisposition( $thumbName );
            $status = $this->repo->quickImport( $tmpThumbPath, $thumbPath, $disposition );
            if ( $status->isOK() ) {
                $thumb->setStoragePath( $thumbPath );
            } else {
                $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $transformParams, $flags );
            }

            $statTiming = microtime( true ) - $starttime;
            $stats->timing( 'media.thumbnail.generate.store', 1000 * $statTiming );

            // Give extensions a chance to do something with this thumbnail...
            Hooks::run( 'FileTransformed', [ $this, $thumb, $tmpThumbPath, $thumbPath ] );
        }

        return $thumb;
    }

    protected function generateBucketsIfNeeded( $params, $flags = 0 ) {
        if ( !$this->repo
            || !isset( $params['physicalWidth'] )
            || !isset( $params['physicalHeight'] )
        ) {
            return false;
        }

        $bucket = $this->getThumbnailBucket( $params['physicalWidth'] );

        if ( !$bucket || $bucket == $params['physicalWidth'] ) {
            return false;
        }

        $bucketPath = $this->getBucketThumbPath( $bucket );

        if ( $this->repo->fileExists( $bucketPath ) ) {
            return false;
        }

        $starttime = microtime( true );

        $params['physicalWidth'] = $bucket;
        $params['width'] = $bucket;

        $params = $this->getHandler()->sanitizeParamsForBucketing( $params );

        $tmpFile = $this->makeTransformTmpFile( $bucketPath );

        if ( !$tmpFile ) {
            return false;
        }

        $thumb = $this->generateAndSaveThumb( $tmpFile, $params, $flags );

        $buckettime = microtime( true ) - $starttime;

        if ( !$thumb || $thumb->isError() ) {
            return false;
        }

        $this->tmpBucketedThumbCache[$bucket] = $tmpFile->getPath();
        // For the caching to work, we need to make the tmp file survive as long as
        // this object exists
        $tmpFile->bind( $this );

        RequestContext::getMain()->getStats()->timing(
            'media.thumbnail.generate.bucket', 1000 * $buckettime );

        return true;
    }

    public function getThumbnailSource( $params ) {
        if ( $this->repo
            && $this->getHandler()->supportsBucketing()
            && isset( $params['physicalWidth'] )
            && $bucket = $this->getThumbnailBucket( $params['physicalWidth'] )
        ) {
            if ( $this->getWidth() != 0 ) {
                $bucketHeight = round( $this->getHeight() * ( $bucket / $this->getWidth() ) );
            } else {
                $bucketHeight = 0;
            }

            // Try to avoid reading from storage if the file was generated by this script
            if ( isset( $this->tmpBucketedThumbCache[$bucket] ) ) {
                $tmpPath = $this->tmpBucketedThumbCache[$bucket];

                if ( file_exists( $tmpPath ) ) {
                    return [
                        'path' => $tmpPath,
                        'width' => $bucket,
                        'height' => $bucketHeight
                    ];
                }
            }

            $bucketPath = $this->getBucketThumbPath( $bucket );

            if ( $this->repo->fileExists( $bucketPath ) ) {
                $fsFile = $this->repo->getLocalReference( $bucketPath );

                if ( $fsFile ) {
                    return [
                        'path' => $fsFile->getPath(),
                        'width' => $bucket,
                        'height' => $bucketHeight
                    ];
                }
            }
        }

        // Thumbnailing a very large file could result in network saturation if
        // everyone does it at once.
        if ( $this->getSize() >= 1e7 ) { // 10MB
            $that = $this;
            $work = new PoolCounterWorkViaCallback( 'GetLocalFileCopy', sha1( $this->getName() ),
                [
                    'doWork' => function () use ( $that ) {
                        return $that->getLocalRefPath();
                    }
                ]
            );
            $srcPath = $work->execute();
        } else {
            $srcPath = $this->getLocalRefPath();
        }

        // Original file
        return [
            'path' => $srcPath,
            'width' => $this->getWidth(),
            'height' => $this->getHeight()
        ];
    }

    protected function getBucketThumbPath( $bucket ) {
        $thumbName = $this->getBucketThumbName( $bucket );
        return $this->getThumbPath( $thumbName );
    }

    protected function getBucketThumbName( $bucket ) {
        return $this->thumbName( [ 'physicalWidth' => $bucket ] );
    }

    protected function makeTransformTmpFile( $thumbPath ) {
        $thumbExt = FileBackend::extensionFromPath( $thumbPath );
        return TempFSFile::factory( 'transform_', $thumbExt, wfTempDir() );
    }

    function getThumbDisposition( $thumbName, $dispositionType = 'inline' ) {
        $fileName = $this->name; // file name to suggest
        $thumbExt = FileBackend::extensionFromPath( $thumbName );
        if ( $thumbExt != '' && $thumbExt !== $this->getExtension() ) {
            $fileName .= ".$thumbExt";
        }

        return FileBackend::makeContentDisposition( $dispositionType, $fileName );
    }

    function migrateThumbFile( $thumbName ) {
    }

    function getHandler() {
        if ( !isset( $this->handler ) ) {
            $this->handler = MediaHandler::getHandler( $this->getMimeType() );
        }

        return $this->handler;
    }

    function iconThumb() {
        global $wgResourceBasePath, $IP;
        $assetsPath = "$wgResourceBasePath/resources/assets/file-type-icons/";
        $assetsDirectory = "$IP/resources/assets/file-type-icons/";

        $try = [ 'fileicon-' . $this->getExtension() . '.png', 'fileicon.png' ];
        foreach ( $try as $icon ) {
            if ( file_exists( $assetsDirectory . $icon ) ) { // always FS
                $params = [ 'width' => 120, 'height' => 120 ];

                return new ThumbnailImage( $this, $assetsPath . $icon, false, $params );
            }
        }

        return null;
    }

    function getLastError() {
        return $this->lastError;
    }

    function getThumbnails() {
        return [];
    }

    function purgeCache( $options = [] ) {
    }

    function purgeDescription() {
        $title = $this->getTitle();
        if ( $title ) {
            $title->invalidateCache();
            $title->purgeSquid();
        }
    }

    function purgeEverything() {
        // Delete thumbnails and refresh file metadata cache
        $this->purgeCache();
        $this->purgeDescription();

        // Purge cache of all pages using this file
        $title = $this->getTitle();
        if ( $title ) {
            DeferredUpdates::addUpdate( new HTMLCacheUpdate( $title, 'imagelinks' ) );
        }
    }

    function getHistory( $limit = null, $start = null, $end = null, $inc = true ) {
        return [];
    }

    public function nextHistoryLine() {
        return false;
    }

    public function resetHistory() {
    }

    function getHashPath() {
        if ( !isset( $this->hashPath ) ) {
            $this->assertRepoDefined();
            $this->hashPath = $this->repo->getHashPath( $this->getName() );
        }

        return $this->hashPath;
    }

    function getRel() {
        return $this->getHashPath() . $this->getName();
    }

    function getArchiveRel( $suffix = false ) {
        $path = 'archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= $suffix;
        }

        return $path;
    }

    function getThumbRel( $suffix = false ) {
        $path = $this->getRel();
        if ( $suffix !== false ) {
            $path .= '/' . $suffix;
        }

        return $path;
    }

    function getUrlRel() {
        return $this->getHashPath() . rawurlencode( $this->getName() );
    }

    function getArchiveThumbRel( $archiveName, $suffix = false ) {
        $path = 'archive/' . $this->getHashPath() . $archiveName . "/";
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= $suffix;
        }

        return $path;
    }

    function getArchivePath( $suffix = false ) {
        $this->assertRepoDefined();

        return $this->repo->getZonePath( 'public' ) . '/' . $this->getArchiveRel( $suffix );
    }

    function getArchiveThumbPath( $archiveName, $suffix = false ) {
        $this->assertRepoDefined();

        return $this->repo->getZonePath( 'thumb' ) . '/' .
        $this->getArchiveThumbRel( $archiveName, $suffix );
    }

    function getThumbPath( $suffix = false ) {
        $this->assertRepoDefined();

        return $this->repo->getZonePath( 'thumb' ) . '/' . $this->getThumbRel( $suffix );
    }

    function getTranscodedPath( $suffix = false ) {
        $this->assertRepoDefined();

        return $this->repo->getZonePath( 'transcoded' ) . '/' . $this->getThumbRel( $suffix );
    }

    function getArchiveUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( 'public', $ext ) . '/archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= rawurlencode( $suffix );
        }

        return $path;
    }

    function getArchiveThumbUrl( $archiveName, $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( 'thumb', $ext ) . '/archive/' .
            $this->getHashPath() . rawurlencode( $archiveName ) . "/";
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= rawurlencode( $suffix );
        }

        return $path;
    }

    function getZoneUrl( $zone, $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( $zone, $ext ) . '/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }

        return $path;
    }

    function getThumbUrl( $suffix = false ) {
        return $this->getZoneUrl( 'thumb', $suffix );
    }

    function getTranscodedUrl( $suffix = false ) {
        return $this->getZoneUrl( 'transcoded', $suffix );
    }

    function getVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/public/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }

        return $path;
    }

    function getArchiveVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/public/archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = substr( $path, 0, -1 );
        } else {
            $path .= rawurlencode( $suffix );
        }

        return $path;
    }

    function getThumbVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/thumb/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }

        return $path;
    }

    function isHashed() {
        $this->assertRepoDefined();

        return (bool)$this->repo->getHashLevels();
    }

    function readOnlyError() {
        throw new MWException( get_class( $this ) . ': write operations are not supported' );
    }

    function recordUpload( $oldver, $desc, $license = '', $copyStatus = '', $source = '',
        $watch = false, $timestamp = false, User $user = null
    ) {
        $this->readOnlyError();
    }

    function publish( $src, $flags = 0, array $options = [] ) {
        $this->readOnlyError();
    }

    function formatMetadata( $context = false ) {
        if ( !$this->getHandler() ) {
            return false;
        }

        return $this->getHandler()->formatMetadata( $this, $context );
    }

    function isLocal() {
        return $this->repo && $this->repo->isLocal();
    }

    function getRepoName() {
        return $this->repo ? $this->repo->getName() : 'unknown';
    }

    function getRepo() {
        return $this->repo;
    }

    function isOld() {
        return false;
    }

    function isDeleted( $field ) {
        return false;
    }

    function getVisibility() {
        return 0;
    }

    function wasDeleted() {
        $title = $this->getTitle();

        return $title && $title->isDeletedQuick();
    }

    function move( $target ) {
        $this->readOnlyError();
    }

    function delete( $reason, $suppress = false, $user = null ) {
        $this->readOnlyError();
    }

    function restore( $versions = [], $unsuppress = false ) {
        $this->readOnlyError();
    }

    function isMultipage() {
        return $this->getHandler() && $this->handler->isMultiPage( $this );
    }

    function pageCount() {
        if ( !isset( $this->pageCount ) ) {
            if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
                $this->pageCount = $this->handler->pageCount( $this );
            } else {
                $this->pageCount = false;
            }
        }

        return $this->pageCount;
    }

    static function scaleHeight( $srcWidth, $srcHeight, $dstWidth ) {
        // Exact integer multiply followed by division
        if ( $srcWidth == 0 ) {
            return 0;
        } else {
            return round( $srcHeight * $dstWidth / $srcWidth );
        }
    }

    function getImageSize( $filePath ) {
        if ( !$this->getHandler() ) {
            return false;
        }

        return $this->getHandler()->getImageSize( $this, $filePath );
    }

    function getDescriptionUrl() {
        if ( $this->repo ) {
            return $this->repo->getDescriptionUrl( $this->getName() );
        } else {
            return false;
        }
    }

    function getDescriptionText( $lang = false ) {
        global $wgLang;

        if ( !$this->repo || !$this->repo->fetchDescription ) {
            return false;
        }

        $lang = $lang ?: $wgLang;

        $renderUrl = $this->repo->getDescriptionRenderUrl( $this->getName(), $lang->getCode() );
        if ( $renderUrl ) {
            $cache = ObjectCache::getMainWANInstance();
            $key = $this->repo->getLocalCacheKey(
                'RemoteFileDescription',
                'url',
                $lang->getCode(),
                $this->getName()
            );

            return $cache->getWithSetCallback(
                $key,
                $this->repo->descriptionCacheExpiry ?: $cache::TTL_UNCACHEABLE,
                function ( $oldValue, &$ttl, array &$setOpts ) use ( $renderUrl ) {
                    wfDebug( "Fetching shared description from $renderUrl\n" );
                    $res = Http::get( $renderUrl, [], __METHOD__ );
                    if ( !$res ) {
                        $ttl = WANObjectCache::TTL_UNCACHEABLE;
                    }

                    return $res;
                }
            );
        }

        return false;
    }

    function getDescription( $audience = self::FOR_PUBLIC, User $user = null ) {
        return null;
    }

    function getTimestamp() {
        $this->assertRepoDefined();

        return $this->repo->getFileTimestamp( $this->getPath() );
    }

    public function getDescriptionTouched() {
        return false;
    }

    function getSha1() {
        $this->assertRepoDefined();

        return $this->repo->getFileSha1( $this->getPath() );
    }

    function getStorageKey() {
        $hash = $this->getSha1();
        if ( !$hash ) {
            return false;
        }
        $ext = $this->getExtension();
        $dotExt = $ext === '' ? '' : ".$ext";

        return $hash . $dotExt;
    }

    function userCan( $field, User $user = null ) {
        return true;
    }

    function getStreamHeaders() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getStreamHeaders( $this->getMetadata() );
        } else {
            return [];
        }
    }

    function getLongDesc() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getLongDesc( $this );
        } else {
            return MediaHandler::getGeneralLongDesc( $this );
        }
    }

    function getShortDesc() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getShortDesc( $this );
        } else {
            return MediaHandler::getGeneralShortDesc( $this );
        }
    }

    function getDimensionsString() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getDimensionsString( $this );
        } else {
            return '';
        }
    }

    function getRedirected() {
        return $this->redirected;
    }

    function getRedirectedTitle() {
        if ( $this->redirected ) {
            if ( !$this->redirectTitle ) {
                $this->redirectTitle = Title::makeTitle( NS_FILE, $this->redirected );
            }

            return $this->redirectTitle;
        }

        return null;
    }

    function redirectedFrom( $from ) {
        $this->redirected = $from;
    }

    function isMissing() {
        return false;
    }

    public function isCacheable() {
        return true;
    }

    protected function assertRepoDefined() {
        if ( !( $this->repo instanceof $this->repoClass ) ) {
            throw new MWException( "A {$this->repoClass} object is not set for this File.\n" );
        }
    }

    protected function assertTitleDefined() {
        if ( !( $this->title instanceof Title ) ) {
            throw new MWException( "A Title object is not set for this File.\n" );
        }
    }

    public function isExpensiveToThumbnail() {
        $handler = $this->getHandler();
        return $handler ? $handler->isExpensiveToThumbnail( $this ) : false;
    }

    public function isTransformedLocally() {
        return true;
    }
}