FileRepo.php

Go to the documentation of this file.

<?php
class FileRepo {
    const DELETE_SOURCE = 1;
    const OVERWRITE = 2;
    const OVERWRITE_SAME = 4;
    const SKIP_LOCKING = 8;

    protected $backend;
    protected $zones = array();

    var $thumbScriptUrl, $transformVia404;
    var $descBaseUrl, $scriptDirUrl, $scriptExtension, $articleUrl;
    var $fetchDescription, $initialCapital;
    var $pathDisclosureProtection = 'simple'; // 'paranoid'
    var $descriptionCacheExpiry, $url, $thumbUrl;
    var $hashLevels, $deletedHashLevels;
    protected $abbrvThreshold;

    var $fileFactory = array( 'UnregisteredLocalFile', 'newFromTitle' );
    var $oldFileFactory = false;
    var $fileFactoryKey = false, $oldFileFactoryKey = false;

    public function __construct( array $info = null ) {
        // Verify required settings presence
        if (
            $info === null
            || !array_key_exists( 'name', $info )
            || !array_key_exists( 'backend', $info )
        ) {
            throw new MWException( __CLASS__ . " requires an array of options having both 'name' and 'backend' keys.\n" );
        }

        // Required settings
        $this->name = $info['name'];
        if ( $info['backend'] instanceof FileBackend ) {
            $this->backend = $info['backend']; // useful for testing
        } else {
            $this->backend = FileBackendGroup::singleton()->get( $info['backend'] );
        }

        // Optional settings that can have no value
        $optionalSettings = array(
            'descBaseUrl', 'scriptDirUrl', 'articleUrl', 'fetchDescription',
            'thumbScriptUrl', 'pathDisclosureProtection', 'descriptionCacheExpiry',
            'scriptExtension'
        );
        foreach ( $optionalSettings as $var ) {
            if ( isset( $info[$var] ) ) {
                $this->$var = $info[$var];
            }
        }

        // Optional settings that have a default
        $this->initialCapital = isset( $info['initialCapital'] )
            ? $info['initialCapital']
            : MWNamespace::isCapitalized( NS_FILE );
        $this->url = isset( $info['url'] )
            ? $info['url']
            : false; // a subclass may set the URL (e.g. ForeignAPIRepo)
        if ( isset( $info['thumbUrl'] ) ) {
            $this->thumbUrl = $info['thumbUrl'];
        } else {
            $this->thumbUrl = $this->url ? "{$this->url}/thumb" : false;
        }
        $this->hashLevels = isset( $info['hashLevels'] )
            ? $info['hashLevels']
            : 2;
        $this->deletedHashLevels = isset( $info['deletedHashLevels'] )
            ? $info['deletedHashLevels']
            : $this->hashLevels;
        $this->transformVia404 = !empty( $info['transformVia404'] );
        $this->abbrvThreshold = isset( $info['abbrvThreshold'] )
            ? $info['abbrvThreshold']
            : 255;
        $this->isPrivate = !empty( $info['isPrivate'] );
        // Give defaults for the basic zones...
        $this->zones = isset( $info['zones'] ) ? $info['zones'] : array();
        foreach ( array( 'public', 'thumb', 'transcoded', 'temp', 'deleted' ) as $zone ) {
            if ( !isset( $this->zones[$zone]['container'] ) ) {
                $this->zones[$zone]['container'] = "{$this->name}-{$zone}";
            }
            if ( !isset( $this->zones[$zone]['directory'] ) ) {
                $this->zones[$zone]['directory'] = '';
            }
            if ( !isset( $this->zones[$zone]['urlsByExt'] ) ) {
                $this->zones[$zone]['urlsByExt'] = array();
            }
        }
    }

    public function getBackend() {
        return $this->backend;
    }

    public function getReadOnlyReason() {
        return $this->backend->getReadOnlyReason();
    }

    protected function initZones( $doZones = array() ) {
        $status = $this->newGood();
        foreach ( (array)$doZones as $zone ) {
            $root = $this->getZonePath( $zone );
            if ( $root === null ) {
                throw new MWException( "No '$zone' zone defined in the {$this->name} repo." );
            }
        }
        return $status;
    }

    public static function isVirtualUrl( $url ) {
        return substr( $url, 0, 9 ) == 'mwrepo://';
    }

    public function getVirtualUrl( $suffix = false ) {
        $path = 'mwrepo://' . $this->name;
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
        return $path;
    }

    public function getZoneUrl( $zone, $ext = null ) {
        if ( in_array( $zone, array( 'public', 'temp', 'thumb', 'transcoded' ) ) ) { // standard public zones
            if ( $ext !== null && isset( $this->zones[$zone]['urlsByExt'][$ext] ) ) {
                return $this->zones[$zone]['urlsByExt'][$ext]; // custom URL for extension/zone
            } elseif ( isset( $this->zones[$zone]['url'] ) ) {
                return $this->zones[$zone]['url']; // custom URL for zone
            }
        }
        switch ( $zone ) {
            case 'public':
                return $this->url;
            case 'temp':
                return "{$this->url}/temp";
            case 'deleted':
                return false; // no public URL
            case 'thumb':
                return $this->thumbUrl;
            case 'transcoded':
                return "{$this->url}/transcoded";
            default:
                return false;
        }
    }

    public function getZoneHandlerUrl( $zone ) {
        if ( isset( $this->zones[$zone]['handlerUrl'] )
            && in_array( $zone, array( 'public', 'temp', 'thumb', 'transcoded' ) ) )
        {
            return $this->zones[$zone]['handlerUrl'];
        }
        return false;
    }

    public function resolveVirtualUrl( $url ) {
        if ( substr( $url, 0, 9 ) != 'mwrepo://' ) {
            throw new MWException( __METHOD__ . ': unknown protocol' );
        }
        $bits = explode( '/', substr( $url, 9 ), 3 );
        if ( count( $bits ) != 3 ) {
            throw new MWException( __METHOD__ . ": invalid mwrepo URL: $url" );
        }
        list( $repo, $zone, $rel ) = $bits;
        if ( $repo !== $this->name ) {
            throw new MWException( __METHOD__ . ": fetching from a foreign repo is not supported" );
        }
        $base = $this->getZonePath( $zone );
        if ( !$base ) {
            throw new MWException( __METHOD__ . ": invalid zone: $zone" );
        }
        return $base . '/' . rawurldecode( $rel );
    }

    protected function getZoneLocation( $zone ) {
        if ( !isset( $this->zones[$zone] ) ) {
            return array( null, null ); // bogus
        }
        return array( $this->zones[$zone]['container'], $this->zones[$zone]['directory'] );
    }

    public function getZonePath( $zone ) {
        list( $container, $base ) = $this->getZoneLocation( $zone );
        if ( $container === null || $base === null ) {
            return null;
        }
        $backendName = $this->backend->getName();
        if ( $base != '' ) { // may not be set
            $base = "/{$base}";
        }
        return "mwstore://$backendName/{$container}{$base}";
    }

    public function newFile( $title, $time = false ) {
        $title = File::normalizeTitle( $title );
        if ( !$title ) {
            return null;
        }
        if ( $time ) {
            if ( $this->oldFileFactory ) {
                return call_user_func( $this->oldFileFactory, $title, $this, $time );
            } else {
                return false;
            }
        } else {
            return call_user_func( $this->fileFactory, $title, $this );
        }
    }

    public function findFile( $title, $options = array() ) {
        $title = File::normalizeTitle( $title );
        if ( !$title ) {
            return false;
        }
        $time = isset( $options['time'] ) ? $options['time'] : false;
        # First try the current version of the file to see if it precedes the timestamp
        $img = $this->newFile( $title );
        if ( !$img ) {
            return false;
        }
        if ( $img->exists() && ( !$time || $img->getTimestamp() == $time ) ) {
            return $img;
        }
        # Now try an old version of the file
        if ( $time !== false ) {
            $img = $this->newFile( $title, $time );
            if ( $img && $img->exists() ) {
                if ( !$img->isDeleted( File::DELETED_FILE ) ) {
                    return $img; // always OK
                } elseif ( !empty( $options['private'] ) && $img->userCan( File::DELETED_FILE ) ) {
                    return $img;
                }
            }
        }

        # Now try redirects
        if ( !empty( $options['ignoreRedirect'] ) ) {
            return false;
        }
        $redir = $this->checkRedirect( $title );
        if ( $redir && $title->getNamespace() == NS_FILE ) {
            $img = $this->newFile( $redir );
            if ( !$img ) {
                return false;
            }
            if ( $img->exists() ) {
                $img->redirectedFrom( $title->getDBkey() );
                return $img;
            }
        }
        return false;
    }

    public function findFiles( array $items ) {
        $result = array();
        foreach ( $items as $item ) {
            if ( is_array( $item ) ) {
                $title = $item['title'];
                $options = $item;
                unset( $options['title'] );
            } else {
                $title = $item;
                $options = array();
            }
            $file = $this->findFile( $title, $options );
            if ( $file ) {
                $result[$file->getTitle()->getDBkey()] = $file;
            }
        }
        return $result;
    }

    public function findFileFromKey( $sha1, $options = array() ) {
        $time = isset( $options['time'] ) ? $options['time'] : false;
        # First try to find a matching current version of a file...
        if ( $this->fileFactoryKey ) {
            $img = call_user_func( $this->fileFactoryKey, $sha1, $this, $time );
        } else {
            return false; // find-by-sha1 not supported
        }
        if ( $img && $img->exists() ) {
            return $img;
        }
        # Now try to find a matching old version of a file...
        if ( $time !== false && $this->oldFileFactoryKey ) { // find-by-sha1 supported?
            $img = call_user_func( $this->oldFileFactoryKey, $sha1, $this, $time );
            if ( $img && $img->exists() ) {
                if ( !$img->isDeleted( File::DELETED_FILE ) ) {
                    return $img; // always OK
                } elseif ( !empty( $options['private'] ) && $img->userCan( File::DELETED_FILE ) ) {
                    return $img;
                }
            }
        }
        return false;
    }

    public function findBySha1( $hash ) {
        return array();
    }

    public function findBySha1s( array $hashes ) {
        $result = array();
        foreach ( $hashes as $hash ) {
            $files = $this->findBySha1( $hash );
            if ( count( $files ) ) {
                $result[$hash] = $files;
            }
        }
        return $result;
    }

    public function findFilesByPrefix( $prefix, $limit ) {
        return array();
    }

    public function getRootUrl() {
        return $this->getZoneUrl( 'public' );
    }

    public function getThumbScriptUrl() {
        return $this->thumbScriptUrl;
    }

    public function canTransformVia404() {
        return $this->transformVia404;
    }

    public function getNameFromTitle( Title $title ) {
        global $wgContLang;
        if ( $this->initialCapital != MWNamespace::isCapitalized( NS_FILE ) ) {
            $name = $title->getUserCaseDBKey();
            if ( $this->initialCapital ) {
                $name = $wgContLang->ucfirst( $name );
            }
        } else {
            $name = $title->getDBkey();
        }
        return $name;
    }

    public function getRootDirectory() {
        return $this->getZonePath( 'public' );
    }

    public function getHashPath( $name ) {
        return self::getHashPathForLevel( $name, $this->hashLevels );
    }

    public function getTempHashPath( $suffix ) {
        $parts = explode( '!', $suffix, 2 ); // format is <timestamp>!<name> or just <name>
        $name = isset( $parts[1] ) ? $parts[1] : $suffix; // hash path is not based on timestamp
        return self::getHashPathForLevel( $name, $this->hashLevels );
    }

    protected static function getHashPathForLevel( $name, $levels ) {
        if ( $levels == 0 ) {
            return '';
        } else {
            $hash = md5( $name );
            $path = '';
            for ( $i = 1; $i <= $levels; $i++ ) {
                $path .= substr( $hash, 0, $i ) . '/';
            }
            return $path;
        }
    }

    public function getHashLevels() {
        return $this->hashLevels;
    }

    public function getName() {
        return $this->name;
    }

    public function makeUrl( $query = '', $entry = 'index' ) {
        if ( isset( $this->scriptDirUrl ) ) {
            $ext = isset( $this->scriptExtension ) ? $this->scriptExtension : '.php';
            return wfAppendQuery( "{$this->scriptDirUrl}/{$entry}{$ext}", $query );
        }
        return false;
    }

    public function getDescriptionUrl( $name ) {
        $encName = wfUrlencode( $name );
        if ( !is_null( $this->descBaseUrl ) ) {
            # "http://example.com/wiki/Image:"
            return $this->descBaseUrl . $encName;
        }
        if ( !is_null( $this->articleUrl ) ) {
            # "http://example.com/wiki/$1"
            #
            # We use "Image:" as the canonical namespace for
            # compatibility across all MediaWiki versions.
            return str_replace( '$1',
                "Image:$encName", $this->articleUrl );
        }
        if ( !is_null( $this->scriptDirUrl ) ) {
            # "http://example.com/w"
            #
            # We use "Image:" as the canonical namespace for
            # compatibility across all MediaWiki versions,
            # and just sort of hope index.php is right. ;)
            return $this->makeUrl( "title=Image:$encName" );
        }
        return false;
    }

    public function getDescriptionRenderUrl( $name, $lang = null ) {
        $query = 'action=render';
        if ( !is_null( $lang ) ) {
            $query .= '&uselang=' . $lang;
        }
        if ( isset( $this->scriptDirUrl ) ) {
            return $this->makeUrl(
                'title=' .
                wfUrlencode( 'Image:' . $name ) .
                "&$query" );
        } else {
            $descUrl = $this->getDescriptionUrl( $name );
            if ( $descUrl ) {
                return wfAppendQuery( $descUrl, $query );
            } else {
                return false;
            }
        }
    }

    public function getDescriptionStylesheetUrl() {
        if ( isset( $this->scriptDirUrl ) ) {
            return $this->makeUrl( 'title=MediaWiki:Filepage.css&' .
                wfArrayToCgi( Skin::getDynamicStylesheetQuery() ) );
        }
        return false;
    }

    public function store( $srcPath, $dstZone, $dstRel, $flags = 0 ) {
        $this->assertWritableRepo(); // fail out if read-only

        $status = $this->storeBatch( array( array( $srcPath, $dstZone, $dstRel ) ), $flags );
        if ( $status->successCount == 0 ) {
            $status->ok = false;
        }

        return $status;
    }

    public function storeBatch( array $triplets, $flags = 0 ) {
        $this->assertWritableRepo(); // fail out if read-only

        $status = $this->newGood();
        $backend = $this->backend; // convenience

        $operations = array();
        $sourceFSFilesToDelete = array(); // cleanup for disk source files
        // Validate each triplet and get the store operation...
        foreach ( $triplets as $triplet ) {
            list( $srcPath, $dstZone, $dstRel ) = $triplet;
            wfDebug( __METHOD__
                . "( \$src='$srcPath', \$dstZone='$dstZone', \$dstRel='$dstRel' )\n"
            );

            // Resolve destination path
            $root = $this->getZonePath( $dstZone );
            if ( !$root ) {
                throw new MWException( "Invalid zone: $dstZone" );
            }
            if ( !$this->validateFilename( $dstRel ) ) {
                throw new MWException( 'Validation error in $dstRel' );
            }
            $dstPath = "$root/$dstRel";
            $dstDir = dirname( $dstPath );
            // Create destination directories for this triplet
            if ( !$this->initDirectory( $dstDir )->isOK() ) {
                return $this->newFatal( 'directorycreateerror', $dstDir );
            }

            // Resolve source to a storage path if virtual
            $srcPath = $this->resolveToStoragePath( $srcPath );

            // Get the appropriate file operation
            if ( FileBackend::isStoragePath( $srcPath ) ) {
                $opName = ( $flags & self::DELETE_SOURCE ) ? 'move' : 'copy';
            } else {
                $opName = 'store';
                if ( $flags & self::DELETE_SOURCE ) {
                    $sourceFSFilesToDelete[] = $srcPath;
                }
            }
            $operations[] = array(
                'op' => $opName,
                'src' => $srcPath,
                'dst' => $dstPath,
                'overwrite' => $flags & self::OVERWRITE,
                'overwriteSame' => $flags & self::OVERWRITE_SAME,
            );
        }

        // Execute the store operation for each triplet
        $opts = array( 'force' => true );
        if ( $flags & self::SKIP_LOCKING ) {
            $opts['nonLocking'] = true;
        }
        $status->merge( $backend->doOperations( $operations, $opts ) );
        // Cleanup for disk source files...
        foreach ( $sourceFSFilesToDelete as $file ) {
            wfSuppressWarnings();
            unlink( $file ); // FS cleanup
            wfRestoreWarnings();
        }

        return $status;
    }

    public function cleanupBatch( array $files, $flags = 0 ) {
        $this->assertWritableRepo(); // fail out if read-only

        $status = $this->newGood();

        $operations = array();
        foreach ( $files as $path ) {
            if ( is_array( $path ) ) {
                // This is a pair, extract it
                list( $zone, $rel ) = $path;
                $path = $this->getZonePath( $zone ) . "/$rel";
            } else {
                // Resolve source to a storage path if virtual
                $path = $this->resolveToStoragePath( $path );
            }
            $operations[] = array( 'op' => 'delete', 'src' => $path );
        }
        // Actually delete files from storage...
        $opts = array( 'force' => true );
        if ( $flags & self::SKIP_LOCKING ) {
            $opts['nonLocking'] = true;
        }
        $status->merge( $this->backend->doOperations( $operations, $opts ) );

        return $status;
    }

    final public function quickImport( $src, $dst, $disposition = null ) {
        return $this->quickImportBatch( array( array( $src, $dst, $disposition ) ) );
    }

    final public function quickPurge( $path ) {
        return $this->quickPurgeBatch( array( $path ) );
    }

    public function quickCleanDir( $dir ) {
        $status = $this->newGood();
        $status->merge( $this->backend->clean(
            array( 'dir' => $this->resolveToStoragePath( $dir ) ) ) );

        return $status;
    }

    public function quickImportBatch( array $triples ) {
        $status = $this->newGood();
        $operations = array();
        foreach ( $triples as $triple ) {
            list( $src, $dst ) = $triple;
            $src = $this->resolveToStoragePath( $src );
            $dst = $this->resolveToStoragePath( $dst );
            $operations[] = array(
                'op' => FileBackend::isStoragePath( $src ) ? 'copy' : 'store',
                'src' => $src,
                'dst' => $dst,
                'disposition' => isset( $triple[2] ) ? $triple[2] : null
            );
            $status->merge( $this->initDirectory( dirname( $dst ) ) );
        }
        $status->merge( $this->backend->doQuickOperations( $operations ) );

        return $status;
    }

    public function quickPurgeBatch( array $paths ) {
        $status = $this->newGood();
        $operations = array();
        foreach ( $paths as $path ) {
            $operations[] = array(
                'op' => 'delete',
                'src' => $this->resolveToStoragePath( $path ),
                'ignoreMissingSource' => true
            );
        }
        $status->merge( $this->backend->doQuickOperations( $operations ) );

        return $status;
    }

    public function storeTemp( $originalName, $srcPath ) {
        $this->assertWritableRepo(); // fail out if read-only

        $date = MWTimestamp::getInstance()->format( 'YmdHis' );
        $hashPath = $this->getHashPath( $originalName );
        $dstUrlRel = $hashPath . $date . '!' . rawurlencode( $originalName );
        $virtualUrl = $this->getVirtualUrl( 'temp' ) . '/' . $dstUrlRel;

        $result = $this->quickImport( $srcPath, $virtualUrl );
        $result->value = $virtualUrl;

        return $result;
    }

    public function freeTemp( $virtualUrl ) {
        $this->assertWritableRepo(); // fail out if read-only

        $temp = $this->getVirtualUrl( 'temp' );
        if ( substr( $virtualUrl, 0, strlen( $temp ) ) != $temp ) {
            wfDebug( __METHOD__ . ": Invalid temp virtual URL\n" );
            return false;
        }

        return $this->quickPurge( $virtualUrl )->isOK();
    }

    public function concatenate( array $srcPaths, $dstPath, $flags = 0 ) {
        $this->assertWritableRepo(); // fail out if read-only

        $status = $this->newGood();

        $sources = array();
        foreach ( $srcPaths as $srcPath ) {
            // Resolve source to a storage path if virtual
            $source = $this->resolveToStoragePath( $srcPath );
            $sources[] = $source; // chunk to merge
        }

        // Concatenate the chunks into one FS file
        $params = array( 'srcs' => $sources, 'dst' => $dstPath );
        $status->merge( $this->backend->concatenate( $params ) );
        if ( !$status->isOK() ) {
            return $status;
        }

        // Delete the sources if required
        if ( $flags & self::DELETE_SOURCE ) {
            $status->merge( $this->quickPurgeBatch( $srcPaths ) );
        }

        // Make sure status is OK, despite any quickPurgeBatch() fatals
        $status->setResult( true );

        return $status;
    }

    public function publish(
        $srcPath, $dstRel, $archiveRel, $flags = 0, array $options = array()
    ) {
        $this->assertWritableRepo(); // fail out if read-only

        $status = $this->publishBatch(
            array( array( $srcPath, $dstRel, $archiveRel, $options ) ), $flags );
        if ( $status->successCount == 0 ) {
            $status->ok = false;
        }
        if ( isset( $status->value[0] ) ) {
            $status->value = $status->value[0];
        } else {
            $status->value = false;
        }

        return $status;
    }

    public function publishBatch( array $ntuples, $flags = 0 ) {
        $this->assertWritableRepo(); // fail out if read-only

        $backend = $this->backend; // convenience
        // Try creating directories
        $status = $this->initZones( 'public' );
        if ( !$status->isOK() ) {
            return $status;
        }

        $status = $this->newGood( array() );

        $operations = array();
        $sourceFSFilesToDelete = array(); // cleanup for disk source files
        // Validate each triplet and get the store operation...
        foreach ( $ntuples as $ntuple ) {
            list( $srcPath, $dstRel, $archiveRel ) = $ntuple;
            $options = isset( $ntuple[3] ) ? $ntuple[3] : array();
            // Resolve source to a storage path if virtual
            $srcPath = $this->resolveToStoragePath( $srcPath );
            if ( !$this->validateFilename( $dstRel ) ) {
                throw new MWException( 'Validation error in $dstRel' );
            }
            if ( !$this->validateFilename( $archiveRel ) ) {
                throw new MWException( 'Validation error in $archiveRel' );
            }

            $publicRoot = $this->getZonePath( 'public' );
            $dstPath = "$publicRoot/$dstRel";
            $archivePath = "$publicRoot/$archiveRel";

            $dstDir = dirname( $dstPath );
            $archiveDir = dirname( $archivePath );
            // Abort immediately on directory creation errors since they're likely to be repetitive
            if ( !$this->initDirectory( $dstDir )->isOK() ) {
                return $this->newFatal( 'directorycreateerror', $dstDir );
            }
            if ( !$this->initDirectory( $archiveDir )->isOK() ) {
                return $this->newFatal( 'directorycreateerror', $archiveDir );
            }

            // Set any desired headers to be use in GET/HEAD responses
            $headers = isset( $options['headers'] ) ? $options['headers'] : array();

            // Archive destination file if it exists.
            // This will check if the archive file also exists and fail if does.
            // This is a sanity check to avoid data loss. On Windows and Linux,
            // copy() will overwrite, so the existence check is vulnerable to
            // race conditions unless an functioning LockManager is used.
            // LocalFile also uses SELECT FOR UPDATE for synchronization.
            $operations[] = array(
                'op' => 'copy',
                'src' => $dstPath,
                'dst' => $archivePath,
                'ignoreMissingSource' => true
            );

            // Copy (or move) the source file to the destination
            if ( FileBackend::isStoragePath( $srcPath ) ) {
                if ( $flags & self::DELETE_SOURCE ) {
                    $operations[] = array(
                        'op' => 'move',
                        'src' => $srcPath,
                        'dst' => $dstPath,
                        'overwrite' => true, // replace current
                        'headers' => $headers
                    );
                } else {
                    $operations[] = array(
                        'op' => 'copy',
                        'src' => $srcPath,
                        'dst' => $dstPath,
                        'overwrite' => true, // replace current
                        'headers' => $headers
                    );
                }
            } else { // FS source path
                $operations[] = array(
                    'op' => 'store',
                    'src' => $srcPath,
                    'dst' => $dstPath,
                    'overwrite' => true, // replace current
                    'headers' => $headers
                );
                if ( $flags & self::DELETE_SOURCE ) {
                    $sourceFSFilesToDelete[] = $srcPath;
                }
            }
        }

        // Execute the operations for each triplet
        $status->merge( $backend->doOperations( $operations ) );
        // Find out which files were archived...
        foreach ( $ntuples as $i => $ntuple ) {
            list( , , $archiveRel ) = $ntuple;
            $archivePath = $this->getZonePath( 'public' ) . "/$archiveRel";
            if ( $this->fileExists( $archivePath ) ) {
                $status->value[$i] = 'archived';
            } else {
                $status->value[$i] = 'new';
            }
        }
        // Cleanup for disk source files...
        foreach ( $sourceFSFilesToDelete as $file ) {
            wfSuppressWarnings();
            unlink( $file ); // FS cleanup
            wfRestoreWarnings();
        }

        return $status;
    }

    protected function initDirectory( $dir ) {
        $path = $this->resolveToStoragePath( $dir );
        list( , $container, ) = FileBackend::splitStoragePath( $path );

        $params = array( 'dir' => $path );
        if ( $this->isPrivate || $container === $this->zones['deleted']['container'] ) {
            # Take all available measures to prevent web accessibility of new deleted
            # directories, in case the user has not configured offline storage
            $params = array( 'noAccess' => true, 'noListing' => true ) + $params;
        }

        return $this->backend->prepare( $params );
    }

    public function cleanDir( $dir ) {
        $this->assertWritableRepo(); // fail out if read-only

        $status = $this->newGood();
        $status->merge( $this->backend->clean(
            array( 'dir' => $this->resolveToStoragePath( $dir ) ) ) );

        return $status;
    }

    public function fileExists( $file ) {
        $result = $this->fileExistsBatch( array( $file ) );
        return $result[0];
    }

    public function fileExistsBatch( array $files ) {
        $result = array();
        foreach ( $files as $key => $file ) {
            $file = $this->resolveToStoragePath( $file );
            $result[$key] = $this->backend->fileExists( array( 'src' => $file ) );
        }
        return $result;
    }

    public function delete( $srcRel, $archiveRel ) {
        $this->assertWritableRepo(); // fail out if read-only

        return $this->deleteBatch( array( array( $srcRel, $archiveRel ) ) );
    }

    public function deleteBatch( array $sourceDestPairs ) {
        $this->assertWritableRepo(); // fail out if read-only

        // Try creating directories
        $status = $this->initZones( array( 'public', 'deleted' ) );
        if ( !$status->isOK() ) {
            return $status;
        }

        $status = $this->newGood();

        $backend = $this->backend; // convenience
        $operations = array();
        // Validate filenames and create archive directories
        foreach ( $sourceDestPairs as $pair ) {
            list( $srcRel, $archiveRel ) = $pair;
            if ( !$this->validateFilename( $srcRel ) ) {
                throw new MWException( __METHOD__ . ':Validation error in $srcRel' );
            } elseif ( !$this->validateFilename( $archiveRel ) ) {
                throw new MWException( __METHOD__ . ':Validation error in $archiveRel' );
            }

            $publicRoot = $this->getZonePath( 'public' );
            $srcPath = "{$publicRoot}/$srcRel";

            $deletedRoot = $this->getZonePath( 'deleted' );
            $archivePath = "{$deletedRoot}/{$archiveRel}";
            $archiveDir = dirname( $archivePath ); // does not touch FS

            // Create destination directories
            if ( !$this->initDirectory( $archiveDir )->isOK() ) {
                return $this->newFatal( 'directorycreateerror', $archiveDir );
            }

            $operations[] = array(
                'op' => 'move',
                'src' => $srcPath,
                'dst' => $archivePath,
                // We may have 2+ identical files being deleted,
                // all of which will map to the same destination file
                'overwriteSame' => true // also see bug 31792
            );
        }

        // Move the files by execute the operations for each pair.
        // We're now committed to returning an OK result, which will
        // lead to the files being moved in the DB also.
        $opts = array( 'force' => true );
        $status->merge( $backend->doOperations( $operations, $opts ) );

        return $status;
    }

    public function cleanupDeletedBatch( array $storageKeys ) {
        $this->assertWritableRepo();
    }

    public function getDeletedHashPath( $key ) {
        if ( strlen( $key ) < 31 ) {
            throw new MWException( "Invalid storage key '$key'." );
        }
        $path = '';
        for ( $i = 0; $i < $this->deletedHashLevels; $i++ ) {
            $path .= $key[$i] . '/';
        }
        return $path;
    }

    protected function resolveToStoragePath( $path ) {
        if ( $this->isVirtualUrl( $path ) ) {
            return $this->resolveVirtualUrl( $path );
        }
        return $path;
    }

    public function getLocalCopy( $virtualUrl ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        return $this->backend->getLocalCopy( array( 'src' => $path ) );
    }

    public function getLocalReference( $virtualUrl ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        return $this->backend->getLocalReference( array( 'src' => $path ) );
    }

    public function getFileProps( $virtualUrl ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        return $this->backend->getFileProps( array( 'src' => $path ) );
    }

    public function getFileTimestamp( $virtualUrl ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        return $this->backend->getFileTimestamp( array( 'src' => $path ) );
    }

    public function getFileSize( $virtualUrl ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        return $this->backend->getFileSize( array( 'src' => $path ) );
    }

    public function getFileSha1( $virtualUrl ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        return $this->backend->getFileSha1Base36( array( 'src' => $path ) );
    }

    public function streamFile( $virtualUrl, $headers = array() ) {
        $path = $this->resolveToStoragePath( $virtualUrl );
        $params = array( 'src' => $path, 'headers' => $headers );
        return $this->backend->streamFile( $params )->isOK();
    }

    public function enumFiles( $callback ) {
        $this->enumFilesInStorage( $callback );
    }

    protected function enumFilesInStorage( $callback ) {
        $publicRoot = $this->getZonePath( 'public' );
        $numDirs = 1 << ( $this->hashLevels * 4 );
        // Use a priori assumptions about directory structure
        // to reduce the tree height of the scanning process.
        for ( $flatIndex = 0; $flatIndex < $numDirs; $flatIndex++ ) {
            $hexString = sprintf( "%0{$this->hashLevels}x", $flatIndex );
            $path = $publicRoot;
            for ( $hexPos = 0; $hexPos < $this->hashLevels; $hexPos++ ) {
                $path .= '/' . substr( $hexString, 0, $hexPos + 1 );
            }
            $iterator = $this->backend->getFileList( array( 'dir' => $path ) );
            foreach ( $iterator as $name ) {
                // Each item returned is a public file
                call_user_func( $callback, "{$path}/{$name}" );
            }
        }
    }

    public function validateFilename( $filename ) {
        if ( strval( $filename ) == '' ) {
            return false;
        }
        return FileBackend::isPathTraversalFree( $filename );
    }

    function getErrorCleanupFunction() {
        switch ( $this->pathDisclosureProtection ) {
            case 'none':
            case 'simple': // b/c
                $callback = array( $this, 'passThrough' );
                break;
            default: // 'paranoid'
                $callback = array( $this, 'paranoidClean' );
        }
        return $callback;
    }

    function paranoidClean( $param ) {
        return '[hidden]';
    }

    function passThrough( $param ) {
        return $param;
    }

    public function newFatal( $message /*, parameters...*/ ) {
        $params = func_get_args();
        array_unshift( $params, $this );
        return call_user_func_array( array( 'FileRepoStatus', 'newFatal' ), $params );
    }

    public function newGood( $value = null ) {
        return FileRepoStatus::newGood( $this, $value );
    }

    public function checkRedirect( Title $title ) {
        return false;
    }

    public function invalidateImageRedirect( Title $title ) {}

    public function getDisplayName() {
        // We don't name our own repo, return nothing
        if ( $this->isLocal() ) {
            return null;
        }
        // 'shared-repo-name-wikimediacommons' is used when $wgUseInstantCommons = true
        return wfMessageFallback( 'shared-repo-name-' . $this->name, 'shared-repo' )->text();
    }

    public function nameForThumb( $name ) {
        if ( strlen( $name ) > $this->abbrvThreshold ) {
            $ext = FileBackend::extensionFromPath( $name );
            $name = ( $ext == '' ) ? 'thumbnail' : "thumbnail.$ext";
        }
        return $name;
    }

    public function isLocal() {
        return $this->getName() == 'local';
    }

    public function getSharedCacheKey( /*...*/ ) {
        return false;
    }

    public function getLocalCacheKey( /*...*/ ) {
        $args = func_get_args();
        array_unshift( $args, 'filerepo', $this->getName() );
        return call_user_func_array( 'wfMemcKey', $args );
    }

    public function getTempRepo() {
        return new TempFileRepo( array(
            'name' => "{$this->name}-temp",
            'backend' => $this->backend,
            'zones' => array(
                'public' => array(
                    'container' => $this->zones['temp']['container'],
                    'directory' => $this->zones['temp']['directory']
                ),
                'thumb' => array(
                    'container' => $this->zones['thumb']['container'],
                    'directory' => ( $this->zones['thumb']['directory'] == '' )
                        ? 'temp'
                        : $this->zones['thumb']['directory'] . '/temp'
                ),
                'transcoded' => array(
                    'container' => $this->zones['transcoded']['container'],
                    'directory' => ( $this->zones['transcoded']['directory'] == '' )
                        ? 'temp'
                        : $this->zones['transcoded']['directory'] . '/temp'
                )
            ),
            'url' => $this->getZoneUrl( 'temp' ),
            'thumbUrl' => $this->getZoneUrl( 'thumb' ) . '/temp',
            'transcodedUrl' => $this->getZoneUrl( 'transcoded' ) . '/temp',
            'hashLevels' => $this->hashLevels // performance
        ) );
    }

    public function getUploadStash( User $user = null ) {
        return new UploadStash( $this, $user );
    }

    protected function assertWritableRepo() {}


    public function getInfo() {
        return array(
            'name' => $this->getName(),
            'displayname' => $this->getDisplayName(),
            'rootUrl' => $this->getRootUrl(),
            'local' => $this->isLocal(),
        );
    }
}

class TempFileRepo extends FileRepo {
    public function getTempRepo() {
        throw new MWException( "Cannot get a temp repo from a temp repo." );
    }
}